diff --git a/.cursorrules b/.cursorrules
index a6b29285..83a208f5 100644
--- a/.cursorrules
+++ b/.cursorrules
@@ -3,6 +3,7 @@
 ## ⚠️ CRITICAL DEVELOPMENT RULES ⚠️
 
 ### 🚨 NEVER COMMIT DIRECTLY TO MASTER/MAIN BRANCH 🚨
+
 - **This is the most important rule - NEVER modify code directly on main or master branch**
 - **Always work on feature branches and use pull requests for all changes**
 - **Any direct commits to master/main branch are strictly forbidden**
@@ -15,23 +16,27 @@
   6. Create a pull request for review
 
 ## Project Overview
+
 RustFS is a high-performance distributed object storage system written in Rust, compatible with S3 API. The project adopts a modular architecture, supporting erasure coding storage, multi-tenant management, observability, and other enterprise-level features.
 
 ## Core Architecture Principles
 
 ### 1. Modular Design
+
 - Project uses Cargo workspace structure, containing multiple independent crates
 - Core modules: `rustfs` (main service), `ecstore` (erasure coding storage), `common` (shared components)
 - Functional modules: `iam` (identity management), `madmin` (management interface), `crypto` (encryption), etc.
 - Tool modules: `cli` (command line tool), `crates/*` (utility libraries)
 
 ### 2. Asynchronous Programming Pattern
+
 - Comprehensive use of `tokio` async runtime
 - Prioritize `async/await` syntax
 - Use `async-trait` for async methods in traits
 - Avoid blocking operations, use `spawn_blocking` when necessary
 
 ### 3. Error Handling Strategy
+
 - **Use modular, type-safe error handling with `thiserror`**
 - Each module should define its own error type using `thiserror::Error` derive macro
 - Support error chains and context information through `#[from]` and `#[source]` attributes
@@ -54,6 +59,7 @@ RustFS is a high-performance distributed object storage system written in Rust,
 ## Code Style Guidelines
 
 ### 1. Formatting Configuration
+
 ```toml
 max_width = 130
 fn_call_width = 90
@@ -69,21 +75,25 @@ single_line_let_else_max_width = 100
 Before every commit, you **MUST**:
 
 1. **Format your code**:
+
    ```bash
    cargo fmt --all
    ```
 
 2. **Verify formatting**:
+
    ```bash
    cargo fmt --all --check
    ```
 
 3. **Pass clippy checks**:
+
    ```bash
    cargo clippy --all-targets --all-features -- -D warnings
    ```
 
 4. **Ensure compilation**:
+
    ```bash
    cargo check --all-targets
    ```
@@ -158,6 +168,7 @@ Example output when formatting fails:
 ```
 
 ### 3. Naming Conventions
+
 - Use `snake_case` for functions, variables, modules
 - Use `PascalCase` for types, traits, enums
 - Constants use `SCREAMING_SNAKE_CASE`
@@ -167,6 +178,7 @@ Example output when formatting fails:
 - Choose names that clearly express the purpose and intent
 
 ### 4. Type Declaration Guidelines
+
 - **Prefer type inference over explicit type declarations** when the type is obvious from context
 - Let the Rust compiler infer types whenever possible to reduce verbosity and improve maintainability
 - Only specify types explicitly when:
@@ -176,6 +188,7 @@ Example output when formatting fails:
   - Needed to resolve ambiguity between multiple possible types
 
 **Good examples (prefer these):**
+
 ```rust
 // Compiler can infer the type
 let items = vec![1, 2, 3, 4];
@@ -187,6 +200,7 @@ let filtered: Vec<_> = items.iter().filter(|&&x| x > 2).collect();
 ```
 
 **Avoid unnecessary explicit types:**
+
 ```rust
 // Unnecessary - type is obvious
 let items: Vec<i32> = vec![1, 2, 3, 4];
@@ -195,6 +209,7 @@ let result: ProcessResult = process_data(&input);
 ```
 
 **When explicit types are beneficial:**
+
 ```rust
 // API boundaries - always specify types
 pub fn process_data(input: &[u8]) -> Result<ProcessResult, Error> { ... }
@@ -207,6 +222,7 @@ let cache: HashMap<String, Arc<Mutex<CacheEntry>>> = HashMap::new();
 ```
 
 ### 5. Documentation Comments
+
 - Public APIs must have documentation comments
 - Use `///` for documentation comments
 - Complex functions add `# Examples` and `# Parameters` descriptions
@@ -215,6 +231,7 @@ let cache: HashMap<String, Arc<Mutex<CacheEntry>>> = HashMap::new();
 - Avoid meaningless comments like "debug 111" or placeholder text
 
 ### 6. Import Guidelines
+
 - Standard library imports first
 - Third-party crate imports in the middle
 - Project internal imports last
@@ -223,6 +240,7 @@ let cache: HashMap<String, Arc<Mutex<CacheEntry>>> = HashMap::new();
 ## Asynchronous Programming Guidelines
 
 ### 1. Trait Definition
+
 ```rust
 #[async_trait::async_trait]
 pub trait StorageAPI: Send + Sync {
@@ -231,6 +249,7 @@ pub trait StorageAPI: Send + Sync {
 ```
 
 ### 2. Error Handling
+
 ```rust
 // Use ? operator to propagate errors
 async fn example_function() -> Result<()> {
@@ -241,6 +260,7 @@ async fn example_function() -> Result<()> {
 ```
 
 ### 3. Concurrency Control
+
 - Use `Arc` and `Mutex`/`RwLock` for shared state management
 - Prioritize async locks from `tokio::sync`
 - Avoid holding locks for long periods
@@ -248,6 +268,7 @@ async fn example_function() -> Result<()> {
 ## Logging and Tracing Guidelines
 
 ### 1. Tracing Usage
+
 ```rust
 #[tracing::instrument(skip(self, data))]
 async fn process_data(&self, data: &[u8]) -> Result<()> {
@@ -257,6 +278,7 @@ async fn process_data(&self, data: &[u8]) -> Result<()> {
 ```
 
 ### 2. Log Levels
+
 - `error!`: System errors requiring immediate attention
 - `warn!`: Warning information that may affect functionality
 - `info!`: Important business information
@@ -264,6 +286,7 @@ async fn process_data(&self, data: &[u8]) -> Result<()> {
 - `trace!`: Detailed execution paths
 
 ### 3. Structured Logging
+
 ```rust
 info!(
     counter.rustfs_api_requests_total = 1_u64,
@@ -276,22 +299,23 @@ info!(
 ## Error Handling Guidelines
 
 ### 1. Error Type Definition
+
 ```rust
 // Use thiserror for module-specific error types
 #[derive(thiserror::Error, Debug)]
 pub enum MyError {
     #[error("IO error: {0}")]
     Io(#[from] std::io::Error),
-    
+
     #[error("Storage error: {0}")]
     Storage(#[from] ecstore::error::StorageError),
-    
+
     #[error("Custom error: {message}")]
     Custom { message: String },
-    
+
     #[error("File not found: {path}")]
     FileNotFound { path: String },
-    
+
     #[error("Invalid configuration: {0}")]
     InvalidConfig(String),
 }
@@ -301,6 +325,7 @@ pub type Result<T> = core::result::Result<T, MyError>;
 ```
 
 ### 2. Error Helper Methods
+
 ```rust
 impl MyError {
     /// Create error from any compatible error type
@@ -314,6 +339,7 @@ impl MyError {
 ```
 
 ### 3. Error Conversion Between Modules
+
 ```rust
 // Convert between different module error types
 impl From<ecstore::error::StorageError> for MyError {
@@ -340,6 +366,7 @@ impl From<MyError> for ecstore::error::StorageError {
 ```
 
 ### 4. Error Context and Propagation
+
 ```rust
 // Use ? operator for clean error propagation
 async fn example_function() -> Result<()> {
@@ -351,14 +378,15 @@ async fn example_function() -> Result<()> {
 // Add context to errors
 fn process_with_context(path: &str) -> Result<()> {
     std::fs::read(path)
-        .map_err(|e| MyError::Custom { 
-            message: format!("Failed to read {}: {}", path, e) 
+        .map_err(|e| MyError::Custom {
+            message: format!("Failed to read {}: {}", path, e)
         })?;
     Ok(())
 }
 ```
 
 ### 5. API Error Conversion (S3 Example)
+
 ```rust
 // Convert storage errors to API-specific errors
 use s3s::{S3Error, S3ErrorCode};
@@ -404,6 +432,7 @@ impl From<ApiError> for S3Error {
 ### 6. Error Handling Best Practices
 
 #### Pattern Matching and Error Classification
+
 ```rust
 // Use pattern matching for specific error handling
 async fn handle_storage_operation() -> Result<()> {
@@ -415,8 +444,8 @@ async fn handle_storage_operation() -> Result<()> {
         }
         Err(ecstore::error::StorageError::BucketNotFound(bucket)) => {
             error!("Bucket not found: {}", bucket);
-            Err(MyError::Custom { 
-                message: format!("Bucket {} does not exist", bucket) 
+            Err(MyError::Custom {
+                message: format!("Bucket {} does not exist", bucket)
             })
         }
         Err(e) => {
@@ -428,30 +457,32 @@ async fn handle_storage_operation() -> Result<()> {
 ```
 
 #### Error Aggregation and Reporting
+
 ```rust
 // Collect and report multiple errors
 pub fn validate_configuration(config: &Config) -> Result<()> {
     let mut errors = Vec::new();
-    
+
     if config.bucket_name.is_empty() {
         errors.push("Bucket name cannot be empty");
     }
-    
+
     if config.region.is_empty() {
         errors.push("Region must be specified");
     }
-    
+
     if !errors.is_empty() {
         return Err(MyError::Custom {
             message: format!("Configuration validation failed: {}", errors.join(", "))
         });
     }
-    
+
     Ok(())
 }
 ```
 
 #### Contextual Error Information
+
 ```rust
 // Add operation context to errors
 #[tracing::instrument(skip(self))]
@@ -468,11 +499,13 @@ async fn upload_file(&self, bucket: &str, key: &str, data: Vec<u8>) -> Result<()
 ## Performance Optimization Guidelines
 
 ### 1. Memory Management
+
 - Use `Bytes` instead of `Vec<u8>` for zero-copy operations
 - Avoid unnecessary cloning, use reference passing
 - Use `Arc` for sharing large objects
 
 ### 2. Concurrency Optimization
+
 ```rust
 // Use join_all for concurrent operations
 let futures = disks.iter().map(|disk| disk.operation());
@@ -480,12 +513,14 @@ let results = join_all(futures).await;
 ```
 
 ### 3. Caching Strategy
+
 - Use `lazy_static` or `OnceCell` for global caching
 - Implement LRU cache to avoid memory leaks
 
 ## Testing Guidelines
 
 ### 1. Unit Tests
+
 ```rust
 #[cfg(test)]
 mod tests {
@@ -507,10 +542,10 @@ mod tests {
     #[test]
     fn test_error_conversion() {
         use ecstore::error::StorageError;
-        
+
         let storage_err = StorageError::BucketNotFound("test-bucket".to_string());
         let api_err: ApiError = storage_err.into();
-        
+
         assert_eq!(api_err.code, S3ErrorCode::NoSuchBucket);
         assert!(api_err.message.contains("test-bucket"));
         assert!(api_err.source.is_some());
@@ -520,7 +555,7 @@ mod tests {
     fn test_error_types() {
         let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "file not found");
         let my_err = MyError::Io(io_err);
-        
+
         // Test error matching
         match my_err {
             MyError::Io(_) => {}, // Expected
@@ -532,7 +567,7 @@ mod tests {
     fn test_error_context() {
         let result = process_with_context("nonexistent_file.txt");
         assert!(result.is_err());
-        
+
         let err = result.unwrap_err();
         match err {
             MyError::Custom { message } => {
@@ -546,10 +581,12 @@ mod tests {
 ```
 
 ### 2. Integration Tests
+
 - Use `e2e_test` module for end-to-end testing
 - Simulate real storage environments
 
 ### 3. Test Quality Standards
+
 - Write meaningful test cases that verify actual functionality
 - Avoid placeholder or debug content like "debug 111", "test test", etc.
 - Use descriptive test names that clearly indicate what is being tested
@@ -559,9 +596,11 @@ mod tests {
 ## Cross-Platform Compatibility Guidelines
 
 ### 1. CPU Architecture Compatibility
+
 - **Always consider multi-platform and different CPU architecture compatibility** when writing code
 - Support major architectures: x86_64, aarch64 (ARM64), and other target platforms
 - Use conditional compilation for architecture-specific code:
+
 ```rust
 #[cfg(target_arch = "x86_64")]
 fn optimized_x86_64_function() { /* x86_64 specific implementation */ }
@@ -574,16 +613,19 @@ fn generic_function() { /* Generic fallback implementation */ }
 ```
 
 ### 2. Platform-Specific Dependencies
+
 - Use feature flags for platform-specific dependencies
 - Provide fallback implementations for unsupported platforms
 - Test on multiple architectures in CI/CD pipeline
 
 ### 3. Endianness Considerations
+
 - Use explicit byte order conversion when dealing with binary data
 - Prefer `to_le_bytes()`, `from_le_bytes()` for consistent little-endian format
 - Use `byteorder` crate for complex binary format handling
 
 ### 4. SIMD and Performance Optimizations
+
 - Use portable SIMD libraries like `wide` or `packed_simd`
 - Provide fallback implementations for non-SIMD architectures
 - Use runtime feature detection when appropriate
@@ -591,10 +633,12 @@ fn generic_function() { /* Generic fallback implementation */ }
 ## Security Guidelines
 
 ### 1. Memory Safety
+
 - Disable `unsafe` code (workspace.lints.rust.unsafe_code = "deny")
 - Use `rustls` instead of `openssl`
 
 ### 2. Authentication and Authorization
+
 ```rust
 // Use IAM system for permission checks
 let identity = iam.authenticate(&access_key, &secret_key).await?;
@@ -604,11 +648,13 @@ iam.authorize(&identity, &action, &resource).await?;
 ## Configuration Management Guidelines
 
 ### 1. Environment Variables
+
 - Use `RUSTFS_` prefix
 - Support both configuration files and environment variables
 - Provide reasonable default values
 
 ### 2. Configuration Structure
+
 ```rust
 #[derive(Debug, Deserialize, Clone)]
 pub struct Config {
@@ -622,10 +668,12 @@ pub struct Config {
 ## Dependency Management Guidelines
 
 ### 1. Workspace Dependencies
+
 - Manage versions uniformly at workspace level
 - Use `workspace = true` to inherit configuration
 
 ### 2. Feature Flags
+
 ```rust
 [features]
 default = ["file"]
@@ -636,15 +684,18 @@ kafka = ["dep:rdkafka"]
 ## Deployment and Operations Guidelines
 
 ### 1. Containerization
+
 - Provide Dockerfile and docker-compose configuration
 - Support multi-stage builds to optimize image size
 
 ### 2. Observability
+
 - Integrate OpenTelemetry for distributed tracing
 - Support Prometheus metrics collection
 - Provide Grafana dashboards
 
 ### 3. Health Checks
+
 ```rust
 // Implement health check endpoint
 async fn health_check() -> Result<HealthStatus> {
@@ -655,6 +706,7 @@ async fn health_check() -> Result<HealthStatus> {
 ## Code Review Checklist
 
 ### 1. **Code Formatting and Quality (MANDATORY)**
+
 - [ ] **Code is properly formatted** (`cargo fmt --all --check` passes)
 - [ ] **All clippy warnings are resolved** (`cargo clippy --all-targets --all-features -- -D warnings` passes)
 - [ ] **Code compiles successfully** (`cargo check --all-targets` passes)
@@ -662,27 +714,32 @@ async fn health_check() -> Result<HealthStatus> {
 - [ ] **No formatting-related changes** mixed with functional changes (separate commits)
 
 ### 2. Functionality
+
 - [ ] Are all error cases properly handled?
 - [ ] Is there appropriate logging?
 - [ ] Is there necessary test coverage?
 
 ### 3. Performance
+
 - [ ] Are unnecessary memory allocations avoided?
 - [ ] Are async operations used correctly?
 - [ ] Are there potential deadlock risks?
 
 ### 4. Security
+
 - [ ] Are input parameters properly validated?
 - [ ] Are there appropriate permission checks?
 - [ ] Is information leakage avoided?
 
 ### 5. Cross-Platform Compatibility
+
 - [ ] Does the code work on different CPU architectures (x86_64, aarch64)?
 - [ ] Are platform-specific features properly gated with conditional compilation?
 - [ ] Is byte order handling correct for binary data?
 - [ ] Are there appropriate fallback implementations for unsupported platforms?
 
 ### 6. Code Commits and Documentation
+
 - [ ] Does it comply with [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/)?
 - [ ] Are commit messages concise and under 72 characters for the title line?
 - [ ] Commit titles should be concise and in English, avoid Chinese
@@ -691,6 +748,7 @@ async fn health_check() -> Result<HealthStatus> {
 ## Common Patterns and Best Practices
 
 ### 1. Resource Management
+
 ```rust
 // Use RAII pattern for resource management
 pub struct ResourceGuard {
@@ -705,6 +763,7 @@ impl Drop for ResourceGuard {
 ```
 
 ### 2. Dependency Injection
+
 ```rust
 // Use dependency injection pattern
 pub struct Service {
@@ -714,6 +773,7 @@ pub struct Service {
 ```
 
 ### 3. Graceful Shutdown
+
 ```rust
 // Implement graceful shutdown
 async fn shutdown_gracefully(shutdown_rx: &mut Receiver<()>) {
@@ -732,16 +792,19 @@ async fn shutdown_gracefully(shutdown_rx: &mut Receiver<()>) {
 ## Domain-Specific Guidelines
 
 ### 1. Storage Operations
+
 - All storage operations must support erasure coding
 - Implement read/write quorum mechanisms
 - Support data integrity verification
 
 ### 2. Network Communication
+
 - Use gRPC for internal service communication
 - HTTP/HTTPS support for S3-compatible API
 - Implement connection pooling and retry mechanisms
 
 ### 3. Metadata Management
+
 - Use FlatBuffers for serialization
 - Support version control and migration
 - Implement metadata caching
@@ -751,11 +814,12 @@ These rules should serve as guiding principles when developing the RustFS projec
 ### 4. Code Operations
 
 #### Branch Management
- - **🚨 CRITICAL: NEVER modify code directly on main or master branch - THIS IS ABSOLUTELY FORBIDDEN 🚨**
- - **⚠️ ANY DIRECT COMMITS TO MASTER/MAIN WILL BE REJECTED AND MUST BE REVERTED IMMEDIATELY ⚠️**
- - **Always work on feature branches - NO EXCEPTIONS**
- - Always check the .cursorrules file before starting to ensure you understand the project guidelines
- - **MANDATORY workflow for ALL changes:**
+
+- **🚨 CRITICAL: NEVER modify code directly on main or master branch - THIS IS ABSOLUTELY FORBIDDEN 🚨**
+- **⚠️ ANY DIRECT COMMITS TO MASTER/MAIN WILL BE REJECTED AND MUST BE REVERTED IMMEDIATELY ⚠️**
+- **Always work on feature branches - NO EXCEPTIONS**
+- Always check the .cursorrules file before starting to ensure you understand the project guidelines
+- **MANDATORY workflow for ALL changes:**
    1. `git checkout main` (switch to main branch)
    2. `git pull` (get latest changes)
    3. `git checkout -b feat/your-feature-name` (create and switch to feature branch)
@@ -763,28 +827,54 @@ These rules should serve as guiding principles when developing the RustFS projec
    5. Test thoroughly before committing
    6. Commit and push to the feature branch
    7. Create a pull request for code review
- - Use descriptive branch names following the pattern: `feat/feature-name`, `fix/issue-name`, `refactor/component-name`, etc.
- - **Double-check current branch before ANY commit: `git branch` to ensure you're NOT on main/master**
- - Ensure all changes are made on feature branches and merged through pull requests
+- Use descriptive branch names following the pattern: `feat/feature-name`, `fix/issue-name`, `refactor/component-name`, etc.
+- **Double-check current branch before ANY commit: `git branch` to ensure you're NOT on main/master**
+- Ensure all changes are made on feature branches and merged through pull requests
 
 #### Development Workflow
- - Use English for all code comments, documentation, and variable names
- - Write meaningful and descriptive names for variables, functions, and methods
- - Avoid meaningless test content like "debug 111" or placeholder values
- - Before each change, carefully read the existing code to ensure you understand the code structure and implementation, do not break existing logic implementation, do not introduce new issues
- - Ensure each change provides sufficient test cases to guarantee code correctness
- - Do not arbitrarily modify numbers and constants in test cases, carefully analyze their meaning to ensure test case correctness
- - When writing or modifying tests, check existing test cases to ensure they have scientific naming and rigorous logic testing, if not compliant, modify test cases to ensure scientific and rigorous testing
- - **Before committing any changes, run `cargo clippy --all-targets --all-features -- -D warnings` to ensure all code passes Clippy checks**
- - After each development completion, first git add . then git commit -m "feat: feature description" or "fix: issue description", ensure compliance with [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/)
- - **Keep commit messages concise and under 72 characters** for the title line, use body for detailed explanations if needed
- - After each development completion, first git push to remote repository
- - After each change completion, summarize the changes, do not create summary files, provide a brief change description, ensure compliance with [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/)
- - Provide change descriptions needed for PR in the conversation, ensure compliance with [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/)
- - **Always provide PR descriptions in English** after completing any changes, including:
-   - Clear and concise title following Conventional Commits format
-   - Detailed description of what was changed and why
-   - List of key changes and improvements
-   - Any breaking changes or migration notes if applicable
-   - Testing information and verification steps
- - **Provide PR descriptions in copyable markdown format** enclosed in code blocks for easy one-click copying
+
+- Use English for all code comments, documentation, and variable names
+- Write meaningful and descriptive names for variables, functions, and methods
+- Avoid meaningless test content like "debug 111" or placeholder values
+- Before each change, carefully read the existing code to ensure you understand the code structure and implementation, do not break existing logic implementation, do not introduce new issues
+- Ensure each change provides sufficient test cases to guarantee code correctness
+- Do not arbitrarily modify numbers and constants in test cases, carefully analyze their meaning to ensure test case correctness
+- When writing or modifying tests, check existing test cases to ensure they have scientific naming and rigorous logic testing, if not compliant, modify test cases to ensure scientific and rigorous testing
+- **Before committing any changes, run `cargo clippy --all-targets --all-features -- -D warnings` to ensure all code passes Clippy checks**
+- After each development completion, first git add . then git commit -m "feat: feature description" or "fix: issue description", ensure compliance with [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/)
+- **Keep commit messages concise and under 72 characters** for the title line, use body for detailed explanations if needed
+- After each development completion, first git push to remote repository
+- After each change completion, summarize the changes, do not create summary files, provide a brief change description, ensure compliance with [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/)
+- Provide change descriptions needed for PR in the conversation, ensure compliance with [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/)
+- **Always provide PR descriptions in English** after completing any changes, including:
+  - Clear and concise title following Conventional Commits format
+  - Detailed description of what was changed and why
+  - List of key changes and improvements
+  - Any breaking changes or migration notes if applicable
+  - Testing information and verification steps
+- **Provide PR descriptions in copyable markdown format** enclosed in code blocks for easy one-click copying
+
+## 🚫 AI 文档生成限制
+
+### 禁止生成总结文档
+
+- **严格禁止创建任何形式的AI生成总结文档**
+- **不得创建包含大量表情符号、详细格式化表格和典型AI风格的文档**
+- **不得在项目中生成以下类型的文档：**
+  - 基准测试总结文档（BENCHMARK*.md）
+  - 实现对比分析文档（IMPLEMENTATION_COMPARISON*.md）
+  - 性能分析报告文档
+  - 架构总结文档
+  - 功能对比文档
+  - 任何带有大量表情符号和格式化内容的文档
+- **如果需要文档，请只在用户明确要求时创建，并保持简洁实用的风格**
+- **文档应当专注于实际需要的信息，避免过度格式化和装饰性内容**
+- **任何发现的AI生成总结文档都应该立即删除**
+
+### 允许的文档类型
+
+- README.md（项目介绍，保持简洁）
+- 技术文档（仅在明确需要时创建）
+- 用户手册（仅在明确需要时创建）
+- API文档（从代码生成）
+- 变更日志（CHANGELOG.md）
diff --git a/.docker/Dockerfile.devenv b/.docker/Dockerfile.devenv
index fee6c2dd..97345985 100644
--- a/.docker/Dockerfile.devenv
+++ b/.docker/Dockerfile.devenv
@@ -1,4 +1,4 @@
-FROM m.daocloud.io/docker.io/library/ubuntu:22.04
+FROM ubuntu:22.04
 
 ENV LANG C.UTF-8
 
@@ -18,10 +18,7 @@ RUN wget https://github.com/google/flatbuffers/releases/download/v25.2.10/Linux.
     && mv flatc /usr/local/bin/ && chmod +x /usr/local/bin/flatc && rm -rf Linux.flatc.binary.g++-13.zip
 
 # install rust
-ENV RUSTUP_DIST_SERVER="https://rsproxy.cn"
-ENV RUSTUP_UPDATE_ROOT="https://rsproxy.cn/rustup"
-RUN curl -o rustup-init.sh --proto '=https' --tlsv1.2 -sSf https://rsproxy.cn/rustup-init.sh \
-    && sh rustup-init.sh -y && rm -rf rustup-init.sh
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
 
 COPY .docker/cargo.config.toml /root/.cargo/config.toml
 
diff --git a/.docker/Dockerfile.rockylinux9.3 b/.docker/Dockerfile.rockylinux9.3
index f677aabe..8487a97b 100644
--- a/.docker/Dockerfile.rockylinux9.3
+++ b/.docker/Dockerfile.rockylinux9.3
@@ -1,4 +1,4 @@
-FROM m.daocloud.io/docker.io/library/rockylinux:9.3 AS builder
+FROM rockylinux:9.3 AS builder
 
 ENV LANG C.UTF-8
 
@@ -25,10 +25,7 @@ RUN wget https://github.com/google/flatbuffers/releases/download/v25.2.10/Linux.
     && rm -rf Linux.flatc.binary.g++-13.zip
 
 # install rust
-ENV RUSTUP_DIST_SERVER="https://rsproxy.cn"
-ENV RUSTUP_UPDATE_ROOT="https://rsproxy.cn/rustup"
-RUN curl -o rustup-init.sh --proto '=https' --tlsv1.2 -sSf https://rsproxy.cn/rustup-init.sh \
-    && sh rustup-init.sh -y && rm -rf rustup-init.sh
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
 
 COPY .docker/cargo.config.toml /root/.cargo/config.toml
 
diff --git a/.docker/Dockerfile.ubuntu22.04 b/.docker/Dockerfile.ubuntu22.04
index 2cb9689c..8670aa45 100644
--- a/.docker/Dockerfile.ubuntu22.04
+++ b/.docker/Dockerfile.ubuntu22.04
@@ -1,4 +1,4 @@
-FROM m.daocloud.io/docker.io/library/ubuntu:22.04
+FROM ubuntu:22.04
 
 ENV LANG C.UTF-8
 
@@ -18,10 +18,7 @@ RUN wget https://github.com/google/flatbuffers/releases/download/v25.2.10/Linux.
     && mv flatc /usr/local/bin/ && chmod +x /usr/local/bin/flatc && rm -rf Linux.flatc.binary.g++-13.zip
 
 # install rust
-ENV RUSTUP_DIST_SERVER="https://rsproxy.cn"
-ENV RUSTUP_UPDATE_ROOT="https://rsproxy.cn/rustup"
-RUN curl -o rustup-init.sh --proto '=https' --tlsv1.2 -sSf https://rsproxy.cn/rustup-init.sh \
-    && sh rustup-init.sh -y && rm -rf rustup-init.sh
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
 
 COPY .docker/cargo.config.toml /root/.cargo/config.toml
 
diff --git a/.docker/cargo.config.toml b/.docker/cargo.config.toml
index ef2fa863..fc6904fe 100644
--- a/.docker/cargo.config.toml
+++ b/.docker/cargo.config.toml
@@ -1,13 +1,5 @@
 [source.crates-io]
 registry = "https://github.com/rust-lang/crates.io-index"
-replace-with = 'rsproxy-sparse'
-
-[source.rsproxy]
-registry = "https://rsproxy.cn/crates.io-index"
-[registries.rsproxy]
-index = "https://rsproxy.cn/crates.io-index"
-[source.rsproxy-sparse]
-registry = "sparse+https://rsproxy.cn/index/"
 
 [net]
 git-fetch-with-cli = true
diff --git a/.docker/mqtt/config/emqx.conf b/.docker/mqtt/config/emqx.conf
new file mode 100644
index 00000000..367f2296
--- /dev/null
+++ b/.docker/mqtt/config/emqx.conf
@@ -0,0 +1,37 @@
+# 节点配置
+node.name = "emqx@127.0.0.1"
+node.cookie = "aBcDeFgHiJkLmNoPqRsTuVwXyZ012345"
+node.data_dir = "/opt/emqx/data"
+
+# 日志配置
+log.console = {level = info, enable = true}
+log.file = {path = "/opt/emqx/log/emqx.log", enable = true, level = info}
+
+# MQTT TCP 监听器
+listeners.tcp.default = {bind = "0.0.0.0:1883", max_connections = 1000000, enable = true}
+
+# MQTT SSL 监听器
+listeners.ssl.default = {bind = "0.0.0.0:8883", enable = false}
+
+# MQTT WebSocket 监听器
+listeners.ws.default = {bind = "0.0.0.0:8083", enable = true}
+
+# MQTT WebSocket SSL 监听器
+listeners.wss.default = {bind = "0.0.0.0:8084", enable = false}
+
+# 管理控制台
+dashboard.listeners.http = {bind = "0.0.0.0:18083", enable = true}
+
+# HTTP API
+management.listeners.http = {bind = "0.0.0.0:8081", enable = true}
+
+# 认证配置
+authentication = [
+  {enable = true, mechanism = password_based, backend = built_in_database, user_id_type = username}
+]
+
+# 授权配置
+authorization.sources = [{type = built_in_database, enable = true}]
+
+# 持久化消息存储
+message.storage.backend = built_in_database
\ No newline at end of file
diff --git a/.docker/mqtt/config/vm.args b/.docker/mqtt/config/vm.args
new file mode 100644
index 00000000..3ddbb959
--- /dev/null
+++ b/.docker/mqtt/config/vm.args
@@ -0,0 +1,9 @@
+-name emqx@127.0.0.1
+-setcookie aBcDeFgHiJkLmNoPqRsTuVwXyZ012345
++P 2097152
++t 1048576
++zdbbl 32768
+-kernel inet_dist_listen_min 6000
+-kernel inet_dist_listen_max 6100
+-smp enable
+-mnesia dir "/opt/emqx/data/mnesia"
\ No newline at end of file
diff --git a/.docker/mqtt/docker-compose-more.yml b/.docker/mqtt/docker-compose-more.yml
new file mode 100644
index 00000000..16128ab1
--- /dev/null
+++ b/.docker/mqtt/docker-compose-more.yml
@@ -0,0 +1,60 @@
+services:
+  emqx:
+    image: emqx/emqx:latest
+    container_name: emqx
+    restart: unless-stopped
+    environment:
+      - EMQX_NODE__NAME=emqx@127.0.0.1
+      - EMQX_NODE__COOKIE=aBcDeFgHiJkLmNoPqRsTuVwXyZ012345
+      - EMQX_NODE__DATA_DIR=/opt/emqx/data
+      - EMQX_LOG__CONSOLE__LEVEL=info
+      - EMQX_LOG__CONSOLE__ENABLE=true
+      - EMQX_LOG__FILE__PATH=/opt/emqx/log/emqx.log
+      - EMQX_LOG__FILE__LEVEL=info
+      - EMQX_LOG__FILE__ENABLE=true
+      - EMQX_LISTENERS__TCP__DEFAULT__BIND=0.0.0.0:1883
+      - EMQX_LISTENERS__TCP__DEFAULT__MAX_CONNECTIONS=1000000
+      - EMQX_LISTENERS__TCP__DEFAULT__ENABLE=true
+      - EMQX_LISTENERS__SSL__DEFAULT__BIND=0.0.0.0:8883
+      - EMQX_LISTENERS__SSL__DEFAULT__ENABLE=false
+      - EMQX_LISTENERS__WS__DEFAULT__BIND=0.0.0.0:8083
+      - EMQX_LISTENERS__WS__DEFAULT__ENABLE=true
+      - EMQX_LISTENERS__WSS__DEFAULT__BIND=0.0.0.0:8084
+      - EMQX_LISTENERS__WSS__DEFAULT__ENABLE=false
+      - EMQX_DASHBOARD__LISTENERS__HTTP__BIND=0.0.0.0:18083
+      - EMQX_DASHBOARD__LISTENERS__HTTP__ENABLE=true
+      - EMQX_MANAGEMENT__LISTENERS__HTTP__BIND=0.0.0.0:8081
+      - EMQX_MANAGEMENT__LISTENERS__HTTP__ENABLE=true
+      - EMQX_AUTHENTICATION__1__ENABLE=true
+      - EMQX_AUTHENTICATION__1__MECHANISM=password_based
+      - EMQX_AUTHENTICATION__1__BACKEND=built_in_database
+      - EMQX_AUTHENTICATION__1__USER_ID_TYPE=username
+      - EMQX_AUTHORIZATION__SOURCES__1__TYPE=built_in_database
+      - EMQX_AUTHORIZATION__SOURCES__1__ENABLE=true
+    ports:
+      - "1883:1883"    # MQTT TCP
+      - "8883:8883"    # MQTT SSL
+      - "8083:8083"    # MQTT WebSocket
+      - "8084:8084"    # MQTT WebSocket SSL
+      - "18083:18083"  # Web 管理控制台
+      - "8081:8081"    # HTTP API
+    volumes:
+      - ./data:/opt/emqx/data
+      - ./log:/opt/emqx/log
+      - ./config:/opt/emqx/etc
+    networks:
+      - mqtt-net
+    healthcheck:
+      test: [ "CMD", "/opt/emqx/bin/emqx_ctl", "status" ]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "100m"
+        max-file: "3"
+
+networks:
+  mqtt-net:
+    driver: bridge
diff --git a/.docker/mqtt/docker-compose.yml b/.docker/mqtt/docker-compose.yml
new file mode 100644
index 00000000..040b7684
--- /dev/null
+++ b/.docker/mqtt/docker-compose.yml
@@ -0,0 +1,15 @@
+services:
+  emqx:
+    image: emqx/emqx:latest
+    container_name: emqx
+    ports:
+      - "1883:1883"
+      - "8083:8083"
+      - "8084:8084"
+      - "8883:8883"
+      - "18083:18083"
+    restart: unless-stopped
+
+networks:
+  default:
+    driver: bridge
\ No newline at end of file
diff --git a/.github/actions/setup/action.yml b/.github/actions/setup/action.yml
index 8c4399ac..a90ca472 100644
--- a/.github/actions/setup/action.yml
+++ b/.github/actions/setup/action.yml
@@ -13,9 +13,9 @@ inputs:
     description: "Cache key for shared cache"
   cache-save-if:
     required: true
-    default: true
+    default: ${{ github.ref == 'refs/heads/main' }}
     description: "Cache save condition"
-  run-os:
+  runs-on:
     required: true
     default: "ubuntu-latest"
     description: "Running system"
@@ -24,7 +24,7 @@ runs:
   using: "composite"
   steps:
     - name: Install system dependencies
-      if: inputs.run-os == 'ubuntu-latest'
+      if: inputs.runs-on == 'ubuntu-latest'
       shell: bash
       run: |
         sudo apt update
@@ -45,7 +45,6 @@ runs:
 
     - uses: Swatinem/rust-cache@v2
       with:
-        cache-on-failure: true
         cache-all-crates: true
         shared-key: ${{ inputs.cache-shared-key }}
         save-if: ${{ inputs.cache-save-if }}
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 03c1ec03..4849aa1e 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -17,42 +17,114 @@ jobs:
       matrix:
         os: [ ubuntu-latest, macos-latest, windows-latest ]
         variant:
-          - { profile: release, target: x86_64-unknown-linux-musl, glibc: "default" }
-          - { profile: release, target: x86_64-unknown-linux-gnu, glibc: "default" }
+          - {
+            profile: release,
+            target: x86_64-unknown-linux-musl,
+            glibc: "default",
+          }
+          - {
+            profile: release,
+            target: x86_64-unknown-linux-gnu,
+            glibc: "default",
+          }
           - { profile: release, target: aarch64-apple-darwin, glibc: "default" }
           #- { profile: release, target: aarch64-unknown-linux-gnu, glibc: "default" }
-          - { profile: release, target: aarch64-unknown-linux-musl, glibc: "default" }
+          - {
+            profile: release,
+            target: aarch64-unknown-linux-musl,
+            glibc: "default",
+          }
           #- { profile: release, target: x86_64-pc-windows-msvc, glibc: "default" }
         exclude:
           # Linux targets on non-Linux systems
           - os: macos-latest
-            variant: { profile: release, target: x86_64-unknown-linux-gnu, glibc: "default" }
+            variant:
+              {
+                profile: release,
+                target: x86_64-unknown-linux-gnu,
+                glibc: "default",
+              }
           - os: macos-latest
-            variant: { profile: release, target: x86_64-unknown-linux-musl, glibc: "default" }
+            variant:
+              {
+                profile: release,
+                target: x86_64-unknown-linux-musl,
+                glibc: "default",
+              }
           - os: macos-latest
-            variant: { profile: release, target: aarch64-unknown-linux-gnu, glibc: "default" }
+            variant:
+              {
+                profile: release,
+                target: aarch64-unknown-linux-gnu,
+                glibc: "default",
+              }
           - os: macos-latest
-            variant: { profile: release, target: aarch64-unknown-linux-musl, glibc: "default" }
+            variant:
+              {
+                profile: release,
+                target: aarch64-unknown-linux-musl,
+                glibc: "default",
+              }
           - os: windows-latest
-            variant: { profile: release, target: x86_64-unknown-linux-gnu, glibc: "default" }
+            variant:
+              {
+                profile: release,
+                target: x86_64-unknown-linux-gnu,
+                glibc: "default",
+              }
           - os: windows-latest
-            variant: { profile: release, target: x86_64-unknown-linux-musl, glibc: "default" }
+            variant:
+              {
+                profile: release,
+                target: x86_64-unknown-linux-musl,
+                glibc: "default",
+              }
           - os: windows-latest
-            variant: { profile: release, target: aarch64-unknown-linux-gnu, glibc: "default" }
+            variant:
+              {
+                profile: release,
+                target: aarch64-unknown-linux-gnu,
+                glibc: "default",
+              }
           - os: windows-latest
-            variant: { profile: release, target: aarch64-unknown-linux-musl, glibc: "default" }
+            variant:
+              {
+                profile: release,
+                target: aarch64-unknown-linux-musl,
+                glibc: "default",
+              }
 
           # Apple targets on non-macOS systems
           - os: ubuntu-latest
-            variant: { profile: release, target: aarch64-apple-darwin, glibc: "default" }
+            variant:
+              {
+                profile: release,
+                target: aarch64-apple-darwin,
+                glibc: "default",
+              }
           - os: windows-latest
-            variant: { profile: release, target: aarch64-apple-darwin, glibc: "default" }
+            variant:
+              {
+                profile: release,
+                target: aarch64-apple-darwin,
+                glibc: "default",
+              }
 
           # Windows targets on non-Windows systems
           - os: ubuntu-latest
-            variant: { profile: release, target: x86_64-pc-windows-msvc, glibc: "default" }
+            variant:
+              {
+                profile: release,
+                target: x86_64-pc-windows-msvc,
+                glibc: "default",
+              }
           - os: macos-latest
-            variant: { profile: release, target: x86_64-pc-windows-msvc, glibc: "default" }
+            variant:
+              {
+                profile: release,
+                target: x86_64-pc-windows-msvc,
+                glibc: "default",
+              }
 
     steps:
       - name: Checkout repository
@@ -89,7 +161,7 @@ jobs:
         if: steps.cache-protoc.outputs.cache-hit != 'true'
         uses: arduino/setup-protoc@v3
         with:
-          version: '31.1'
+          version: "31.1"
           repo-token: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Setup Flatc
@@ -180,14 +252,14 @@ jobs:
           if [[ "$GLIBC" != "default" ]]; then
             BIN_NAME="${BIN_NAME}.glibc${GLIBC}"
           fi
-          
+
           # Windows systems use exe suffix, and other systems do not have suffix
           if [[ "${{ matrix.variant.target }}" == *"windows"* ]]; then
             BIN_NAME="${BIN_NAME}.exe"
           else
             BIN_NAME="${BIN_NAME}.bin"
           fi
-          
+
           echo "Binary name will be: $BIN_NAME"
 
           echo "::group::Building rustfs"
@@ -265,17 +337,56 @@ jobs:
           path: ${{ steps.package.outputs.artifact_name }}.zip
           retention-days: 7
 
+      # Install ossutil2 tool for OSS upload
+      - name: Install ossutil2
+        if: startsWith(github.ref, 'refs/tags/') || github.ref == 'refs/heads/main'
+        shell: bash
+        run: |
+          echo "::group::Installing ossutil2"
+          # Download and install ossutil based on platform
+          if [ "${{ runner.os }}" = "Linux" ]; then
+            curl -o ossutil.zip https://gosspublic.alicdn.com/ossutil/v2/2.1.1/ossutil-2.1.1-linux-amd64.zip
+            unzip -o ossutil.zip
+            chmod 755 ossutil-2.1.1-linux-amd64/ossutil
+            sudo mv ossutil-2.1.1-linux-amd64/ossutil /usr/local/bin/
+            rm -rf ossutil.zip ossutil-2.1.1-linux-amd64
+          elif [ "${{ runner.os }}" = "macOS" ]; then
+            if [ "$(uname -m)" = "arm64" ]; then
+              curl -o ossutil.zip https://gosspublic.alicdn.com/ossutil/v2/2.1.1/ossutil-2.1.1-mac-arm64.zip
+            else
+              curl -o ossutil.zip https://gosspublic.alicdn.com/ossutil/v2/2.1.1/ossutil-2.1.1-mac-amd64.zip
+            fi
+            unzip -o ossutil.zip
+            chmod 755 ossutil-*/ossutil
+            sudo mv ossutil-*/ossutil /usr/local/bin/
+            rm -rf ossutil.zip ossutil-*
+          elif [ "${{ runner.os }}" = "Windows" ]; then
+            curl -o ossutil.zip https://gosspublic.alicdn.com/ossutil/v2/2.1.1/ossutil-2.1.1-windows-amd64.zip
+            unzip -o ossutil.zip
+            mv ossutil-*/ossutil.exe /usr/bin/ossutil.exe
+            rm -rf ossutil.zip ossutil-*
+          fi
+          echo "ossutil2 installation completed"
+
+          # Set the OSS configuration
+          ossutil config set Region oss-cn-beijing
+          ossutil config set endpoint oss-cn-beijing.aliyuncs.com
+          ossutil config set accessKeyID ${{ secrets.ALICLOUDOSS_KEY_ID }}
+          ossutil config set accessKeySecret ${{ secrets.ALICLOUDOSS_KEY_SECRET }}
+
       - name: Upload to Aliyun OSS
         if: startsWith(github.ref, 'refs/tags/') || github.ref == 'refs/heads/main'
-        uses: JohnGuan/oss-upload-action@main
-        with:
-          key-id: ${{ secrets.ALICLOUDOSS_KEY_ID }}
-          key-secret: ${{ secrets.ALICLOUDOSS_KEY_SECRET }}
-          region: oss-cn-beijing
-          bucket: rustfs-artifacts
-          assets: |
-            ${{ steps.package.outputs.artifact_name }}.zip:/artifacts/rustfs/${{ steps.package.outputs.artifact_name }}.zip
-            ${{ steps.package.outputs.artifact_name }}.zip:/artifacts/rustfs/${{ steps.package.outputs.artifact_name }}.latest.zip  
+        shell: bash
+        env:
+          OSSUTIL_ACCESS_KEY_ID: ${{ secrets.ALICLOUDOSS_KEY_ID }}
+          OSSUTIL_ACCESS_KEY_SECRET: ${{ secrets.ALICLOUDOSS_KEY_SECRET }}
+          OSSUTIL_ENDPOINT: https://oss-cn-beijing.aliyuncs.com
+        run: |
+          echo "::group::Uploading files to OSS"
+          # Upload the artifact file to two different paths
+          ossutil cp "${{ steps.package.outputs.artifact_name }}.zip" "oss://rustfs-artifacts/artifacts/rustfs/${{ steps.package.outputs.artifact_name }}.zip" --force
+          ossutil cp "${{ steps.package.outputs.artifact_name }}.zip" "oss://rustfs-artifacts/artifacts/rustfs/${{ steps.package.outputs.artifact_name }}.latest.zip" --force
+          echo "Successfully uploaded artifacts to OSS"
 
       # Determine whether to perform GUI construction based on conditions
       - name: Prepare for GUI build
@@ -393,16 +504,17 @@ jobs:
       # Upload GUI to Alibaba Cloud OSS
       - name: Upload GUI to Aliyun OSS
         if: startsWith(github.ref, 'refs/tags/')
-        uses: JohnGuan/oss-upload-action@main
-        with:
-          key-id: ${{ secrets.ALICLOUDOSS_KEY_ID }}
-          key-secret: ${{ secrets.ALICLOUDOSS_KEY_SECRET }}
-          region: oss-cn-beijing
-          bucket: rustfs-artifacts
-          assets: |
-            ${{ steps.build_gui.outputs.gui_artifact_name }}.zip:/artifacts/rustfs/${{ steps.build_gui.outputs.gui_artifact_name }}.zip
-            ${{ steps.build_gui.outputs.gui_artifact_name }}.zip:/artifacts/rustfs/${{ steps.build_gui.outputs.gui_artifact_name }}.latest.zip
-
+        shell: bash
+        env:
+          OSSUTIL_ACCESS_KEY_ID: ${{ secrets.ALICLOUDOSS_KEY_ID }}
+          OSSUTIL_ACCESS_KEY_SECRET: ${{ secrets.ALICLOUDOSS_KEY_SECRET }}
+          OSSUTIL_ENDPOINT: https://oss-cn-beijing.aliyuncs.com
+        run: |
+          echo "::group::Uploading GUI files to OSS"
+          # Upload the GUI artifact file to two different paths
+          ossutil cp "${{ steps.build_gui.outputs.gui_artifact_name }}.zip" "oss://rustfs-artifacts/artifacts/rustfs/${{ steps.build_gui.outputs.gui_artifact_name }}.zip" --force
+          ossutil cp "${{ steps.build_gui.outputs.gui_artifact_name }}.zip" "oss://rustfs-artifacts/artifacts/rustfs/${{ steps.build_gui.outputs.gui_artifact_name }}.latest.zip" --force
+          echo "Successfully uploaded GUI artifacts to OSS"
 
   merge:
     runs-on: ubuntu-latest
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 44f6d75a..3cdabf6a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -11,9 +11,6 @@ on:
     - cron: '0 0 * * 0' # at midnight of each sunday
   workflow_dispatch:
 
-env:
-  CARGO_TERM_COLOR: always
-
 jobs:
   skip-check:
     permissions:
@@ -30,103 +27,52 @@ jobs:
           cancel_others: true
           paths_ignore: '["*.md"]'
 
-  # Quality checks for pull requests
-  pr-checks:
-    name: Pull Request Quality Checks
-    if: github.event_name == 'pull_request'
+  develop:
+    needs: skip-check
+    if: needs.skip-check.outputs.should_skip != 'true'
     runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/setup
+
+      - name: Test
+        run: cargo test --all --exclude e2e_test
+
+      - name: Format
+        run: cargo fmt --all --check
+
+      - name: Lint
+        run: cargo clippy --all-targets --all-features -- -D warnings
+
+  s3s-e2e:
+    name: E2E (s3s-e2e)
+    needs: skip-check
+    if: needs.skip-check.outputs.should_skip != 'true'
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
     steps:
       - uses: actions/checkout@v4.2.2
       - uses: ./.github/actions/setup
 
-      # - name: Format Check
-      #   run: cargo fmt --all --check
-
-      - name: Lint Check
-        run: cargo check --all-targets
-
-      - name: Clippy Check
-        run: cargo clippy --all-targets --all-features -- -D warnings
-
-      - name: Unit Tests
-        run: cargo test --all --exclude e2e_test
-
-      - name: Format Code
-        run: cargo fmt --all
-
-  s3s-e2e:
-    name: E2E (s3s-e2e)
-    needs:
-      - skip-check
-      - develop
-    if: needs.skip-check.outputs.should_skip != 'true'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4.2.2
-      - uses: dtolnay/rust-toolchain@stable
-      - uses: Swatinem/rust-cache@v2
+      - name: Install s3s-e2e
+        uses: taiki-e/cache-cargo-install-action@v2
         with:
-          cache-on-failure: true
-          cache-all-crates: true
-
-      - name: Install system dependencies
-        run: |
-          sudo apt update
-          sudo apt install -y musl-tools build-essential lld libdbus-1-dev libwayland-dev libwebkit2gtk-4.1-dev libxdo-dev
-
-      - name: Test
-        run: cargo test --all --exclude e2e_test
+          tool: s3s-e2e
+          git: https://github.com/Nugine/s3s.git
+          rev: b7714bfaa17ddfa9b23ea01774a1e7bbdbfc2ca3
 
       - name: Build debug
         run: |
           touch rustfs/build.rs
           cargo build -p rustfs --bins
 
-      - name: Pack artifacts
-        run: |
-          mkdir -p ./target/artifacts
-          cp target/debug/rustfs    ./target/artifacts/rustfs-debug
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: rustfs
-          path: ./target/artifacts/*
-
-      - name: Install s3s-e2e
-        run: |
-          cargo install s3s-e2e --git https://github.com/Nugine/s3s.git
-          s3s-e2e --version
-
-      - uses: actions/download-artifact@v4
-        with:
-          name: rustfs
-          path: ./target/artifacts
-
       - name: Run s3s-e2e
-        timeout-minutes: 10
         run: |
-          ./scripts/e2e-run.sh ./target/artifacts/rustfs-debug /tmp/rustfs
+          s3s-e2e --version
+          ./scripts/e2e-run.sh ./target/debug/rustfs /tmp/rustfs
 
       - uses: actions/upload-artifact@v4
         with:
           name: s3s-e2e.logs
-          path: /tmp/rustfs.log
-
-
-
-  develop:
-    needs: skip-check
-    if: needs.skip-check.outputs.should_skip != 'true'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4.2.2
-      - uses: ./.github/actions/setup
-
-      - name: Format
-        run: cargo fmt --all --check
-
-      - name: Lint
-        run: cargo check --all-targets
-
-      - name: Clippy
-        run: cargo clippy --all-targets --all-features -- -D warnings
+          path: /tmp/rustfs.log
\ No newline at end of file
diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml
new file mode 100644
index 00000000..bbe3dfed
--- /dev/null
+++ b/.github/workflows/docker.yml
@@ -0,0 +1,227 @@
+name: Build and Push Docker Images
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - "v*"
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+    inputs:
+      push_to_registry:
+        description: "Push images to registry"
+        required: false
+        default: "true"
+        type: boolean
+
+env:
+  REGISTRY_IMAGE_DOCKERHUB: rustfs/rustfs
+  REGISTRY_IMAGE_GHCR: ghcr.io/${{ github.repository }}
+
+jobs:
+  # Skip duplicate job runs
+  skip-check:
+    permissions:
+      actions: write
+      contents: read
+    runs-on: ubuntu-latest
+    outputs:
+      should_skip: ${{ steps.skip_check.outputs.should_skip }}
+    steps:
+      - id: skip_check
+        uses: fkirc/skip-duplicate-actions@v5
+        with:
+          concurrent_skipping: "same_content_newer"
+          cancel_others: true
+          paths_ignore: '["*.md", "docs/**"]'
+
+  # Build RustFS binary for different platforms
+  build-binary:
+    needs: skip-check
+    if: needs.skip-check.outputs.should_skip != 'true'
+    strategy:
+      matrix:
+        include:
+          - target: x86_64-unknown-linux-musl
+            os: ubuntu-latest
+            arch: amd64
+            use_cross: false
+          - target: aarch64-unknown-linux-gnu
+            os: ubuntu-latest
+            arch: arm64
+            use_cross: true
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 120
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Rust toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          target: ${{ matrix.target }}
+          components: rustfmt, clippy
+
+      - name: Install cross-compilation dependencies (native build)
+        if: matrix.use_cross == false
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y musl-tools
+
+      - name: Install cross tool (cross compilation)
+        if: matrix.use_cross == true
+        uses: taiki-e/install-action@v2
+        with:
+          tool: cross
+
+      - name: Install protoc
+        uses: arduino/setup-protoc@v3
+        with:
+          version: "31.1"
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Install flatc
+        uses: Nugine/setup-flatc@v1
+        with:
+          version: "25.2.10"
+
+      - name: Cache cargo dependencies
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ matrix.target }}-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-${{ matrix.target }}-
+            ${{ runner.os }}-cargo-
+
+      - name: Generate protobuf code
+        run: cargo run --bin gproto
+
+      - name: Build RustFS binary (native)
+        if: matrix.use_cross == false
+        run: |
+          cargo build --release --target ${{ matrix.target }} --bin rustfs
+
+      - name: Build RustFS binary (cross)
+        if: matrix.use_cross == true
+        run: |
+          cross build --release --target ${{ matrix.target }} --bin rustfs
+
+      - name: Upload binary artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: rustfs-${{ matrix.arch }}
+          path: target/${{ matrix.target }}/release/rustfs
+          retention-days: 1
+
+  # Build and push multi-arch Docker images
+  build-images:
+    needs: [skip-check, build-binary]
+    if: needs.skip-check.outputs.should_skip != 'true'
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    strategy:
+      matrix:
+        image-type: [production, ubuntu, rockylinux, devenv]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Download binary artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: ./artifacts
+
+      - name: Setup binary files
+        run: |
+          mkdir -p target/x86_64-unknown-linux-musl/release
+          mkdir -p target/aarch64-unknown-linux-gnu/release
+          cp artifacts/rustfs-amd64/rustfs target/x86_64-unknown-linux-musl/release/
+          cp artifacts/rustfs-arm64/rustfs target/aarch64-unknown-linux-gnu/release/
+          chmod +x target/*/release/rustfs
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Login to Docker Hub
+        if: github.event_name != 'pull_request' && (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/'))
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Login to GitHub Container Registry
+        if: github.event_name != 'pull_request' && (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/'))
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Set Dockerfile and context
+        id: dockerfile
+        run: |
+          case "${{ matrix.image-type }}" in
+            production)
+              echo "dockerfile=Dockerfile" >> $GITHUB_OUTPUT
+              echo "context=." >> $GITHUB_OUTPUT
+              echo "suffix=" >> $GITHUB_OUTPUT
+              ;;
+            ubuntu)
+              echo "dockerfile=.docker/Dockerfile.ubuntu22.04" >> $GITHUB_OUTPUT
+              echo "context=." >> $GITHUB_OUTPUT
+              echo "suffix=-ubuntu22.04" >> $GITHUB_OUTPUT
+              ;;
+            rockylinux)
+              echo "dockerfile=.docker/Dockerfile.rockylinux9.3" >> $GITHUB_OUTPUT
+              echo "context=." >> $GITHUB_OUTPUT
+              echo "suffix=-rockylinux9.3" >> $GITHUB_OUTPUT
+              ;;
+            devenv)
+              echo "dockerfile=.docker/Dockerfile.devenv" >> $GITHUB_OUTPUT
+              echo "context=." >> $GITHUB_OUTPUT
+              echo "suffix=-devenv" >> $GITHUB_OUTPUT
+              ;;
+          esac
+
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            ${{ env.REGISTRY_IMAGE_DOCKERHUB }}
+            ${{ env.REGISTRY_IMAGE_GHCR }}
+          tags: |
+            type=ref,event=branch,suffix=${{ steps.dockerfile.outputs.suffix }}
+            type=ref,event=pr,suffix=${{ steps.dockerfile.outputs.suffix }}
+            type=semver,pattern={{version}},suffix=${{ steps.dockerfile.outputs.suffix }}
+            type=semver,pattern={{major}}.{{minor}},suffix=${{ steps.dockerfile.outputs.suffix }}
+            type=semver,pattern={{major}},suffix=${{ steps.dockerfile.outputs.suffix }}
+            type=raw,value=latest,suffix=${{ steps.dockerfile.outputs.suffix }},enable={{is_default_branch}}
+          flavor: |
+            latest=false
+
+      - name: Build and push multi-arch Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: ${{ steps.dockerfile.outputs.context }}
+          file: ${{ steps.dockerfile.outputs.dockerfile }}
+          platforms: linux/amd64,linux/arm64
+          push: ${{ (github.event_name != 'pull_request' && (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/'))) || github.event.inputs.push_to_registry == 'true' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha,scope=${{ matrix.image-type }}
+          cache-to: type=gha,mode=max,scope=${{ matrix.image-type }}
+          build-args: |
+            BUILDTIME=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.created'] }}
+            VERSION=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.version'] }}
+            REVISION=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.revision'] }}
diff --git a/.gitignore b/.gitignore
index c3bbd3e6..b93bd2a0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,4 +17,4 @@ deploy/certs/*
 .rustfs.sys
 .cargo
 profile.json
-.docker/openobserve-otel/data
+.docker/openobserve-otel/data
\ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml
index 04e38435..2c41ad62 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,13 +3,16 @@ members = [
     "appauth", # Application authentication and authorization
     "cli/rustfs-gui", # Graphical user interface client
     "common/common", # Shared utilities and data structures
+    "crates/filemeta", # File metadata management
     "common/lock", # Distributed locking implementation
     "common/protos", # Protocol buffer definitions
     "common/workers", # Worker thread pools and task scheduling
     "crates/config", # Configuration management
-    "crates/event-notifier", # Event notification system
+    "crates/notify", # Notification system for events
     "crates/obs", # Observability utilities
+    "crates/rio", # Rust I/O utilities and abstractions
     "crates/utils", # Utility functions and helpers
+    "crates/zip", # ZIP file handling and compression
     "crypto", # Cryptography and security features
     "ecstore", # Erasure coding storage implementation
     "e2e_test", # End-to-end test suite
@@ -18,10 +21,8 @@ members = [
     "rustfs", # Core file system implementation
     "s3select/api", # S3 Select API interface
     "s3select/query", # S3 Select query engine
-    "crates/zip",
-    "crates/filemeta",
-    "crates/rio",
     "reader",
+
 ]
 resolver = "2"
 
@@ -54,12 +55,10 @@ rustfs = { path = "./rustfs", version = "0.0.1" }
 rustfs-zip = { path = "./crates/zip", version = "0.0.1" }
 rustfs-config = { path = "./crates/config", version = "0.0.1" }
 rustfs-obs = { path = "crates/obs", version = "0.0.1" }
-rustfs-event-notifier = { path = "crates/event-notifier", version = "0.0.1" }
+rustfs-notify = { path = "crates/notify", version = "0.0.1" }
 rustfs-utils = { path = "crates/utils", version = "0.0.1" }
 rustfs-rio = { path = "crates/rio", version = "0.0.1" }
 rustfs-filemeta = { path = "crates/filemeta", version = "0.0.1" }
-rustfs-disk = { path = "crates/disk", version = "0.0.1" }
-rustfs-error = { path = "crates/error", version = "0.0.1" }
 workers = { path = "./common/workers", version = "0.0.1" }
 reader = { path = "./reader", version = "0.0.1" }
 aes-gcm = { version = "0.10.3", features = ["std"] }
@@ -75,24 +74,25 @@ axum-extra = "0.10.1"
 axum-server = { version = "0.7.2", features = ["tls-rustls"] }
 backon = "1.5.1"
 base64-simd = "0.8.0"
+base64 = "0.22.1"
 blake2 = "0.10.6"
-bytes = "1.10.1"
+bytes = { version = "1.10.1", features = ["serde"] }
 bytesize = "2.0.1"
 byteorder = "1.5.0"
 cfg-if = "1.0.0"
 chacha20poly1305 = { version = "0.10.1" }
 chrono = { version = "0.4.41", features = ["serde"] }
 clap = { version = "4.5.40", features = ["derive", "env"] }
-config = "0.15.11"
 const-str = { version = "0.6.2", features = ["std", "proc"] }
 crc32fast = "1.4.2"
+dashmap = "6.1.0"
 datafusion = "46.0.1"
 derive_builder = "0.20.2"
-dotenvy = "0.15.7"
 dioxus = { version = "0.6.3", features = ["router"] }
 dirs = "6.0.0"
 flatbuffers = "25.2.10"
 flexi_logger = { version = "0.30.2", features = ["trc","dont_minimize_extra_stacks"] }  
+form_urlencoded = "1.2.1"
 futures = "0.3.31"
 futures-core = "0.3.31"
 futures-util = "0.3.31"
@@ -100,6 +100,7 @@ glob = "0.3.2"
 hex = "0.4.3"
 hex-simd = "0.8.0"
 highway = { version = "1.3.0" }
+hmac = "0.12.1"
 hyper = "1.6.0"
 hyper-util = { version = "0.1.14", features = [
     "tokio",
@@ -158,12 +159,17 @@ pin-project-lite = "0.2.16"
 prost = "0.13.5"
 prost-build = "0.13.5"
 protobuf = "3.7"
+quick-xml = "0.37.5"
 rand = "0.9.1"
+brotli = "8.0.1"
+flate2 = "1.1.1"
+zstd = "0.13.3"
+lz4 = "1.28.1"
 rdkafka = { version = "0.37.0", features = ["tokio"] }
-reed-solomon-erasure = { version = "6.0.0", features = ["simd-accel"] }
+
 reed-solomon-simd = { version = "3.0.0" }
 regex = { version = "1.11.1" }
-reqwest = { version = "0.12.19", default-features = false, features = [
+reqwest = { version = "0.12.20", default-features = false, features = [
     "rustls-tls",
     "charset",
     "http2",
@@ -181,6 +187,7 @@ rmp-serde = "1.3.0"
 rsa = "0.9.8"
 rumqttc = { version = "0.24" }
 rust-embed = { version = "8.7.2" }
+rust-i18n = { version = "3.1.4" }
 rustfs-rsc = "2025.506.1"
 rustls = { version = "0.23.27" }
 rustls-pki-types = "1.12.0"
@@ -193,7 +200,6 @@ serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
 serde-xml-rs = "0.8.1"
 serde_urlencoded = "0.7.1"
-serde_with = "3.12.0"
 sha1 = "0.10.6"
 sha2 = "0.10.9"
 hmac = "0.12.1"
@@ -201,6 +207,7 @@ std-next = "0.1.8"
 siphasher = "1.0.1"
 smallvec = { version = "1.15.1", features = ["serde"] }
 snafu = "0.8.6"
+snap = "1.1.1"
 socket2 = "0.5.10"
 strum = { version = "0.27.1", features = ["derive"] }
 sysinfo = "0.35.2"
@@ -214,13 +221,14 @@ time = { version = "0.3.41", features = [
     "macros",
     "serde",
 ] }
+
 tokio = { version = "1.45.1", features = ["fs", "rt-multi-thread"] }
-tonic = { version = "0.13.1", features = ["gzip"] }
-tonic-build = { version = "0.13.1" }
 tokio-rustls = { version = "0.26.2", default-features = false }
 tokio-stream = { version = "0.1.17" }
 tokio-tar = "0.3.1"
 tokio-util = { version = "0.7.15", features = ["io", "compat"] }
+tonic = { version = "0.13.1", features = ["gzip"] }
+tonic-build = { version = "0.13.1" }
 async-channel = "2.3.1"
 tower = { version = "0.5.2", features = ["timeout"] }
 tower-http = { version = "0.6.6", features = ["cors"] }
@@ -238,6 +246,7 @@ uuid = { version = "1.17.0", features = [
     "fast-rng",
     "macro-diagnostics",
 ] }
+wildmatch = { version = "2.4.0", features = ["serde"] }
 winapi = { version = "0.3.9" }
 xxhash-rust = { version = "0.8.15", features = ["xxh64", "xxh3"] }
 
diff --git a/Dockerfile b/Dockerfile
index 035a2c08..555ab559 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,17 +1,37 @@
 FROM alpine:latest
 
-# RUN apk add --no-cache <package-name>
+# Install runtime dependencies
+RUN apk add --no-cache \
+    ca-certificates \
+    tzdata \
+    && rm -rf /var/cache/apk/*
+
+# Create rustfs user and group
+RUN addgroup -g 1000 rustfs && \
+    adduser -D -s /bin/sh -u 1000 -G rustfs rustfs
 
 WORKDIR /app
 
-RUN mkdir -p /data/rustfs0  /data/rustfs1  /data/rustfs2  /data/rustfs3 
+# Create data directories
+RUN mkdir -p /data/rustfs{0,1,2,3} && \
+    chown -R rustfs:rustfs /data /app
 
-COPY ./target/x86_64-unknown-linux-musl/release/rustfs /app/rustfs
+# Copy binary based on target architecture
+COPY --chown=rustfs:rustfs \
+  target/*/release/rustfs \
+  /app/rustfs
 
 RUN chmod +x /app/rustfs
 
-EXPOSE 9000
-EXPOSE 9001
+# Switch to non-root user
+USER rustfs
 
+# Expose ports
+EXPOSE 9000 9001
 
-CMD ["/app/rustfs"]
\ No newline at end of file
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD wget --no-verbose --tries=1 --spider http://localhost:9000/health || exit 1
+
+# Set default command
+CMD ["/app/rustfs"]
diff --git a/Dockerfile.multi-stage b/Dockerfile.multi-stage
new file mode 100644
index 00000000..24b1f616
--- /dev/null
+++ b/Dockerfile.multi-stage
@@ -0,0 +1,121 @@
+# Multi-stage Dockerfile for RustFS
+# Supports cross-compilation for amd64 and arm64 architectures
+ARG TARGETPLATFORM
+ARG BUILDPLATFORM
+
+# Build stage
+FROM --platform=$BUILDPLATFORM rust:1.85-bookworm AS builder
+
+# Install required build dependencies
+RUN apt-get update && apt-get install -y \
+    wget \
+    git \
+    curl \
+    unzip \
+    gcc \
+    pkg-config \
+    libssl-dev \
+    lld \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install cross-compilation tools for ARM64
+RUN if [ "$TARGETPLATFORM" = "linux/arm64" ]; then \
+        apt-get update && \
+        apt-get install -y gcc-aarch64-linux-gnu && \
+        rm -rf /var/lib/apt/lists/*; \
+    fi
+
+# Install protoc
+RUN wget https://github.com/protocolbuffers/protobuf/releases/download/v31.1/protoc-31.1-linux-x86_64.zip \
+    && unzip protoc-31.1-linux-x86_64.zip -d protoc3 \
+    && mv protoc3/bin/* /usr/local/bin/ && chmod +x /usr/local/bin/protoc \
+    && mv protoc3/include/* /usr/local/include/ && rm -rf protoc-31.1-linux-x86_64.zip protoc3
+
+# Install flatc
+RUN wget https://github.com/google/flatbuffers/releases/download/v25.2.10/Linux.flatc.binary.g++-13.zip \
+    && unzip Linux.flatc.binary.g++-13.zip \
+    && mv flatc /usr/local/bin/ && chmod +x /usr/local/bin/flatc && rm -rf Linux.flatc.binary.g++-13.zip
+
+# Set up Rust targets based on platform
+RUN case "$TARGETPLATFORM" in \
+        "linux/amd64") rustup target add x86_64-unknown-linux-gnu ;; \
+        "linux/arm64") rustup target add aarch64-unknown-linux-gnu ;; \
+        *) echo "Unsupported platform: $TARGETPLATFORM" && exit 1 ;; \
+    esac
+
+# Set up environment for cross-compilation
+ENV CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc
+ENV CC_aarch64_unknown_linux_gnu=aarch64-linux-gnu-gcc
+ENV CXX_aarch64_unknown_linux_gnu=aarch64-linux-gnu-g++
+
+WORKDIR /usr/src/rustfs
+
+# Copy Cargo files for dependency caching
+COPY Cargo.toml Cargo.lock ./
+COPY */Cargo.toml ./*/
+
+# Create dummy main.rs files for dependency compilation
+RUN find . -name "Cargo.toml" -not -path "./Cargo.toml" | \
+    xargs -I {} dirname {} | \
+    xargs -I {} sh -c 'mkdir -p {}/src && echo "fn main() {}" > {}/src/main.rs'
+
+# Build dependencies only (cache layer)
+RUN case "$TARGETPLATFORM" in \
+        "linux/amd64") cargo build --release --target x86_64-unknown-linux-gnu ;; \
+        "linux/arm64") cargo build --release --target aarch64-unknown-linux-gnu ;; \
+    esac
+
+# Copy source code
+COPY . .
+
+# Generate protobuf code
+RUN cargo run --bin gproto
+
+# Build the actual application
+RUN case "$TARGETPLATFORM" in \
+        "linux/amd64") \
+            cargo build --release --target x86_64-unknown-linux-gnu --bin rustfs && \
+            cp target/x86_64-unknown-linux-gnu/release/rustfs /usr/local/bin/rustfs \
+            ;; \
+        "linux/arm64") \
+            cargo build --release --target aarch64-unknown-linux-gnu --bin rustfs && \
+            cp target/aarch64-unknown-linux-gnu/release/rustfs /usr/local/bin/rustfs \
+            ;; \
+    esac
+
+# Runtime stage - Ubuntu minimal for better compatibility
+FROM ubuntu:22.04
+
+# Install runtime dependencies
+RUN apt-get update && apt-get install -y \
+    ca-certificates \
+    tzdata \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create rustfs user and group
+RUN groupadd -g 1000 rustfs && \
+    useradd -d /app -g rustfs -u 1000 -s /bin/bash rustfs
+
+WORKDIR /app
+
+# Create data directories
+RUN mkdir -p /data/rustfs{0,1,2,3} && \
+    chown -R rustfs:rustfs /data /app
+
+# Copy binary from builder stage
+COPY --from=builder /usr/local/bin/rustfs /app/rustfs
+RUN chmod +x /app/rustfs && chown rustfs:rustfs /app/rustfs
+
+# Switch to non-root user
+USER rustfs
+
+# Expose ports
+EXPOSE 9000 9001
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD wget --no-verbose --tries=1 --spider http://localhost:9000/health || exit 1
+
+# Set default command
+CMD ["/app/rustfs"]
diff --git a/Makefile b/Makefile
index b401a2ed..1fe3ab0a 100644
--- a/Makefile
+++ b/Makefile
@@ -79,3 +79,121 @@ build: BUILD_CMD = /root/.cargo/bin/cargo build --release --bin rustfs --target-
 build:
 	$(DOCKER_CLI) build -t $(ROCKYLINUX_BUILD_IMAGE_NAME) -f $(DOCKERFILE_PATH)/Dockerfile.$(BUILD_OS) .
 	$(DOCKER_CLI) run --rm --name $(ROCKYLINUX_BUILD_CONTAINER_NAME) -v $(shell pwd):/root/s3-rustfs -it $(ROCKYLINUX_BUILD_IMAGE_NAME) $(BUILD_CMD)
+
+.PHONY: build-musl
+build-musl:
+	@echo "🔨 Building rustfs for x86_64-unknown-linux-musl..."
+	cargo build --target x86_64-unknown-linux-musl --bin rustfs -r
+
+.PHONY: build-gnu
+build-gnu:
+	@echo "🔨 Building rustfs for x86_64-unknown-linux-gnu..."
+	cargo build --target x86_64-unknown-linux-gnu --bin rustfs -r
+
+.PHONY: deploy-dev
+deploy-dev: build-musl
+	@echo "🚀 Deploying to dev server: $${IP}"
+	./scripts/dev_deploy.sh $${IP}
+
+# Multi-architecture Docker build targets
+.PHONY: docker-build-multiarch
+docker-build-multiarch:
+	@echo "🏗️ Building multi-architecture Docker images..."
+	./scripts/build-docker-multiarch.sh
+
+.PHONY: docker-build-multiarch-push
+docker-build-multiarch-push:
+	@echo "🚀 Building and pushing multi-architecture Docker images..."
+	./scripts/build-docker-multiarch.sh --push
+
+.PHONY: docker-build-multiarch-version
+docker-build-multiarch-version:
+	@if [ -z "$(VERSION)" ]; then \
+		echo "❌ 错误: 请指定版本, 例如: make docker-build-multiarch-version VERSION=v1.0.0"; \
+		exit 1; \
+	fi
+	@echo "🏗️ Building multi-architecture Docker images (version: $(VERSION))..."
+	./scripts/build-docker-multiarch.sh --version $(VERSION)
+
+.PHONY: docker-push-multiarch-version
+docker-push-multiarch-version:
+	@if [ -z "$(VERSION)" ]; then \
+		echo "❌ 错误: 请指定版本, 例如: make docker-push-multiarch-version VERSION=v1.0.0"; \
+		exit 1; \
+	fi
+	@echo "🚀 Building and pushing multi-architecture Docker images (version: $(VERSION))..."
+	./scripts/build-docker-multiarch.sh --version $(VERSION) --push
+
+.PHONY: docker-build-ubuntu
+docker-build-ubuntu:
+	@echo "🏗️ Building multi-architecture Ubuntu Docker images..."
+	./scripts/build-docker-multiarch.sh --type ubuntu
+
+.PHONY: docker-build-rockylinux
+docker-build-rockylinux:
+	@echo "🏗️ Building multi-architecture RockyLinux Docker images..."
+	./scripts/build-docker-multiarch.sh --type rockylinux
+
+.PHONY: docker-build-devenv
+docker-build-devenv:
+	@echo "🏗️ Building multi-architecture development environment Docker images..."
+	./scripts/build-docker-multiarch.sh --type devenv
+
+.PHONY: docker-build-all-types
+docker-build-all-types:
+	@echo "🏗️ Building all multi-architecture Docker image types..."
+	./scripts/build-docker-multiarch.sh --type production
+	./scripts/build-docker-multiarch.sh --type ubuntu
+	./scripts/build-docker-multiarch.sh --type rockylinux
+	./scripts/build-docker-multiarch.sh --type devenv
+
+.PHONY: docker-inspect-multiarch
+docker-inspect-multiarch:
+	@if [ -z "$(IMAGE)" ]; then \
+		echo "❌ 错误: 请指定镜像, 例如: make docker-inspect-multiarch IMAGE=rustfs/rustfs:latest"; \
+		exit 1; \
+	fi
+	@echo "🔍 Inspecting multi-architecture image: $(IMAGE)"
+	docker buildx imagetools inspect $(IMAGE)
+
+.PHONY: build-cross-all
+build-cross-all:
+	@echo "🔧 Building all target architectures..."
+	@if ! command -v cross &> /dev/null; then \
+		echo "📦 Installing cross..."; \
+		cargo install cross; \
+	fi
+	@echo "🔨 Generating protobuf code..."
+	cargo run --bin gproto || true
+	@echo "🔨 Building x86_64-unknown-linux-musl..."
+	cargo build --release --target x86_64-unknown-linux-musl --bin rustfs
+	@echo "🔨 Building aarch64-unknown-linux-gnu..."
+	cross build --release --target aarch64-unknown-linux-gnu --bin rustfs
+	@echo "✅ All architectures built successfully!"
+
+.PHONY: help-docker
+help-docker:
+	@echo "🐳 Docker 多架构构建帮助："
+	@echo ""
+	@echo "基本构建:"
+	@echo "  make docker-build-multiarch              # 构建多架构镜像（不推送）"
+	@echo "  make docker-build-multiarch-push         # 构建并推送多架构镜像"
+	@echo ""
+	@echo "版本构建:"
+	@echo "  make docker-build-multiarch-version VERSION=v1.0.0   # 构建指定版本"
+	@echo "  make docker-push-multiarch-version VERSION=v1.0.0    # 构建并推送指定版本"
+	@echo ""
+	@echo "镜像类型:"
+	@echo "  make docker-build-ubuntu                 # 构建 Ubuntu 镜像"
+	@echo "  make docker-build-rockylinux             # 构建 RockyLinux 镜像"
+	@echo "  make docker-build-devenv                 # 构建开发环境镜像"
+	@echo "  make docker-build-all-types              # 构建所有类型镜像"
+	@echo ""
+	@echo "辅助工具:"
+	@echo "  make build-cross-all                     # 构建所有架构的二进制文件"
+	@echo "  make docker-inspect-multiarch IMAGE=xxx  # 检查镜像的架构支持"
+	@echo ""
+	@echo "环境变量 (在推送时需要设置):"
+	@echo "  DOCKERHUB_USERNAME    Docker Hub 用户名"
+	@echo "  DOCKERHUB_TOKEN       Docker Hub 访问令牌"
+	@echo "  GITHUB_TOKEN          GitHub 访问令牌"
diff --git a/README.md b/README.md
index 64c0d3aa..7f38cb15 100644
--- a/README.md
+++ b/README.md
@@ -73,9 +73,9 @@ export RUSTFS_OBS_ENDPOINT="http://localhost:4317"
 ./rustfs /data/rustfs
 ```
 
-### Observability Stack
+## Observability Stack Otel and OpenObserve
 
-#### Deployment
+### OpenTelemetry Collector 和 Jaeger、Grafana、Prometheus、Loki
 
 1. Navigate to the observability directory:
    ```bash
@@ -92,3 +92,30 @@ export RUSTFS_OBS_ENDPOINT="http://localhost:4317"
 - Grafana: `http://localhost:3000` (credentials: `admin`/`admin`)
 - Jaeger: `http://localhost:16686`
 - Prometheus: `http://localhost:9090`
+
+#### Configure observability
+
+```
+OpenTelemetry Collector address(endpoint):  http://localhost:4317 
+```
+
+---
+
+### OpenObserve and OpenTelemetry Collector
+
+1. Navigate to the OpenObserve and OpenTelemetry directory:
+   ```bash
+   cd .docker/openobserve-otel
+   ```
+2. Start the OpenObserve and OpenTelemetry Collector services:
+   ```bash
+    docker compose -f docker-compose.yml up -d
+    ```
+3. Access the OpenObserve UI:
+   OpenObserve UI: `http://localhost:5080`
+    - Default credentials:
+        - Username: `root@rustfs.com`
+        - Password: `rustfs123`
+    - Exposed ports:
+        - 5080: HTTP API and UI
+        - 5081: OTLP gRPC
diff --git a/README_ZH.md b/README_ZH.md
index 2af21ce1..6e4b330e 100644
--- a/README_ZH.md
+++ b/README_ZH.md
@@ -72,9 +72,9 @@ export RUSTFS_OBS_ENDPOINT="http://localhost:4317"
 ./rustfs /data/rustfs
 ```
 
-### 可观测性系统
+## 可观测性系统 Otel 和 OpenObserve
 
-#### 部署
+### OpenTelemetry Collector 和 Jaeger、Grafana、Prometheus、Loki
 
 1. 进入可观测性目录：
    ```bash
@@ -96,4 +96,26 @@ export RUSTFS_OBS_ENDPOINT="http://localhost:4317"
 
 ```
 OpenTelemetry Collector 地址(endpoint):  http://localhost:4317 
-```
\ No newline at end of file
+```
+
+--- 
+
+### OpenObserve 和 OpenTelemetry Collector
+
+1. 进入 OpenObserve 和 OpenTelemetry 目录：
+   ```bash
+   cd .docker/openobserve-otel
+   ```
+2. 启动 OpenObserve 和 OpenTelemetry Collector 服务：
+   ```bash
+   docker compose -f docker-compose.yml up -d
+   ```
+3. 访问 OpenObserve UI：
+   OpenObserve UI: `http://localhost:5080`
+    - 默认凭据：
+        - 用户名：`root@rustfs.com`
+        - 密码：`rustfs123`
+    - 开放端口：
+        - 5080：HTTP API 和 UI
+        - 5081：OTLP gRPC
+
diff --git a/cli/rustfs-gui/Cargo.toml b/cli/rustfs-gui/Cargo.toml
index faca71ee..218c8d10 100644
--- a/cli/rustfs-gui/Cargo.toml
+++ b/cli/rustfs-gui/Cargo.toml
@@ -15,6 +15,7 @@ keyring = { workspace = true }
 lazy_static = { workspace = true }
 rfd = { workspace = true }
 rust-embed = { workspace = true, features = ["interpolate-folder-path"] }
+rust-i18n = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 sha2 = { workspace = true }
diff --git a/common/protos/src/generated/proto_gen/node_service.rs b/common/protos/src/generated/proto_gen/node_service.rs
index 4b441819..f536dfbf 100644
--- a/common/protos/src/generated/proto_gen/node_service.rs
+++ b/common/protos/src/generated/proto_gen/node_service.rs
@@ -11,15 +11,15 @@ pub struct Error {
 pub struct PingRequest {
     #[prost(uint64, tag = "1")]
     pub version: u64,
-    #[prost(bytes = "vec", tag = "2")]
-    pub body: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub body: ::prost::bytes::Bytes,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct PingResponse {
     #[prost(uint64, tag = "1")]
     pub version: u64,
-    #[prost(bytes = "vec", tag = "2")]
-    pub body: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub body: ::prost::bytes::Bytes,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct HealBucketRequest {
@@ -105,8 +105,8 @@ pub struct ReadAllRequest {
 pub struct ReadAllResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub data: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub data: ::prost::bytes::Bytes,
     #[prost(message, optional, tag = "3")]
     pub error: ::core::option::Option<Error>,
 }
@@ -119,8 +119,8 @@ pub struct WriteAllRequest {
     pub volume: ::prost::alloc::string::String,
     #[prost(string, tag = "3")]
     pub path: ::prost::alloc::string::String,
-    #[prost(bytes = "vec", tag = "4")]
-    pub data: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "4")]
+    pub data: ::prost::bytes::Bytes,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct WriteAllResponse {
@@ -202,8 +202,8 @@ pub struct RenamePartRequest {
     pub dst_volume: ::prost::alloc::string::String,
     #[prost(string, tag = "5")]
     pub dst_path: ::prost::alloc::string::String,
-    #[prost(bytes = "vec", tag = "6")]
-    pub meta: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "6")]
+    pub meta: ::prost::bytes::Bytes,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct RenamePartResponse {
@@ -243,8 +243,8 @@ pub struct WriteRequest {
     pub path: ::prost::alloc::string::String,
     #[prost(bool, tag = "4")]
     pub is_append: bool,
-    #[prost(bytes = "vec", tag = "5")]
-    pub data: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "5")]
+    pub data: ::prost::bytes::Bytes,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct WriteResponse {
@@ -271,8 +271,8 @@ pub struct ReadAtRequest {
 pub struct ReadAtResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub data: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub data: ::prost::bytes::Bytes,
     #[prost(int64, tag = "3")]
     pub read_size: i64,
     #[prost(message, optional, tag = "4")]
@@ -300,8 +300,8 @@ pub struct WalkDirRequest {
     /// indicate which one in the disks
     #[prost(string, tag = "1")]
     pub disk: ::prost::alloc::string::String,
-    #[prost(bytes = "vec", tag = "2")]
-    pub walk_dir_options: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub walk_dir_options: ::prost::bytes::Bytes,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct WalkDirResponse {
@@ -633,8 +633,8 @@ pub struct LocalStorageInfoRequest {
 pub struct LocalStorageInfoResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub storage_info: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub storage_info: ::prost::bytes::Bytes,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
@@ -647,8 +647,8 @@ pub struct ServerInfoRequest {
 pub struct ServerInfoResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub server_properties: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub server_properties: ::prost::bytes::Bytes,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
@@ -658,8 +658,8 @@ pub struct GetCpusRequest {}
 pub struct GetCpusResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub cpus: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub cpus: ::prost::bytes::Bytes,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
@@ -669,8 +669,8 @@ pub struct GetNetInfoRequest {}
 pub struct GetNetInfoResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub net_info: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub net_info: ::prost::bytes::Bytes,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
@@ -680,8 +680,8 @@ pub struct GetPartitionsRequest {}
 pub struct GetPartitionsResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub partitions: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub partitions: ::prost::bytes::Bytes,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
@@ -691,8 +691,8 @@ pub struct GetOsInfoRequest {}
 pub struct GetOsInfoResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub os_info: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub os_info: ::prost::bytes::Bytes,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
@@ -702,8 +702,8 @@ pub struct GetSeLinuxInfoRequest {}
 pub struct GetSeLinuxInfoResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub sys_services: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub sys_services: ::prost::bytes::Bytes,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
@@ -713,8 +713,8 @@ pub struct GetSysConfigRequest {}
 pub struct GetSysConfigResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub sys_config: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub sys_config: ::prost::bytes::Bytes,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
@@ -724,8 +724,8 @@ pub struct GetSysErrorsRequest {}
 pub struct GetSysErrorsResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub sys_errors: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub sys_errors: ::prost::bytes::Bytes,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
@@ -735,24 +735,24 @@ pub struct GetMemInfoRequest {}
 pub struct GetMemInfoResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub mem_info: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub mem_info: ::prost::bytes::Bytes,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetMetricsRequest {
-    #[prost(bytes = "vec", tag = "1")]
-    pub metric_type: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes = "vec", tag = "2")]
-    pub opts: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "1")]
+    pub metric_type: ::prost::bytes::Bytes,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub opts: ::prost::bytes::Bytes,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetMetricsResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub realtime_metrics: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub realtime_metrics: ::prost::bytes::Bytes,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
@@ -762,8 +762,8 @@ pub struct GetProcInfoRequest {}
 pub struct GetProcInfoResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub proc_info: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub proc_info: ::prost::bytes::Bytes,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
@@ -786,7 +786,7 @@ pub struct DownloadProfileDataResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
     #[prost(map = "string, bytes", tag = "2")]
-    pub data: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::vec::Vec<u8>>,
+    pub data: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::bytes::Bytes>,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
@@ -799,8 +799,8 @@ pub struct GetBucketStatsDataRequest {
 pub struct GetBucketStatsDataResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub bucket_stats: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub bucket_stats: ::prost::bytes::Bytes,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
@@ -810,8 +810,8 @@ pub struct GetSrMetricsDataRequest {}
 pub struct GetSrMetricsDataResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub sr_metrics_summary: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub sr_metrics_summary: ::prost::bytes::Bytes,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
@@ -821,8 +821,8 @@ pub struct GetAllBucketStatsRequest {}
 pub struct GetAllBucketStatsResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub bucket_stats_map: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub bucket_stats_map: ::prost::bytes::Bytes,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
@@ -979,36 +979,36 @@ pub struct BackgroundHealStatusRequest {}
 pub struct BackgroundHealStatusResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub bg_heal_state: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub bg_heal_state: ::prost::bytes::Bytes,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetMetacacheListingRequest {
-    #[prost(bytes = "vec", tag = "1")]
-    pub opts: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "1")]
+    pub opts: ::prost::bytes::Bytes,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetMetacacheListingResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub metacache: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub metacache: ::prost::bytes::Bytes,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct UpdateMetacacheListingRequest {
-    #[prost(bytes = "vec", tag = "1")]
-    pub metacache: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "1")]
+    pub metacache: ::prost::bytes::Bytes,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct UpdateMetacacheListingResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
-    #[prost(bytes = "vec", tag = "2")]
-    pub metacache: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub metacache: ::prost::bytes::Bytes,
     #[prost(string, optional, tag = "3")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
diff --git a/common/protos/src/main.rs b/common/protos/src/main.rs
index 44fe20a1..c2eb5fdf 100644
--- a/common/protos/src/main.rs
+++ b/common/protos/src/main.rs
@@ -43,6 +43,7 @@ fn main() -> Result<(), AnyError> {
         // .file_descriptor_set_path(descriptor_set_path)
         .protoc_arg("--experimental_allow_proto3_optional")
         .compile_well_known_types(true)
+        .bytes(["."])
         .emit_rerun_if_changed(false)
         .compile_protos(proto_files, &[proto_dir.clone()])
         .map_err(|e| format!("Failed to generate protobuf file: {e}."))?;
diff --git a/crates/config/Cargo.toml b/crates/config/Cargo.toml
index 1a81e30d..0256f30e 100644
--- a/crates/config/Cargo.toml
+++ b/crates/config/Cargo.toml
@@ -7,11 +7,16 @@ rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-config = { workspace = true }
-const-str = { workspace = true }
+const-str = { workspace = true, optional = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 
 
 [lints]
 workspace = true
+
+[features]
+default = []
+constants = ["dep:const-str"]
+observability = []
+
diff --git a/crates/config/src/config.rs b/crates/config/src/config.rs
deleted file mode 100644
index 40dd8fc6..00000000
--- a/crates/config/src/config.rs
+++ /dev/null
@@ -1,200 +0,0 @@
-use crate::ObservabilityConfig;
-use crate::event::config::NotifierConfig;
-
-/// RustFs configuration
-pub struct RustFsConfig {
-    pub observability: ObservabilityConfig,
-    pub event: NotifierConfig,
-}
-
-impl RustFsConfig {
-    pub fn new() -> Self {
-        Self {
-            observability: ObservabilityConfig::new(),
-            event: NotifierConfig::new(),
-        }
-    }
-}
-
-impl Default for RustFsConfig {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_rustfs_config_new() {
-        let config = RustFsConfig::new();
-
-        // Verify that observability config is properly initialized
-        assert!(!config.observability.sinks.is_empty(), "Observability sinks should not be empty");
-        assert!(config.observability.logger.is_some(), "Logger config should be present");
-
-        // Verify that event config is properly initialized
-        assert!(!config.event.store_path.is_empty(), "Event store path should not be empty");
-        assert!(config.event.channel_capacity > 0, "Channel capacity should be positive");
-        assert!(!config.event.adapters.is_empty(), "Event adapters should not be empty");
-    }
-
-    #[test]
-    fn test_rustfs_config_default() {
-        let config = RustFsConfig::default();
-
-        // Default should be equivalent to new()
-        let new_config = RustFsConfig::new();
-
-        // Compare observability config
-        assert_eq!(config.observability.sinks.len(), new_config.observability.sinks.len());
-        assert_eq!(config.observability.logger.is_some(), new_config.observability.logger.is_some());
-
-        // Compare event config
-        assert_eq!(config.event.store_path, new_config.event.store_path);
-        assert_eq!(config.event.channel_capacity, new_config.event.channel_capacity);
-        assert_eq!(config.event.adapters.len(), new_config.event.adapters.len());
-    }
-
-    #[test]
-    fn test_rustfs_config_components_independence() {
-        let mut config = RustFsConfig::new();
-
-        // Modify observability config
-        config.observability.sinks.clear();
-
-        // Event config should remain unchanged
-        assert!(!config.event.adapters.is_empty(), "Event adapters should remain unchanged");
-        assert!(config.event.channel_capacity > 0, "Channel capacity should remain unchanged");
-
-        // Create new config to verify independence
-        let new_config = RustFsConfig::new();
-        assert!(!new_config.observability.sinks.is_empty(), "New config should have default sinks");
-    }
-
-    #[test]
-    fn test_rustfs_config_observability_integration() {
-        let config = RustFsConfig::new();
-
-        // Test observability config properties
-        assert!(config.observability.otel.endpoint.is_empty() || !config.observability.otel.endpoint.is_empty());
-        assert!(config.observability.otel.use_stdout.is_some());
-        assert!(config.observability.otel.sample_ratio.is_some());
-        assert!(config.observability.otel.meter_interval.is_some());
-        assert!(config.observability.otel.service_name.is_some());
-        assert!(config.observability.otel.service_version.is_some());
-        assert!(config.observability.otel.environment.is_some());
-        assert!(config.observability.otel.logger_level.is_some());
-    }
-
-    #[test]
-    fn test_rustfs_config_event_integration() {
-        let config = RustFsConfig::new();
-
-        // Test event config properties
-        assert!(!config.event.store_path.is_empty(), "Store path should not be empty");
-        assert!(
-            config.event.channel_capacity >= 1000,
-            "Channel capacity should be reasonable for production"
-        );
-
-        // Test that store path is a valid path format
-        let store_path = &config.event.store_path;
-        assert!(!store_path.contains('\0'), "Store path should not contain null characters");
-
-        // Test adapters configuration
-        for adapter in &config.event.adapters {
-            // Each adapter should have a valid configuration
-            match adapter {
-                crate::event::adapters::AdapterConfig::Webhook(_) => {
-                    // Webhook adapter should be properly configured
-                }
-                crate::event::adapters::AdapterConfig::Kafka(_) => {
-                    // Kafka adapter should be properly configured
-                }
-                crate::event::adapters::AdapterConfig::Mqtt(_) => {
-                    // MQTT adapter should be properly configured
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn test_rustfs_config_memory_usage() {
-        // Test that config doesn't use excessive memory
-        let config = RustFsConfig::new();
-
-        // Basic memory usage checks
-        assert!(std::mem::size_of_val(&config) < 10000, "Config should not use excessive memory");
-
-        // Test that strings are not excessively long
-        assert!(config.event.store_path.len() < 1000, "Store path should not be excessively long");
-
-        // Test that collections are reasonably sized
-        assert!(config.observability.sinks.len() < 100, "Sinks collection should be reasonably sized");
-        assert!(config.event.adapters.len() < 100, "Adapters collection should be reasonably sized");
-    }
-
-    #[test]
-    fn test_rustfs_config_serialization_compatibility() {
-        let config = RustFsConfig::new();
-
-        // Test that observability config can be serialized (it has Serialize trait)
-        let observability_json = serde_json::to_string(&config.observability);
-        assert!(observability_json.is_ok(), "Observability config should be serializable");
-
-        // Test that event config can be serialized (it has Serialize trait)
-        let event_json = serde_json::to_string(&config.event);
-        assert!(event_json.is_ok(), "Event config should be serializable");
-    }
-
-    #[test]
-    fn test_rustfs_config_debug_format() {
-        let config = RustFsConfig::new();
-
-        // Test that observability config has Debug trait
-        let observability_debug = format!("{:?}", config.observability);
-        assert!(!observability_debug.is_empty(), "Observability config should have debug output");
-        assert!(
-            observability_debug.contains("ObservabilityConfig"),
-            "Debug output should contain type name"
-        );
-
-        // Test that event config has Debug trait
-        let event_debug = format!("{:?}", config.event);
-        assert!(!event_debug.is_empty(), "Event config should have debug output");
-        assert!(event_debug.contains("NotifierConfig"), "Debug output should contain type name");
-    }
-
-    #[test]
-    fn test_rustfs_config_clone_behavior() {
-        let config = RustFsConfig::new();
-
-        // Test that observability config can be cloned
-        let observability_clone = config.observability.clone();
-        assert_eq!(observability_clone.sinks.len(), config.observability.sinks.len());
-
-        // Test that event config can be cloned
-        let event_clone = config.event.clone();
-        assert_eq!(event_clone.store_path, config.event.store_path);
-        assert_eq!(event_clone.channel_capacity, config.event.channel_capacity);
-    }
-
-    #[test]
-    fn test_rustfs_config_environment_independence() {
-        // Test that config creation doesn't depend on specific environment variables
-        // This test ensures the config can be created in any environment
-
-        let config1 = RustFsConfig::new();
-        let config2 = RustFsConfig::new();
-
-        // Both configs should have the same structure
-        assert_eq!(config1.observability.sinks.len(), config2.observability.sinks.len());
-        assert_eq!(config1.event.adapters.len(), config2.event.adapters.len());
-
-        // Store paths should be consistent
-        assert_eq!(config1.event.store_path, config2.event.store_path);
-        assert_eq!(config1.event.channel_capacity, config2.event.channel_capacity);
-    }
-}
diff --git a/crates/config/src/event/adapters.rs b/crates/config/src/event/adapters.rs
deleted file mode 100644
index d66bf19e..00000000
--- a/crates/config/src/event/adapters.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use crate::event::kafka::KafkaAdapter;
-use crate::event::mqtt::MqttAdapter;
-use crate::event::webhook::WebhookAdapter;
-use serde::{Deserialize, Serialize};
-
-/// Configuration for the notification system.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(tag = "type")]
-pub enum AdapterConfig {
-    Webhook(WebhookAdapter),
-    Kafka(KafkaAdapter),
-    Mqtt(MqttAdapter),
-}
-
-impl AdapterConfig {
-    /// create a new configuration with default values
-    pub fn new() -> Self {
-        Self::Webhook(WebhookAdapter::new())
-    }
-}
-
-impl Default for AdapterConfig {
-    /// create a new configuration with default values
-    fn default() -> Self {
-        Self::new()
-    }
-}
diff --git a/crates/config/src/event/config.rs b/crates/config/src/event/config.rs
deleted file mode 100644
index e72c4697..00000000
--- a/crates/config/src/event/config.rs
+++ /dev/null
@@ -1,334 +0,0 @@
-use crate::event::adapters::AdapterConfig;
-use serde::{Deserialize, Serialize};
-use std::env;
-
-#[allow(dead_code)]
-const DEFAULT_CONFIG_FILE: &str = "event";
-
-/// Configuration for the notification system.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct NotifierConfig {
-    #[serde(default = "default_store_path")]
-    pub store_path: String,
-    #[serde(default = "default_channel_capacity")]
-    pub channel_capacity: usize,
-    pub adapters: Vec<AdapterConfig>,
-}
-
-impl Default for NotifierConfig {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl NotifierConfig {
-    /// create a new configuration with default values
-    pub fn new() -> Self {
-        Self {
-            store_path: default_store_path(),
-            channel_capacity: default_channel_capacity(),
-            adapters: vec![AdapterConfig::new()],
-        }
-    }
-}
-
-/// Provide temporary directories as default storage paths
-fn default_store_path() -> String {
-    env::temp_dir().join("event-notification").to_string_lossy().to_string()
-}
-
-/// Provides the recommended default channel capacity for high concurrency systems
-fn default_channel_capacity() -> usize {
-    10000 // Reasonable default values for high concurrency systems
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::path::Path;
-
-    #[test]
-    fn test_notifier_config_new() {
-        let config = NotifierConfig::new();
-
-        // Verify store path is set
-        assert!(!config.store_path.is_empty(), "Store path should not be empty");
-        assert!(
-            config.store_path.contains("event-notification"),
-            "Store path should contain event-notification"
-        );
-
-        // Verify channel capacity is reasonable
-        assert_eq!(config.channel_capacity, 10000, "Channel capacity should be 10000");
-        assert!(config.channel_capacity > 0, "Channel capacity should be positive");
-
-        // Verify adapters are initialized
-        assert!(!config.adapters.is_empty(), "Adapters should not be empty");
-        assert_eq!(config.adapters.len(), 1, "Should have exactly one default adapter");
-    }
-
-    #[test]
-    fn test_notifier_config_default() {
-        let config = NotifierConfig::default();
-        let new_config = NotifierConfig::new();
-
-        // Default should be equivalent to new()
-        assert_eq!(config.store_path, new_config.store_path);
-        assert_eq!(config.channel_capacity, new_config.channel_capacity);
-        assert_eq!(config.adapters.len(), new_config.adapters.len());
-    }
-
-    #[test]
-    fn test_default_store_path() {
-        let store_path = default_store_path();
-
-        // Verify store path properties
-        assert!(!store_path.is_empty(), "Store path should not be empty");
-        assert!(store_path.contains("event-notification"), "Store path should contain event-notification");
-
-        // Verify it's a valid path format
-        let path = Path::new(&store_path);
-        assert!(path.is_absolute() || path.is_relative(), "Store path should be a valid path");
-
-        // Verify it doesn't contain invalid characters
-        assert!(!store_path.contains('\0'), "Store path should not contain null characters");
-
-        // Verify it's based on temp directory
-        let temp_dir = env::temp_dir();
-        let expected_path = temp_dir.join("event-notification");
-        assert_eq!(store_path, expected_path.to_string_lossy().to_string());
-    }
-
-    #[test]
-    fn test_default_channel_capacity() {
-        let capacity = default_channel_capacity();
-
-        // Verify capacity is reasonable
-        assert_eq!(capacity, 10000, "Default capacity should be 10000");
-        assert!(capacity > 0, "Capacity should be positive");
-        assert!(capacity >= 1000, "Capacity should be at least 1000 for production use");
-        assert!(capacity <= 1_000_000, "Capacity should not be excessively large");
-    }
-
-    #[test]
-    fn test_notifier_config_serialization() {
-        let config = NotifierConfig::new();
-
-        // Test serialization to JSON
-        let json_result = serde_json::to_string(&config);
-        assert!(json_result.is_ok(), "Config should be serializable to JSON");
-
-        let json_str = json_result.unwrap();
-        assert!(!json_str.is_empty(), "Serialized JSON should not be empty");
-        assert!(json_str.contains("store_path"), "JSON should contain store_path");
-        assert!(json_str.contains("channel_capacity"), "JSON should contain channel_capacity");
-        assert!(json_str.contains("adapters"), "JSON should contain adapters");
-
-        // Test deserialization from JSON
-        let deserialized_result: Result<NotifierConfig, _> = serde_json::from_str(&json_str);
-        assert!(deserialized_result.is_ok(), "Config should be deserializable from JSON");
-
-        let deserialized_config = deserialized_result.unwrap();
-        assert_eq!(deserialized_config.store_path, config.store_path);
-        assert_eq!(deserialized_config.channel_capacity, config.channel_capacity);
-        assert_eq!(deserialized_config.adapters.len(), config.adapters.len());
-    }
-
-    #[test]
-    fn test_notifier_config_serialization_with_defaults() {
-        // Test serialization with minimal JSON (using serde defaults)
-        let minimal_json = r#"{"adapters": []}"#;
-
-        let deserialized_result: Result<NotifierConfig, _> = serde_json::from_str(minimal_json);
-        assert!(deserialized_result.is_ok(), "Config should deserialize with defaults");
-
-        let config = deserialized_result.unwrap();
-        assert_eq!(config.store_path, default_store_path(), "Should use default store path");
-        assert_eq!(config.channel_capacity, default_channel_capacity(), "Should use default channel capacity");
-        assert!(config.adapters.is_empty(), "Should have empty adapters as specified");
-    }
-
-    #[test]
-    fn test_notifier_config_debug_format() {
-        let config = NotifierConfig::new();
-
-        let debug_str = format!("{:?}", config);
-        assert!(!debug_str.is_empty(), "Debug output should not be empty");
-        assert!(debug_str.contains("NotifierConfig"), "Debug output should contain struct name");
-        assert!(debug_str.contains("store_path"), "Debug output should contain store_path field");
-        assert!(
-            debug_str.contains("channel_capacity"),
-            "Debug output should contain channel_capacity field"
-        );
-        assert!(debug_str.contains("adapters"), "Debug output should contain adapters field");
-    }
-
-    #[test]
-    fn test_notifier_config_clone() {
-        let config = NotifierConfig::new();
-        let cloned_config = config.clone();
-
-        // Test that clone creates an independent copy
-        assert_eq!(cloned_config.store_path, config.store_path);
-        assert_eq!(cloned_config.channel_capacity, config.channel_capacity);
-        assert_eq!(cloned_config.adapters.len(), config.adapters.len());
-
-        // Verify they are independent (modifying one doesn't affect the other)
-        let mut modified_config = config.clone();
-        modified_config.channel_capacity = 5000;
-        assert_ne!(modified_config.channel_capacity, config.channel_capacity);
-        assert_eq!(cloned_config.channel_capacity, config.channel_capacity);
-    }
-
-    #[test]
-    fn test_notifier_config_modification() {
-        let mut config = NotifierConfig::new();
-
-        // Test modifying store path
-        let original_store_path = config.store_path.clone();
-        config.store_path = "/custom/path".to_string();
-        assert_ne!(config.store_path, original_store_path);
-        assert_eq!(config.store_path, "/custom/path");
-
-        // Test modifying channel capacity
-        let original_capacity = config.channel_capacity;
-        config.channel_capacity = 5000;
-        assert_ne!(config.channel_capacity, original_capacity);
-        assert_eq!(config.channel_capacity, 5000);
-
-        // Test modifying adapters
-        let original_adapters_len = config.adapters.len();
-        config.adapters.push(AdapterConfig::new());
-        assert_eq!(config.adapters.len(), original_adapters_len + 1);
-
-        // Test clearing adapters
-        config.adapters.clear();
-        assert!(config.adapters.is_empty());
-    }
-
-    #[test]
-    fn test_notifier_config_adapters() {
-        let config = NotifierConfig::new();
-
-        // Test default adapter configuration
-        assert_eq!(config.adapters.len(), 1, "Should have exactly one default adapter");
-
-        // Test that we can add more adapters
-        let mut config_mut = config.clone();
-        config_mut.adapters.push(AdapterConfig::new());
-        assert_eq!(config_mut.adapters.len(), 2, "Should be able to add more adapters");
-
-        // Test adapter types
-        for adapter in &config.adapters {
-            match adapter {
-                AdapterConfig::Webhook(_) => {
-                    // Webhook adapter should be properly configured
-                }
-                AdapterConfig::Kafka(_) => {
-                    // Kafka adapter should be properly configured
-                }
-                AdapterConfig::Mqtt(_) => {
-                    // MQTT adapter should be properly configured
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn test_notifier_config_edge_cases() {
-        // Test with empty adapters
-        let mut config = NotifierConfig::new();
-        config.adapters.clear();
-        assert!(config.adapters.is_empty(), "Adapters should be empty after clearing");
-
-        // Test serialization with empty adapters
-        let json_result = serde_json::to_string(&config);
-        assert!(json_result.is_ok(), "Config with empty adapters should be serializable");
-
-        // Test with very large channel capacity
-        config.channel_capacity = 1_000_000;
-        assert_eq!(config.channel_capacity, 1_000_000);
-
-        // Test with minimum channel capacity
-        config.channel_capacity = 1;
-        assert_eq!(config.channel_capacity, 1);
-
-        // Test with empty store path
-        config.store_path = String::new();
-        assert!(config.store_path.is_empty());
-    }
-
-    #[test]
-    fn test_notifier_config_memory_efficiency() {
-        let config = NotifierConfig::new();
-
-        // Test that config doesn't use excessive memory
-        let config_size = std::mem::size_of_val(&config);
-        assert!(config_size < 5000, "Config should not use excessive memory");
-
-        // Test that store path is not excessively long
-        assert!(config.store_path.len() < 1000, "Store path should not be excessively long");
-
-        // Test that adapters collection is reasonably sized
-        assert!(config.adapters.len() < 100, "Adapters collection should be reasonably sized");
-    }
-
-    #[test]
-    fn test_notifier_config_consistency() {
-        // Create multiple configs and ensure they're consistent
-        let config1 = NotifierConfig::new();
-        let config2 = NotifierConfig::new();
-
-        // Both configs should have the same default values
-        assert_eq!(config1.store_path, config2.store_path);
-        assert_eq!(config1.channel_capacity, config2.channel_capacity);
-        assert_eq!(config1.adapters.len(), config2.adapters.len());
-    }
-
-    #[test]
-    fn test_notifier_config_path_validation() {
-        let config = NotifierConfig::new();
-
-        // Test that store path is a valid path
-        let path = Path::new(&config.store_path);
-
-        // Path should be valid
-        assert!(path.components().count() > 0, "Path should have components");
-
-        // Path should not contain invalid characters for most filesystems
-        assert!(!config.store_path.contains('\0'), "Path should not contain null characters");
-        assert!(!config.store_path.contains('\x01'), "Path should not contain control characters");
-
-        // Path should be reasonable length
-        assert!(config.store_path.len() < 260, "Path should be shorter than Windows MAX_PATH");
-    }
-
-    #[test]
-    fn test_notifier_config_production_readiness() {
-        let config = NotifierConfig::new();
-
-        // Test production readiness criteria
-        assert!(config.channel_capacity >= 1000, "Channel capacity should be sufficient for production");
-        assert!(!config.store_path.is_empty(), "Store path should be configured");
-        assert!(!config.adapters.is_empty(), "At least one adapter should be configured");
-
-        // Test that configuration is reasonable for high-load scenarios
-        assert!(config.channel_capacity <= 10_000_000, "Channel capacity should not be excessive");
-
-        // Test that store path is in a reasonable location (temp directory)
-        assert!(config.store_path.contains("event-notification"), "Store path should be identifiable");
-    }
-
-    #[test]
-    fn test_default_config_file_constant() {
-        // Test that the constant is properly defined
-        assert_eq!(DEFAULT_CONFIG_FILE, "event");
-        // DEFAULT_CONFIG_FILE is a const, so is_empty() check is redundant
-        // assert!(!DEFAULT_CONFIG_FILE.is_empty(), "Config file name should not be empty");
-        assert!(!DEFAULT_CONFIG_FILE.contains('/'), "Config file name should not contain path separators");
-        assert!(
-            !DEFAULT_CONFIG_FILE.contains('\\'),
-            "Config file name should not contain Windows path separators"
-        );
-    }
-}
diff --git a/crates/config/src/event/kafka.rs b/crates/config/src/event/kafka.rs
deleted file mode 100644
index 16411374..00000000
--- a/crates/config/src/event/kafka.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-/// Configuration for the Kafka adapter.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct KafkaAdapter {
-    pub brokers: String,
-    pub topic: String,
-    pub max_retries: u32,
-    pub timeout: u64,
-}
-
-impl KafkaAdapter {
-    /// create a new configuration with default values
-    pub fn new() -> Self {
-        Self {
-            brokers: "localhost:9092".to_string(),
-            topic: "kafka_topic".to_string(),
-            max_retries: 3,
-            timeout: 1000,
-        }
-    }
-}
-
-impl Default for KafkaAdapter {
-    /// create a new configuration with default values
-    fn default() -> Self {
-        Self::new()
-    }
-}
diff --git a/crates/config/src/event/mod.rs b/crates/config/src/event/mod.rs
deleted file mode 100644
index 80dfd45e..00000000
--- a/crates/config/src/event/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-pub(crate) mod adapters;
-pub(crate) mod config;
-pub(crate) mod kafka;
-pub(crate) mod mqtt;
-pub(crate) mod webhook;
diff --git a/crates/config/src/event/mqtt.rs b/crates/config/src/event/mqtt.rs
deleted file mode 100644
index ee983532..00000000
--- a/crates/config/src/event/mqtt.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-/// Configuration for the MQTT adapter.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct MqttAdapter {
-    pub broker: String,
-    pub port: u16,
-    pub client_id: String,
-    pub topic: String,
-    pub max_retries: u32,
-}
-
-impl MqttAdapter {
-    /// create a new configuration with default values
-    pub fn new() -> Self {
-        Self {
-            broker: "localhost".to_string(),
-            port: 1883,
-            client_id: "mqtt_client".to_string(),
-            topic: "mqtt_topic".to_string(),
-            max_retries: 3,
-        }
-    }
-}
-
-impl Default for MqttAdapter {
-    /// create a new configuration with default values
-    fn default() -> Self {
-        Self::new()
-    }
-}
diff --git a/crates/config/src/event/webhook.rs b/crates/config/src/event/webhook.rs
deleted file mode 100644
index 95b3adad..00000000
--- a/crates/config/src/event/webhook.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-
-/// Configuration for the notification system.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct WebhookAdapter {
-    pub endpoint: String,
-    pub auth_token: Option<String>,
-    pub custom_headers: Option<HashMap<String, String>>,
-    pub max_retries: u32,
-    pub timeout: u64,
-}
-
-impl WebhookAdapter {
-    /// verify that the configuration is valid
-    pub fn validate(&self) -> Result<(), String> {
-        // verify that endpoint cannot be empty
-        if self.endpoint.trim().is_empty() {
-            return Err("Webhook endpoint cannot be empty".to_string());
-        }
-
-        // verification timeout must be reasonable
-        if self.timeout == 0 {
-            return Err("Webhook timeout must be greater than 0".to_string());
-        }
-
-        // Verify that the maximum number of retry is reasonable
-        if self.max_retries > 10 {
-            return Err("Maximum retry count cannot exceed 10".to_string());
-        }
-
-        Ok(())
-    }
-
-    /// Get the default configuration
-    pub fn new() -> Self {
-        Self {
-            endpoint: "".to_string(),
-            auth_token: None,
-            custom_headers: Some(HashMap::new()),
-            max_retries: 3,
-            timeout: 1000,
-        }
-    }
-}
-
-impl Default for WebhookAdapter {
-    fn default() -> Self {
-        Self::new()
-    }
-}
diff --git a/crates/config/src/lib.rs b/crates/config/src/lib.rs
index 44a9fe3c..da496971 100644
--- a/crates/config/src/lib.rs
+++ b/crates/config/src/lib.rs
@@ -1,11 +1,7 @@
-use crate::observability::config::ObservabilityConfig;
-
-mod config;
-mod constants;
-mod event;
-mod observability;
-
-pub use config::RustFsConfig;
+#[cfg(feature = "constants")]
+pub mod constants;
+#[cfg(feature = "constants")]
 pub use constants::app::*;
 
-pub use event::config::NotifierConfig;
+#[cfg(feature = "observability")]
+pub mod observability;
diff --git a/crates/event-notifier/Cargo.toml b/crates/event-notifier/Cargo.toml
deleted file mode 100644
index 36f3027f..00000000
--- a/crates/event-notifier/Cargo.toml
+++ /dev/null
@@ -1,43 +0,0 @@
-[package]
-name = "rustfs-event-notifier"
-edition.workspace = true
-license.workspace = true
-repository.workspace = true
-rust-version.workspace = true
-version.workspace = true
-
-[features]
-default = ["webhook"]
-webhook = ["dep:reqwest"]
-mqtt = ["rumqttc"]
-kafka = ["dep:rdkafka"]
-
-[dependencies]
-async-trait = { workspace = true }
-config = { workspace = true }
-reqwest = { workspace = true, optional = true }
-rumqttc = { workspace = true, optional = true }
-serde = { workspace = true }
-serde_json = { workspace = true }
-serde_with = { workspace = true }
-smallvec = { workspace = true, features = ["serde"] }
-strum = { workspace = true, features = ["derive"] }
-tracing = { workspace = true }
-thiserror = { workspace = true }
-tokio = { workspace = true, features = ["sync", "net", "macros", "signal", "rt-multi-thread"] }
-tokio-util = { workspace = true }
-uuid = { workspace = true, features = ["v4", "serde"] }
-
-# Only enable kafka features and related dependencies on Linux
-[target.'cfg(target_os = "linux")'.dependencies]
-rdkafka = { workspace = true, features = ["tokio"], optional = true }
-
-[dev-dependencies]
-tokio = { workspace = true, features = ["test-util"] }
-tracing-subscriber = { workspace = true }
-http = { workspace = true }
-axum = { workspace = true }
-dotenvy = { workspace = true }
-
-[lints]
-workspace = true
diff --git a/crates/event-notifier/examples/.env.example b/crates/event-notifier/examples/.env.example
deleted file mode 100644
index c6d37142..00000000
--- a/crates/event-notifier/examples/.env.example
+++ /dev/null
@@ -1,28 +0,0 @@
-## ===== global configuration =====
-#NOTIFIER__STORE_PATH=/var/log/event-notification
-#NOTIFIER__CHANNEL_CAPACITY=5000
-#
-## ===== adapter configuration array format =====
-## webhook adapter index 0
-#NOTIFIER__ADAPTERS_0__type=Webhook
-#NOTIFIER__ADAPTERS_0__endpoint=http://127.0.0.1:3020/webhook
-#NOTIFIER__ADAPTERS_0__auth_token=your-auth-token
-#NOTIFIER__ADAPTERS_0__max_retries=3
-#NOTIFIER__ADAPTERS_0__timeout=50
-#NOTIFIER__ADAPTERS_0__custom_headers__x_custom_server=server-value
-#NOTIFIER__ADAPTERS_0__custom_headers__x_custom_client=client-value
-#
-## kafka adapter index 1
-#NOTIFIER__ADAPTERS_1__type=Kafka
-#NOTIFIER__ADAPTERS_1__brokers=localhost:9092
-#NOTIFIER__ADAPTERS_1__topic=notifications
-#NOTIFIER__ADAPTERS_1__max_retries=3
-#NOTIFIER__ADAPTERS_1__timeout=60
-#
-## mqtt adapter index 2
-#NOTIFIER__ADAPTERS_2__type=Mqtt
-#NOTIFIER__ADAPTERS_2__broker=mqtt.example.com
-#NOTIFIER__ADAPTERS_2__port=1883
-#NOTIFIER__ADAPTERS_2__client_id=event-notifier
-#NOTIFIER__ADAPTERS_2__topic=events
-#NOTIFIER__ADAPTERS_2__max_retries=3
\ No newline at end of file
diff --git a/crates/event-notifier/examples/.env.zh.example b/crates/event-notifier/examples/.env.zh.example
deleted file mode 100644
index 47f54308..00000000
--- a/crates/event-notifier/examples/.env.zh.example
+++ /dev/null
@@ -1,28 +0,0 @@
-## ===== 全局配置 =====
-#NOTIFIER__STORE_PATH=/var/log/event-notification
-#NOTIFIER__CHANNEL_CAPACITY=5000
-#
-## ===== 适配器配置（数组格式） =====
-## Webhook 适配器（索引 0）
-#NOTIFIER__ADAPTERS_0__type=Webhook
-#NOTIFIER__ADAPTERS_0__endpoint=http://127.0.0.1:3020/webhook
-#NOTIFIER__ADAPTERS_0__auth_token=your-auth-token
-#NOTIFIER__ADAPTERS_0__max_retries=3
-#NOTIFIER__ADAPTERS_0__timeout=50
-#NOTIFIER__ADAPTERS_0__custom_headers__x_custom_server=value
-#NOTIFIER__ADAPTERS_0__custom_headers__x_custom_client=value
-#
-## Kafka 适配器（索引 1）
-#NOTIFIER__ADAPTERS_1__type=Kafka
-#NOTIFIER__ADAPTERS_1__brokers=localhost:9092
-#NOTIFIER__ADAPTERS_1__topic=notifications
-#NOTIFIER__ADAPTERS_1__max_retries=3
-#NOTIFIER__ADAPTERS_1__timeout=60
-#
-## MQTT 适配器（索引 2）
-#NOTIFIER__ADAPTERS_2__type=Mqtt
-#NOTIFIER__ADAPTERS_2__broker=mqtt.example.com
-#NOTIFIER__ADAPTERS_2__port=1883
-#NOTIFIER__ADAPTERS_2__client_id=event-notifier
-#NOTIFIER__ADAPTERS_2__topic=events
-#NOTIFIER__ADAPTERS_2__max_retries=3
\ No newline at end of file
diff --git a/crates/event-notifier/examples/event.toml b/crates/event-notifier/examples/event.toml
deleted file mode 100644
index 5b4292fa..00000000
--- a/crates/event-notifier/examples/event.toml
+++ /dev/null
@@ -1,29 +0,0 @@
-# config.toml
-store_path = "/var/log/event-notifier"
-channel_capacity = 5000
-
-[[adapters]]
-type = "Webhook"
-endpoint = "http://127.0.0.1:3020/webhook"
-auth_token = "your-auth-token"
-max_retries = 3
-timeout = 50
-
-[adapters.custom_headers]
-custom_server = "value_server"
-custom_client = "value_client"
-
-[[adapters]]
-type = "Kafka"
-brokers = "localhost:9092"
-topic = "notifications"
-max_retries = 3
-timeout = 60
-
-[[adapters]]
-type = "Mqtt"
-broker = "mqtt.example.com"
-port = 1883
-client_id = "event-notifier"
-topic = "events"
-max_retries = 3
\ No newline at end of file
diff --git a/crates/event-notifier/examples/full.rs b/crates/event-notifier/examples/full.rs
deleted file mode 100644
index 23e858fb..00000000
--- a/crates/event-notifier/examples/full.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-use rustfs_event_notifier::{
-    AdapterConfig, Bucket, Error as NotifierError, Event, Identity, Metadata, Name, NotifierConfig, Object, Source, WebhookConfig,
-};
-use std::collections::HashMap;
-use tokio::signal;
-use tracing::Level;
-use tracing_subscriber::FmtSubscriber;
-
-async fn setup_notification_system() -> Result<(), NotifierError> {
-    let config = NotifierConfig {
-        store_path: "./deploy/logs/event_store".into(),
-        channel_capacity: 100,
-        adapters: vec![AdapterConfig::Webhook(WebhookConfig {
-            endpoint: "http://127.0.0.1:3020/webhook".into(),
-            auth_token: Some("your-auth-token".into()),
-            custom_headers: Some(HashMap::new()),
-            max_retries: 3,
-            timeout: 30,
-        })],
-    };
-
-    rustfs_event_notifier::initialize(config).await?;
-
-    // wait for the system to be ready
-    for _ in 0..50 {
-        // wait up to 5 seconds
-        if rustfs_event_notifier::is_ready() {
-            return Ok(());
-        }
-        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
-    }
-
-    Err(NotifierError::custom("notify the system of initialization timeout"))
-}
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // initialization log
-    // tracing_subscriber::fmt::init();
-
-    let subscriber = FmtSubscriber::builder()
-        .with_max_level(Level::DEBUG) // set to debug or lower level
-        .with_target(false) // simplify output
-        .finish();
-    tracing::subscriber::set_global_default(subscriber).expect("failed to set up log subscriber");
-
-    // set up notification system
-    if let Err(e) = setup_notification_system().await {
-        eprintln!("unable to initialize notification system:{}", e);
-        return Err(e.into());
-    }
-
-    // create a shutdown signal processing
-    let (shutdown_tx, mut shutdown_rx) = tokio::sync::oneshot::channel();
-
-    // start signal processing task
-    tokio::spawn(async move {
-        let _ = signal::ctrl_c().await;
-        println!("Received the shutdown signal and prepared to exit...");
-        let _ = shutdown_tx.send(());
-    });
-
-    // main application logic
-    tokio::select! {
-        _ = async {
-            loop {
-                // application logic
-                // create an s3 metadata object
-                let metadata = Metadata {
-                    schema_version: "1.0".to_string(),
-                    configuration_id: "test-config".to_string(),
-                    bucket: Bucket {
-                        name: "my-bucket".to_string(),
-                        owner_identity: Identity {
-                            principal_id: "owner123".to_string(),
-                        },
-                        arn: "arn:aws:s3:::my-bucket".to_string(),
-                    },
-                    object: Object {
-                        key: "test.txt".to_string(),
-                        size: Some(1024),
-                        etag: Some("abc123".to_string()),
-                        content_type: Some("text/plain".to_string()),
-                        user_metadata: None,
-                        version_id: None,
-                        sequencer: "1234567890".to_string(),
-                    },
-                };
-
-                // create source object
-                let source = Source {
-                    host: "localhost".to_string(),
-                    port: "80".to_string(),
-                    user_agent: "curl/7.68.0".to_string(),
-                };
-
-                // create events using builder mode
-                let event = Event::builder()
-                    .event_time("2023-10-01T12:00:00.000Z")
-                    .event_name(Name::ObjectCreatedPut)
-                    .user_identity(Identity {
-                        principal_id: "user123".to_string(),
-                    })
-                    .s3(metadata)
-                    .source(source)
-                    .channels(vec!["webhook".to_string()])
-                    .build()
-                    .expect("failed to create event");
-
-                if let Err(e) = rustfs_event_notifier::send_event(event).await {
-                    eprintln!("send event failed:{}", e);
-                }
-
-                tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;
-            }
-        } => {},
-
-        _ = &mut shutdown_rx => {
-            println!("close the app");
-        }
-    }
-
-    // 优雅关闭通知系统
-    println!("turn off the notification system");
-    if let Err(e) = rustfs_event_notifier::shutdown().await {
-        eprintln!("An error occurred while shutting down the notification system:{}", e);
-    } else {
-        println!("the notification system has been closed safely");
-    }
-
-    println!("the application has been closed safely");
-    Ok(())
-}
diff --git a/crates/event-notifier/examples/simple.rs b/crates/event-notifier/examples/simple.rs
deleted file mode 100644
index eb2213db..00000000
--- a/crates/event-notifier/examples/simple.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-use rustfs_event_notifier::NotifierSystem;
-use rustfs_event_notifier::create_adapters;
-use rustfs_event_notifier::{AdapterConfig, NotifierConfig, WebhookConfig};
-use rustfs_event_notifier::{Bucket, Event, Identity, Metadata, Name, Object, Source};
-use std::collections::HashMap;
-use std::error;
-use std::sync::Arc;
-use tokio::signal;
-use tracing::Level;
-use tracing_subscriber::FmtSubscriber;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn error::Error>> {
-    let subscriber = FmtSubscriber::builder()
-        .with_max_level(Level::DEBUG) // set to debug or lower level
-        .with_target(false) // simplify output
-        .finish();
-    tracing::subscriber::set_global_default(subscriber).expect("failed to set up log subscriber");
-
-    let config = NotifierConfig {
-        store_path: "./events".to_string(),
-        channel_capacity: 100,
-        adapters: vec![AdapterConfig::Webhook(WebhookConfig {
-            endpoint: "http://127.0.0.1:3020/webhook".to_string(),
-            auth_token: Some("secret-token".to_string()),
-            custom_headers: Some(HashMap::from([("X-Custom".to_string(), "value".to_string())])),
-            max_retries: 3,
-            timeout: 10,
-        })],
-    };
-
-    // event_load_config
-    // loading configuration from environment variables
-    let _config = NotifierConfig::event_load_config(Some("./crates/event-notifier/examples/event.toml".to_string()));
-    tracing::info!("event_load_config config: {:?} \n", _config);
-    dotenvy::dotenv()?;
-    let _config = NotifierConfig::event_load_config(None);
-    tracing::info!("event_load_config config: {:?} \n", _config);
-    let system = Arc::new(tokio::sync::Mutex::new(NotifierSystem::new(config.clone()).await?));
-    let adapters = create_adapters(&config.adapters)?;
-
-    // create an s3 metadata object
-    let metadata = Metadata {
-        schema_version: "1.0".to_string(),
-        configuration_id: "test-config".to_string(),
-        bucket: Bucket {
-            name: "my-bucket".to_string(),
-            owner_identity: Identity {
-                principal_id: "owner123".to_string(),
-            },
-            arn: "arn:aws:s3:::my-bucket".to_string(),
-        },
-        object: Object {
-            key: "test.txt".to_string(),
-            size: Some(1024),
-            etag: Some("abc123".to_string()),
-            content_type: Some("text/plain".to_string()),
-            user_metadata: None,
-            version_id: None,
-            sequencer: "1234567890".to_string(),
-        },
-    };
-
-    // create source object
-    let source = Source {
-        host: "localhost".to_string(),
-        port: "80".to_string(),
-        user_agent: "curl/7.68.0".to_string(),
-    };
-
-    // create events using builder mode
-    let event = Event::builder()
-        .event_time("2023-10-01T12:00:00.000Z")
-        .event_name(Name::ObjectCreatedPut)
-        .user_identity(Identity {
-            principal_id: "user123".to_string(),
-        })
-        .s3(metadata)
-        .source(source)
-        .channels(vec!["webhook".to_string()])
-        .build()
-        .expect("failed to create event");
-
-    {
-        let system = system.lock().await;
-        system.send_event(event).await?;
-    }
-
-    let system_clone = Arc::clone(&system);
-    let system_handle = tokio::spawn(async move {
-        let mut system = system_clone.lock().await;
-        system.start(adapters).await
-    });
-
-    signal::ctrl_c().await?;
-    tracing::info!("Received shutdown signal");
-    let result = {
-        let mut system = system.lock().await;
-        system.shutdown().await
-    };
-
-    if let Err(e) = result {
-        tracing::error!("Failed to shut down the notification system: {}", e);
-    } else {
-        tracing::info!("Notification system shut down successfully");
-    }
-
-    system_handle.await??;
-    Ok(())
-}
diff --git a/crates/event-notifier/examples/webhook.rs b/crates/event-notifier/examples/webhook.rs
deleted file mode 100644
index a91b8afd..00000000
--- a/crates/event-notifier/examples/webhook.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-use axum::{Router, extract::Json, http::StatusCode, routing::post};
-use serde_json::Value;
-use std::time::{SystemTime, UNIX_EPOCH};
-
-#[tokio::main]
-async fn main() {
-    // 构建应用
-    let app = Router::new().route("/webhook", post(receive_webhook));
-    // 启动服务器
-    let listener = tokio::net::TcpListener::bind("0.0.0.0:3020").await.unwrap();
-    println!("Server running on http://0.0.0.0:3020");
-
-    // 创建关闭信号处理
-    tokio::select! {
-        result = axum::serve(listener, app) => {
-            if let Err(e) = result {
-                eprintln!("Server error: {}", e);
-            }
-        }
-        _ = tokio::signal::ctrl_c() => {
-            println!("Shutting down server...");
-        }
-    }
-}
-
-async fn receive_webhook(Json(payload): Json<Value>) -> StatusCode {
-    let start = SystemTime::now();
-    let since_the_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards");
-
-    // get the number of seconds since the unix era
-    let seconds = since_the_epoch.as_secs();
-
-    // Manually calculate year, month, day, hour, minute, and second
-    let (year, month, day, hour, minute, second) = convert_seconds_to_date(seconds);
-
-    // output result
-    println!("current time:{:04}-{:02}-{:02} {:02}:{:02}:{:02}", year, month, day, hour, minute, second);
-    println!(
-        "received a webhook request time:{} content:\n {}",
-        seconds,
-        serde_json::to_string_pretty(&payload).unwrap()
-    );
-    StatusCode::OK
-}
-
-fn convert_seconds_to_date(seconds: u64) -> (u32, u32, u32, u32, u32, u32) {
-    // assume that the time zone is utc
-    let seconds_per_minute = 60;
-    let seconds_per_hour = 3600;
-    let seconds_per_day = 86400;
-
-    // Calculate the year, month, day, hour, minute, and second corresponding to the number of seconds
-    let mut total_seconds = seconds;
-    let mut year = 1970;
-    let mut month = 1;
-    let mut day = 1;
-    let mut hour = 0;
-    let mut minute = 0;
-    let mut second = 0;
-
-    // calculate year
-    while total_seconds >= 31536000 {
-        year += 1;
-        total_seconds -= 31536000; // simplified processing no leap year considered
-    }
-
-    // calculate month
-    let days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-    for m in &days_in_month {
-        if total_seconds >= m * seconds_per_day {
-            month += 1;
-            total_seconds -= m * seconds_per_day;
-        } else {
-            break;
-        }
-    }
-
-    // calculate the number of days
-    day += total_seconds / seconds_per_day;
-    total_seconds %= seconds_per_day;
-
-    // calculate hours
-    hour += total_seconds / seconds_per_hour;
-    total_seconds %= seconds_per_hour;
-
-    // calculate minutes
-    minute += total_seconds / seconds_per_minute;
-    total_seconds %= seconds_per_minute;
-
-    // calculate the number of seconds
-    second += total_seconds;
-
-    (year as u32, month as u32, day as u32, hour as u32, minute as u32, second as u32)
-}
diff --git a/crates/event-notifier/src/adapter/kafka.rs b/crates/event-notifier/src/adapter/kafka.rs
deleted file mode 100644
index 0abd1f00..00000000
--- a/crates/event-notifier/src/adapter/kafka.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use crate::ChannelAdapter;
-use crate::Error;
-use crate::Event;
-use crate::KafkaConfig;
-use async_trait::async_trait;
-use rdkafka::error::KafkaError;
-use rdkafka::producer::{FutureProducer, FutureRecord};
-use rdkafka::types::RDKafkaErrorCode;
-use rdkafka::util::Timeout;
-use std::time::Duration;
-use tokio::time::sleep;
-
-/// Kafka adapter for sending events to a Kafka topic.
-pub struct KafkaAdapter {
-    producer: FutureProducer,
-    topic: String,
-    max_retries: u32,
-}
-
-impl KafkaAdapter {
-    /// Creates a new Kafka adapter.
-    pub fn new(config: &KafkaConfig) -> Result<Self, Error> {
-        // Create a Kafka producer with the provided configuration.
-        let producer = rdkafka::config::ClientConfig::new()
-            .set("bootstrap.servers", &config.brokers)
-            .set("message.timeout.ms", config.timeout.to_string())
-            .create()?;
-
-        Ok(Self {
-            producer,
-            topic: config.topic.clone(),
-            max_retries: config.max_retries,
-        })
-    }
-    /// Sends an event to the Kafka topic with retry logic.
-    async fn send_with_retry(&self, event: &Event) -> Result<(), Error> {
-        let event_id = event.id.to_string();
-        let payload = serde_json::to_string(&event)?;
-
-        for attempt in 0..self.max_retries {
-            let record = FutureRecord::to(&self.topic).key(&event_id).payload(&payload);
-
-            match self.producer.send(record, Timeout::Never).await {
-                Ok(_) => return Ok(()),
-                Err((KafkaError::MessageProduction(RDKafkaErrorCode::QueueFull), _)) => {
-                    tracing::warn!("Kafka attempt {} failed: Queue full. Retrying...", attempt + 1);
-                    sleep(Duration::from_secs(2u64.pow(attempt))).await;
-                }
-                Err((e, _)) => {
-                    tracing::error!("Kafka send error: {}", e);
-                    return Err(Error::Kafka(e));
-                }
-            }
-        }
-
-        Err(Error::Custom("Exceeded maximum retry attempts for Kafka message".to_string()))
-    }
-}
-
-#[async_trait]
-impl ChannelAdapter for KafkaAdapter {
-    fn name(&self) -> String {
-        "kafka".to_string()
-    }
-
-    async fn send(&self, event: &Event) -> Result<(), Error> {
-        self.send_with_retry(event).await
-    }
-}
diff --git a/crates/event-notifier/src/adapter/mod.rs b/crates/event-notifier/src/adapter/mod.rs
deleted file mode 100644
index 426fd2d8..00000000
--- a/crates/event-notifier/src/adapter/mod.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-use crate::AdapterConfig;
-use crate::Error;
-use crate::Event;
-use async_trait::async_trait;
-use std::sync::Arc;
-
-#[cfg(all(feature = "kafka", target_os = "linux"))]
-pub(crate) mod kafka;
-#[cfg(feature = "mqtt")]
-pub(crate) mod mqtt;
-#[cfg(feature = "webhook")]
-pub(crate) mod webhook;
-
-/// The `ChannelAdapter` trait defines the interface for all channel adapters.
-#[async_trait]
-pub trait ChannelAdapter: Send + Sync + 'static {
-    /// Sends an event to the channel.
-    fn name(&self) -> String;
-    /// Sends an event to the channel.
-    async fn send(&self, event: &Event) -> Result<(), Error>;
-}
-
-/// Creates channel adapters based on the provided configuration.
-pub fn create_adapters(configs: &[AdapterConfig]) -> Result<Vec<Arc<dyn ChannelAdapter>>, Error> {
-    let mut adapters: Vec<Arc<dyn ChannelAdapter>> = Vec::new();
-
-    for config in configs {
-        match config {
-            #[cfg(feature = "webhook")]
-            AdapterConfig::Webhook(webhook_config) => {
-                webhook_config.validate().map_err(Error::ConfigError)?;
-                adapters.push(Arc::new(webhook::WebhookAdapter::new(webhook_config.clone())));
-            }
-            #[cfg(all(feature = "kafka", target_os = "linux"))]
-            AdapterConfig::Kafka(kafka_config) => {
-                adapters.push(Arc::new(kafka::KafkaAdapter::new(kafka_config)?));
-            }
-            #[cfg(feature = "mqtt")]
-            AdapterConfig::Mqtt(mqtt_config) => {
-                let (mqtt, mut event_loop) = mqtt::MqttAdapter::new(mqtt_config);
-                tokio::spawn(async move { while event_loop.poll().await.is_ok() {} });
-                adapters.push(Arc::new(mqtt));
-            }
-            #[cfg(not(feature = "webhook"))]
-            AdapterConfig::Webhook(_) => return Err(Error::FeatureDisabled("webhook")),
-            #[cfg(any(not(feature = "kafka"), not(target_os = "linux")))]
-            AdapterConfig::Kafka(_) => return Err(Error::FeatureDisabled("kafka")),
-            #[cfg(not(feature = "mqtt"))]
-            AdapterConfig::Mqtt(_) => return Err(Error::FeatureDisabled("mqtt")),
-        }
-    }
-
-    Ok(adapters)
-}
diff --git a/crates/event-notifier/src/adapter/mqtt.rs b/crates/event-notifier/src/adapter/mqtt.rs
deleted file mode 100644
index 9aab61e8..00000000
--- a/crates/event-notifier/src/adapter/mqtt.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-use crate::ChannelAdapter;
-use crate::Error;
-use crate::Event;
-use crate::MqttConfig;
-use async_trait::async_trait;
-use rumqttc::{AsyncClient, MqttOptions, QoS};
-use std::time::Duration;
-use tokio::time::sleep;
-
-/// MQTT adapter for sending events to an MQTT broker.
-pub struct MqttAdapter {
-    client: AsyncClient,
-    topic: String,
-    max_retries: u32,
-}
-
-impl MqttAdapter {
-    /// Creates a new MQTT adapter.
-    pub fn new(config: &MqttConfig) -> (Self, rumqttc::EventLoop) {
-        let mqtt_options = MqttOptions::new(&config.client_id, &config.broker, config.port);
-        let (client, event_loop) = rumqttc::AsyncClient::new(mqtt_options, 10);
-        (
-            Self {
-                client,
-                topic: config.topic.clone(),
-                max_retries: config.max_retries,
-            },
-            event_loop,
-        )
-    }
-}
-
-#[async_trait]
-impl ChannelAdapter for MqttAdapter {
-    fn name(&self) -> String {
-        "mqtt".to_string()
-    }
-
-    async fn send(&self, event: &Event) -> Result<(), Error> {
-        let payload = serde_json::to_string(event).map_err(Error::Serde)?;
-        let mut attempt = 0;
-        loop {
-            match self
-                .client
-                .publish(&self.topic, QoS::AtLeastOnce, false, payload.clone())
-                .await
-            {
-                Ok(()) => return Ok(()),
-                Err(e) if attempt < self.max_retries => {
-                    attempt += 1;
-                    tracing::warn!("MQTT attempt {} failed: {}. Retrying...", attempt, e);
-                    sleep(Duration::from_secs(2u64.pow(attempt))).await;
-                }
-                Err(e) => return Err(Error::Mqtt(e)),
-            }
-        }
-    }
-}
diff --git a/crates/event-notifier/src/adapter/webhook.rs b/crates/event-notifier/src/adapter/webhook.rs
deleted file mode 100644
index 447c463e..00000000
--- a/crates/event-notifier/src/adapter/webhook.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-use crate::ChannelAdapter;
-use crate::Error;
-use crate::Event;
-use crate::WebhookConfig;
-use async_trait::async_trait;
-use reqwest::{Client, RequestBuilder};
-use std::time::Duration;
-use tokio::time::sleep;
-
-/// Webhook adapter for sending events to a webhook endpoint.
-pub struct WebhookAdapter {
-    config: WebhookConfig,
-    client: Client,
-}
-
-impl WebhookAdapter {
-    /// Creates a new Webhook adapter.
-    pub fn new(config: WebhookConfig) -> Self {
-        let client = Client::builder()
-            .timeout(Duration::from_secs(config.timeout))
-            .build()
-            .expect("Failed to build reqwest client");
-        Self { config, client }
-    }
-    /// Builds the request to send the event.
-    fn build_request(&self, event: &Event) -> RequestBuilder {
-        let mut request = self.client.post(&self.config.endpoint).json(event);
-        if let Some(token) = &self.config.auth_token {
-            request = request.header("Authorization", format!("Bearer {}", token));
-        }
-        if let Some(headers) = &self.config.custom_headers {
-            for (key, value) in headers {
-                request = request.header(key, value);
-            }
-        }
-        request
-    }
-}
-
-#[async_trait]
-impl ChannelAdapter for WebhookAdapter {
-    fn name(&self) -> String {
-        "webhook".to_string()
-    }
-
-    async fn send(&self, event: &Event) -> Result<(), Error> {
-        let mut attempt = 0;
-        tracing::info!("Attempting to send webhook request: {:?}", event);
-        loop {
-            match self.build_request(event).send().await {
-                Ok(response) => {
-                    response.error_for_status().map_err(Error::Http)?;
-                    return Ok(());
-                }
-                Err(e) if attempt < self.config.max_retries => {
-                    attempt += 1;
-                    tracing::warn!("Webhook attempt {} failed: {}. Retrying...", attempt, e);
-                    sleep(Duration::from_secs(2u64.pow(attempt))).await;
-                }
-                Err(e) => return Err(Error::Http(e)),
-            }
-        }
-    }
-}
diff --git a/crates/event-notifier/src/bus.rs b/crates/event-notifier/src/bus.rs
deleted file mode 100644
index 5cabfc22..00000000
--- a/crates/event-notifier/src/bus.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-use crate::ChannelAdapter;
-use crate::Error;
-use crate::EventStore;
-use crate::{Event, Log};
-use std::sync::Arc;
-use std::time::{SystemTime, UNIX_EPOCH};
-use tokio::sync::mpsc;
-use tokio::time::Duration;
-use tokio_util::sync::CancellationToken;
-use tracing::instrument;
-
-/// Handles incoming events from the producer.
-///
-/// This function is responsible for receiving events from the producer and sending them to the appropriate adapters.
-/// It also handles the shutdown process and saves any pending logs to the event store.
-#[instrument(skip_all)]
-pub async fn event_bus(
-    mut rx: mpsc::Receiver<Event>,
-    adapters: Vec<Arc<dyn ChannelAdapter>>,
-    store: Arc<EventStore>,
-    shutdown: CancellationToken,
-    shutdown_complete: Option<tokio::sync::oneshot::Sender<()>>,
-) -> Result<(), Error> {
-    let mut current_log = Log {
-        event_name: crate::event::Name::Everything,
-        key: SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs().to_string(),
-        records: Vec::new(),
-    };
-
-    let mut unprocessed_events = Vec::new();
-    loop {
-        tokio::select! {
-            Some(event) = rx.recv() => {
-                current_log.records.push(event.clone());
-                let mut send_tasks = Vec::new();
-                for adapter in &adapters {
-                    if event.channels.contains(&adapter.name()) {
-                        let adapter = adapter.clone();
-                        let event = event.clone();
-                        send_tasks.push(tokio::spawn(async move {
-                            if let Err(e) = adapter.send(&event).await {
-                                tracing::error!("Failed to send event to {}: {}", adapter.name(), e);
-                                Err(e)
-                            } else {
-                                Ok(())
-                            }
-                        }));
-                    }
-                }
-                for task in send_tasks {
-                    if task.await?.is_err() {
-                        // If sending fails, add the event to the unprocessed list
-                        let failed_event = event.clone();
-                        unprocessed_events.push(failed_event);
-                    }
-                }
-
-                // Clear the current log because we only care about unprocessed events
-                 current_log.records.clear();
-            }
-            _ = shutdown.cancelled() => {
-                tracing::info!("Shutting down event bus, saving pending logs...");
-                // Check if there are still unprocessed messages in the channel
-                while let Ok(Some(event)) = tokio::time::timeout(
-                    Duration::from_millis(100),
-                    rx.recv()
-                ).await {
-                    unprocessed_events.push(event);
-                }
-
-                // save only if there are unprocessed events
-                if !unprocessed_events.is_empty() {
-                    tracing::info!("Save {} unhandled events", unprocessed_events.len());
-                    // create and save logging
-                    let shutdown_log = Log {
-                        event_name: crate::event::Name::Everything,
-                        key: format!("shutdown_{}", SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs()),
-                        records: unprocessed_events,
-                    };
-
-                    store.save_logs(&[shutdown_log]).await?;
-                } else {
-                    tracing::info!("no unhandled events need to be saved");
-                }
-                 tracing::debug!("shutdown_complete is Some: {}", shutdown_complete.is_some());
-
-                if let Some(complete_sender) = shutdown_complete {
-                    // send a completion signal
-                    let result = complete_sender.send(());
-                    match result {
-                        Ok(_) => tracing::info!("Event bus shutdown signal sent"),
-                        Err(e) => tracing::error!("Failed to send event bus shutdown signal: {:?}", e),
-                    }
-                    tracing::info!("Shutting down event bus");
-                }
-                tracing::info!("Event bus shutdown complete");
-                break;
-            }
-        }
-    }
-    Ok(())
-}
diff --git a/crates/event-notifier/src/config.rs b/crates/event-notifier/src/config.rs
deleted file mode 100644
index 3414f3fa..00000000
--- a/crates/event-notifier/src/config.rs
+++ /dev/null
@@ -1,166 +0,0 @@
-use config::{Config, File, FileFormat};
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::env;
-
-/// Configuration for the notification system.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct WebhookConfig {
-    pub endpoint: String,
-    pub auth_token: Option<String>,
-    pub custom_headers: Option<HashMap<String, String>>,
-    pub max_retries: u32,
-    pub timeout: u64,
-}
-
-impl WebhookConfig {
-    /// verify that the configuration is valid
-    pub fn validate(&self) -> Result<(), String> {
-        // verify that endpoint cannot be empty
-        if self.endpoint.trim().is_empty() {
-            return Err("Webhook endpoint cannot be empty".to_string());
-        }
-
-        // verification timeout must be reasonable
-        if self.timeout == 0 {
-            return Err("Webhook timeout must be greater than 0".to_string());
-        }
-
-        // Verify that the maximum number of retry is reasonable
-        if self.max_retries > 10 {
-            return Err("Maximum retry count cannot exceed 10".to_string());
-        }
-
-        Ok(())
-    }
-}
-
-/// Configuration for the Kafka adapter.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct KafkaConfig {
-    pub brokers: String,
-    pub topic: String,
-    pub max_retries: u32,
-    pub timeout: u64,
-}
-
-/// Configuration for the MQTT adapter.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct MqttConfig {
-    pub broker: String,
-    pub port: u16,
-    pub client_id: String,
-    pub topic: String,
-    pub max_retries: u32,
-}
-
-/// Configuration for the notification system.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(tag = "type")]
-pub enum AdapterConfig {
-    Webhook(WebhookConfig),
-    Kafka(KafkaConfig),
-    Mqtt(MqttConfig),
-}
-
-/// Configuration for the notification system.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct NotifierConfig {
-    #[serde(default = "default_store_path")]
-    pub store_path: String,
-    #[serde(default = "default_channel_capacity")]
-    pub channel_capacity: usize,
-    pub adapters: Vec<AdapterConfig>,
-}
-
-impl Default for NotifierConfig {
-    fn default() -> Self {
-        Self {
-            store_path: default_store_path(),
-            channel_capacity: default_channel_capacity(),
-            adapters: Vec::new(),
-        }
-    }
-}
-
-impl NotifierConfig {
-    /// create a new configuration with default values
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Loading the configuration file
-    /// Supports TOML, YAML and .env formats, read in order by priority
-    ///
-    /// # Parameters
-    /// - `config_dir`: Configuration file path
-    ///
-    /// # Returns
-    /// Configuration information
-    ///
-    /// # Example
-    /// ```
-    /// use rustfs_event_notifier::NotifierConfig;
-    ///
-    /// let config = NotifierConfig::event_load_config(None);
-    /// ```
-    pub fn event_load_config(config_dir: Option<String>) -> NotifierConfig {
-        let config_dir = if let Some(path) = config_dir {
-            // If a path is provided, check if it's empty
-            if path.is_empty() {
-                // If empty, use the default config file name
-                DEFAULT_CONFIG_FILE.to_string()
-            } else {
-                // Use the provided path
-                let path = std::path::Path::new(&path);
-                if path.extension().is_some() {
-                    // If path has extension, use it as is (extension will be added by Config::builder)
-                    path.with_extension("").to_string_lossy().into_owned()
-                } else {
-                    // If path is a directory, append the default config file name
-                    path.to_string_lossy().into_owned()
-                }
-            }
-        } else {
-            // If no path provided, use current directory + default config file
-            match env::current_dir() {
-                Ok(dir) => dir.join(DEFAULT_CONFIG_FILE).to_string_lossy().into_owned(),
-                Err(_) => {
-                    eprintln!("Warning: Failed to get current directory, using default config file");
-                    DEFAULT_CONFIG_FILE.to_string()
-                }
-            }
-        };
-
-        // Log using proper logging instead of println when possible
-        println!("Using config file base: {}", config_dir);
-
-        let app_config = Config::builder()
-            .add_source(File::with_name(config_dir.as_str()).format(FileFormat::Toml).required(false))
-            .add_source(File::with_name(config_dir.as_str()).format(FileFormat::Yaml).required(false))
-            .build()
-            .unwrap_or_default();
-        match app_config.try_deserialize::<NotifierConfig>() {
-            Ok(app_config) => {
-                println!("Parsed AppConfig: {:?} \n", app_config);
-                app_config
-            }
-            Err(e) => {
-                println!("Failed to deserialize config: {}", e);
-                NotifierConfig::default()
-            }
-        }
-    }
-}
-
-const DEFAULT_CONFIG_FILE: &str = "event";
-
-/// Provide temporary directories as default storage paths
-fn default_store_path() -> String {
-    std::env::temp_dir().join("event-notification").to_string_lossy().to_string()
-}
-
-/// Provides the recommended default channel capacity for high concurrency systems
-fn default_channel_capacity() -> usize {
-    10000 // Reasonable default values for high concurrency systems
-}
diff --git a/crates/event-notifier/src/error.rs b/crates/event-notifier/src/error.rs
deleted file mode 100644
index e91f036e..00000000
--- a/crates/event-notifier/src/error.rs
+++ /dev/null
@@ -1,418 +0,0 @@
-use config::ConfigError;
-use thiserror::Error;
-use tokio::sync::mpsc::error;
-use tokio::task::JoinError;
-
-/// The `Error` enum represents all possible errors that can occur in the application.
-/// It implements the `std::error::Error` trait and provides a way to convert various error types into a single error type.
-#[derive(Error, Debug)]
-pub enum Error {
-    #[error("Join error: {0}")]
-    JoinError(#[from] JoinError),
-    #[error("IO error: {0}")]
-    Io(#[from] std::io::Error),
-    #[error("Serialization error: {0}")]
-    Serde(#[from] serde_json::Error),
-    #[error("HTTP error: {0}")]
-    Http(#[from] reqwest::Error),
-    #[cfg(all(feature = "kafka", target_os = "linux"))]
-    #[error("Kafka error: {0}")]
-    Kafka(#[from] rdkafka::error::KafkaError),
-    #[cfg(feature = "mqtt")]
-    #[error("MQTT error: {0}")]
-    Mqtt(#[from] rumqttc::ClientError),
-    #[error("Channel send error: {0}")]
-    ChannelSend(#[from] Box<error::SendError<crate::event::Event>>),
-    #[error("Feature disabled: {0}")]
-    FeatureDisabled(&'static str),
-    #[error("Event bus already started")]
-    EventBusStarted,
-    #[error("necessary fields are missing:{0}")]
-    MissingField(&'static str),
-    #[error("field verification failed:{0}")]
-    ValidationError(&'static str),
-    #[error("Custom error: {0}")]
-    Custom(String),
-    #[error("Configuration error: {0}")]
-    ConfigError(String),
-    #[error("Configuration loading error: {0}")]
-    Config(#[from] ConfigError),
-}
-
-impl Error {
-    pub fn custom(msg: &str) -> Error {
-        Self::Custom(msg.to_string())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::error::Error as StdError;
-    use std::io;
-    use tokio::sync::mpsc;
-
-    #[test]
-    fn test_error_display() {
-        // Test error message display
-        let custom_error = Error::custom("test message");
-        assert_eq!(custom_error.to_string(), "Custom error: test message");
-
-        let feature_error = Error::FeatureDisabled("test feature");
-        assert_eq!(feature_error.to_string(), "Feature disabled: test feature");
-
-        let event_bus_error = Error::EventBusStarted;
-        assert_eq!(event_bus_error.to_string(), "Event bus already started");
-
-        let missing_field_error = Error::MissingField("required_field");
-        assert_eq!(missing_field_error.to_string(), "necessary fields are missing:required_field");
-
-        let validation_error = Error::ValidationError("invalid format");
-        assert_eq!(validation_error.to_string(), "field verification failed:invalid format");
-
-        let config_error = Error::ConfigError("invalid config".to_string());
-        assert_eq!(config_error.to_string(), "Configuration error: invalid config");
-    }
-
-    #[test]
-    fn test_error_debug() {
-        // Test Debug trait implementation
-        let custom_error = Error::custom("debug test");
-        let debug_str = format!("{:?}", custom_error);
-        assert!(debug_str.contains("Custom"));
-        assert!(debug_str.contains("debug test"));
-
-        let feature_error = Error::FeatureDisabled("debug feature");
-        let debug_str = format!("{:?}", feature_error);
-        assert!(debug_str.contains("FeatureDisabled"));
-        assert!(debug_str.contains("debug feature"));
-    }
-
-    #[test]
-    fn test_custom_error_creation() {
-        // Test custom error creation
-        let error = Error::custom("test custom error");
-        match error {
-            Error::Custom(msg) => assert_eq!(msg, "test custom error"),
-            _ => panic!("Expected Custom error variant"),
-        }
-
-        // Test empty string
-        let empty_error = Error::custom("");
-        match empty_error {
-            Error::Custom(msg) => assert_eq!(msg, ""),
-            _ => panic!("Expected Custom error variant"),
-        }
-
-        // Test special characters
-        let special_error = Error::custom("Test Chinese 中文 & special chars: !@#$%");
-        match special_error {
-            Error::Custom(msg) => assert_eq!(msg, "Test Chinese 中文 & special chars: !@#$%"),
-            _ => panic!("Expected Custom error variant"),
-        }
-    }
-
-    #[test]
-    fn test_io_error_conversion() {
-        // Test IO error conversion
-        let io_error = io::Error::new(io::ErrorKind::NotFound, "file not found");
-        let converted_error: Error = io_error.into();
-
-        match converted_error {
-            Error::Io(err) => {
-                assert_eq!(err.kind(), io::ErrorKind::NotFound);
-                assert_eq!(err.to_string(), "file not found");
-            }
-            _ => panic!("Expected Io error variant"),
-        }
-
-        // Test different types of IO errors
-        let permission_error = io::Error::new(io::ErrorKind::PermissionDenied, "access denied");
-        let converted: Error = permission_error.into();
-        assert!(matches!(converted, Error::Io(_)));
-    }
-
-    #[test]
-    fn test_serde_error_conversion() {
-        // Test serialization error conversion
-        let invalid_json = r#"{"invalid": json}"#;
-        let serde_error = serde_json::from_str::<serde_json::Value>(invalid_json).unwrap_err();
-        let converted_error: Error = serde_error.into();
-
-        match converted_error {
-            Error::Serde(_) => {
-                // Verify error type is correct
-                assert!(converted_error.to_string().contains("Serialization error"));
-            }
-            _ => panic!("Expected Serde error variant"),
-        }
-    }
-
-    #[test]
-    fn test_config_error_conversion() {
-        // Test configuration error conversion
-        let config_error = ConfigError::Message("invalid configuration".to_string());
-        let converted_error: Error = config_error.into();
-
-        match converted_error {
-            Error::Config(_) => {
-                assert!(converted_error.to_string().contains("Configuration loading error"));
-            }
-            _ => panic!("Expected Config error variant"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_channel_send_error_conversion() {
-        // Test channel send error conversion
-        let (tx, rx) = mpsc::channel::<crate::event::Event>(1);
-        drop(rx); // Close receiver
-
-        // Create a test event
-        use crate::event::{Bucket, Identity, Metadata, Name, Object, Source};
-        use std::collections::HashMap;
-
-        let identity = Identity::new("test-user".to_string());
-        let bucket = Bucket::new("test-bucket".to_string(), identity.clone(), "arn:aws:s3:::test-bucket".to_string());
-        let object = Object::new(
-            "test-key".to_string(),
-            Some(1024),
-            Some("etag123".to_string()),
-            Some("text/plain".to_string()),
-            Some(HashMap::new()),
-            None,
-            "sequencer123".to_string(),
-        );
-        let metadata = Metadata::create("1.0".to_string(), "config1".to_string(), bucket, object);
-        let source = Source::new("localhost".to_string(), "8080".to_string(), "test-agent".to_string());
-
-        let test_event = crate::event::Event::builder()
-            .event_name(Name::ObjectCreatedPut)
-            .s3(metadata)
-            .source(source)
-            .build()
-            .unwrap();
-
-        let send_result = tx.send(test_event).await;
-        assert!(send_result.is_err());
-
-        let send_error = send_result.unwrap_err();
-        let boxed_error = Box::new(send_error);
-        let converted_error: Error = boxed_error.into();
-
-        match converted_error {
-            Error::ChannelSend(_) => {
-                assert!(converted_error.to_string().contains("Channel send error"));
-            }
-            _ => panic!("Expected ChannelSend error variant"),
-        }
-    }
-
-    #[test]
-    fn test_error_source_chain() {
-        // 测试错误源链
-        let io_error = io::Error::new(io::ErrorKind::InvalidData, "invalid data");
-        let converted_error: Error = io_error.into();
-
-        // 验证错误源
-        assert!(converted_error.source().is_some());
-        let source = converted_error.source().unwrap();
-        assert_eq!(source.to_string(), "invalid data");
-    }
-
-    #[test]
-    fn test_error_variants_exhaustive() {
-        // 测试所有错误变体的创建
-        let errors = vec![
-            Error::FeatureDisabled("test"),
-            Error::EventBusStarted,
-            Error::MissingField("field"),
-            Error::ValidationError("validation"),
-            Error::Custom("custom".to_string()),
-            Error::ConfigError("config".to_string()),
-        ];
-
-        for error in errors {
-            // 验证每个错误都能正确显示
-            let error_str = error.to_string();
-            assert!(!error_str.is_empty());
-
-            // 验证每个错误都能正确调试
-            let debug_str = format!("{:?}", error);
-            assert!(!debug_str.is_empty());
-        }
-    }
-
-    #[test]
-    fn test_error_equality_and_matching() {
-        // 测试错误的模式匹配
-        let custom_error = Error::custom("test");
-        match custom_error {
-            Error::Custom(msg) => assert_eq!(msg, "test"),
-            _ => panic!("Pattern matching failed"),
-        }
-
-        let feature_error = Error::FeatureDisabled("feature");
-        match feature_error {
-            Error::FeatureDisabled(feature) => assert_eq!(feature, "feature"),
-            _ => panic!("Pattern matching failed"),
-        }
-
-        let event_bus_error = Error::EventBusStarted;
-        match event_bus_error {
-            Error::EventBusStarted => {} // 正确匹配
-            _ => panic!("Pattern matching failed"),
-        }
-    }
-
-    #[test]
-    fn test_error_message_formatting() {
-        // 测试错误消息格式化
-        let test_cases = vec![
-            (Error::FeatureDisabled("kafka"), "Feature disabled: kafka"),
-            (Error::MissingField("bucket_name"), "necessary fields are missing:bucket_name"),
-            (Error::ValidationError("invalid email"), "field verification failed:invalid email"),
-            (Error::ConfigError("missing file".to_string()), "Configuration error: missing file"),
-        ];
-
-        for (error, expected_message) in test_cases {
-            assert_eq!(error.to_string(), expected_message);
-        }
-    }
-
-    #[test]
-    fn test_error_memory_efficiency() {
-        // 测试错误类型的内存效率
-        use std::mem;
-
-        let size = mem::size_of::<Error>();
-        // 错误类型应该相对紧凑，考虑到包含多种错误类型，96 字节是合理的
-        assert!(size <= 128, "Error size should be reasonable, got {} bytes", size);
-
-        // 测试 Option<Error>的大小
-        let option_size = mem::size_of::<Option<Error>>();
-        assert!(option_size <= 136, "Option<Error> should be efficient, got {} bytes", option_size);
-    }
-
-    #[test]
-    fn test_error_thread_safety() {
-        // 测试错误类型的线程安全性
-        fn assert_send<T: Send>() {}
-        fn assert_sync<T: Sync>() {}
-
-        assert_send::<Error>();
-        assert_sync::<Error>();
-    }
-
-    #[test]
-    fn test_custom_error_edge_cases() {
-        // 测试自定义错误的边界情况
-        let long_message = "a".repeat(1000);
-        let long_error = Error::custom(&long_message);
-        match long_error {
-            Error::Custom(msg) => assert_eq!(msg.len(), 1000),
-            _ => panic!("Expected Custom error variant"),
-        }
-
-        // 测试包含换行符的消息
-        let multiline_error = Error::custom("line1\nline2\nline3");
-        match multiline_error {
-            Error::Custom(msg) => assert!(msg.contains('\n')),
-            _ => panic!("Expected Custom error variant"),
-        }
-
-        // 测试包含 Unicode 字符的消息
-        let unicode_error = Error::custom("🚀 Unicode test 测试 🎉");
-        match unicode_error {
-            Error::Custom(msg) => assert!(msg.contains('🚀')),
-            _ => panic!("Expected Custom error variant"),
-        }
-    }
-
-    #[test]
-    fn test_error_conversion_consistency() {
-        // 测试错误转换的一致性
-        let original_io_error = io::Error::new(io::ErrorKind::TimedOut, "timeout");
-        let error_message = original_io_error.to_string();
-        let converted: Error = original_io_error.into();
-
-        // 验证转换后的错误包含原始错误信息
-        assert!(converted.to_string().contains(&error_message));
-    }
-
-    #[test]
-    fn test_error_downcast() {
-        // 测试错误的向下转型
-        let io_error = io::Error::other("test error");
-        let converted: Error = io_error.into();
-
-        // 验证可以获取源错误
-        if let Error::Io(ref inner) = converted {
-            assert_eq!(inner.to_string(), "test error");
-            assert_eq!(inner.kind(), io::ErrorKind::Other);
-        } else {
-            panic!("Expected Io error variant");
-        }
-    }
-
-    #[test]
-    fn test_error_chain_depth() {
-        // 测试错误链的深度
-        let root_cause = io::Error::other("root cause");
-        let converted: Error = root_cause.into();
-
-        let mut depth = 0;
-        let mut current_error: &dyn StdError = &converted;
-
-        while let Some(source) = current_error.source() {
-            depth += 1;
-            current_error = source;
-            // 防止无限循环
-            if depth > 10 {
-                break;
-            }
-        }
-
-        assert!(depth > 0, "Error should have at least one source");
-        assert!(depth <= 3, "Error chain should not be too deep");
-    }
-
-    #[test]
-    fn test_static_str_lifetime() {
-        // 测试静态字符串生命周期
-        fn create_feature_error() -> Error {
-            Error::FeatureDisabled("static_feature")
-        }
-
-        let error = create_feature_error();
-        match error {
-            Error::FeatureDisabled(feature) => assert_eq!(feature, "static_feature"),
-            _ => panic!("Expected FeatureDisabled error variant"),
-        }
-    }
-
-    #[test]
-    fn test_error_formatting_consistency() {
-        // 测试错误格式化的一致性
-        let errors = vec![
-            Error::FeatureDisabled("test"),
-            Error::MissingField("field"),
-            Error::ValidationError("validation"),
-            Error::Custom("custom".to_string()),
-        ];
-
-        for error in errors {
-            let display_str = error.to_string();
-            let debug_str = format!("{:?}", error);
-
-            // Display 和 Debug 都不应该为空
-            assert!(!display_str.is_empty());
-            assert!(!debug_str.is_empty());
-
-            // Debug 输出通常包含更多信息，但不是绝对的
-            // 这里我们只验证两者都有内容即可
-            assert!(!debug_str.is_empty());
-            assert!(!display_str.is_empty());
-        }
-    }
-}
diff --git a/crates/event-notifier/src/event.rs b/crates/event-notifier/src/event.rs
deleted file mode 100644
index 16eabccc..00000000
--- a/crates/event-notifier/src/event.rs
+++ /dev/null
@@ -1,616 +0,0 @@
-use crate::Error;
-use serde::{Deserialize, Serialize};
-use serde_with::{DeserializeFromStr, SerializeDisplay};
-use smallvec::{SmallVec, smallvec};
-use std::borrow::Cow;
-use std::collections::HashMap;
-use std::time::{SystemTime, UNIX_EPOCH};
-use strum::{Display, EnumString};
-use uuid::Uuid;
-
-/// A struct representing the identity of the user
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct Identity {
-    #[serde(rename = "principalId")]
-    pub principal_id: String,
-}
-
-impl Identity {
-    /// Create a new Identity instance
-    pub fn new(principal_id: String) -> Self {
-        Self { principal_id }
-    }
-
-    /// Set the principal ID
-    pub fn set_principal_id(&mut self, principal_id: String) {
-        self.principal_id = principal_id;
-    }
-}
-
-/// A struct representing the bucket information
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct Bucket {
-    pub name: String,
-    #[serde(rename = "ownerIdentity")]
-    pub owner_identity: Identity,
-    pub arn: String,
-}
-
-impl Bucket {
-    /// Create a new Bucket instance
-    pub fn new(name: String, owner_identity: Identity, arn: String) -> Self {
-        Self {
-            name,
-            owner_identity,
-            arn,
-        }
-    }
-
-    /// Set the name of the bucket
-    pub fn set_name(&mut self, name: String) {
-        self.name = name;
-    }
-
-    /// Set the ARN of the bucket
-    pub fn set_arn(&mut self, arn: String) {
-        self.arn = arn;
-    }
-
-    /// Set the owner identity of the bucket
-    pub fn set_owner_identity(&mut self, owner_identity: Identity) {
-        self.owner_identity = owner_identity;
-    }
-}
-
-/// A struct representing the object information
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct Object {
-    pub key: String,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub size: Option<i64>,
-    #[serde(default, skip_serializing_if = "Option::is_none", rename = "eTag")]
-    pub etag: Option<String>,
-    #[serde(default, skip_serializing_if = "Option::is_none", rename = "contentType")]
-    pub content_type: Option<String>,
-    #[serde(default, skip_serializing_if = "Option::is_none", rename = "userMetadata")]
-    pub user_metadata: Option<HashMap<String, String>>,
-    #[serde(default, skip_serializing_if = "Option::is_none", rename = "versionId")]
-    pub version_id: Option<String>,
-    pub sequencer: String,
-}
-
-impl Object {
-    /// Create a new Object instance
-    pub fn new(
-        key: String,
-        size: Option<i64>,
-        etag: Option<String>,
-        content_type: Option<String>,
-        user_metadata: Option<HashMap<String, String>>,
-        version_id: Option<String>,
-        sequencer: String,
-    ) -> Self {
-        Self {
-            key,
-            size,
-            etag,
-            content_type,
-            user_metadata,
-            version_id,
-            sequencer,
-        }
-    }
-
-    /// Set the key
-    pub fn set_key(&mut self, key: String) {
-        self.key = key;
-    }
-
-    /// Set the size
-    pub fn set_size(&mut self, size: Option<i64>) {
-        self.size = size;
-    }
-
-    /// Set the etag
-    pub fn set_etag(&mut self, etag: Option<String>) {
-        self.etag = etag;
-    }
-
-    /// Set the content type
-    pub fn set_content_type(&mut self, content_type: Option<String>) {
-        self.content_type = content_type;
-    }
-
-    /// Set the user metadata
-    pub fn set_user_metadata(&mut self, user_metadata: Option<HashMap<String, String>>) {
-        self.user_metadata = user_metadata;
-    }
-
-    /// Set the version ID
-    pub fn set_version_id(&mut self, version_id: Option<String>) {
-        self.version_id = version_id;
-    }
-
-    /// Set the sequencer
-    pub fn set_sequencer(&mut self, sequencer: String) {
-        self.sequencer = sequencer;
-    }
-}
-
-/// A struct representing the metadata of the event
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct Metadata {
-    #[serde(rename = "s3SchemaVersion")]
-    pub schema_version: String,
-    #[serde(rename = "configurationId")]
-    pub configuration_id: String,
-    pub bucket: Bucket,
-    pub object: Object,
-}
-
-impl Default for Metadata {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl Metadata {
-    /// Create a new Metadata instance with default values
-    pub fn new() -> Self {
-        Self {
-            schema_version: "1.0".to_string(),
-            configuration_id: "default".to_string(),
-            bucket: Bucket::new(
-                "default".to_string(),
-                Identity::new("default".to_string()),
-                "arn:aws:s3:::default".to_string(),
-            ),
-            object: Object::new("default".to_string(), None, None, None, None, None, "default".to_string()),
-        }
-    }
-
-    /// Create a new Metadata instance
-    pub fn create(schema_version: String, configuration_id: String, bucket: Bucket, object: Object) -> Self {
-        Self {
-            schema_version,
-            configuration_id,
-            bucket,
-            object,
-        }
-    }
-
-    /// Set the schema version
-    pub fn set_schema_version(&mut self, schema_version: String) {
-        self.schema_version = schema_version;
-    }
-
-    /// Set the configuration ID
-    pub fn set_configuration_id(&mut self, configuration_id: String) {
-        self.configuration_id = configuration_id;
-    }
-
-    /// Set the bucket
-    pub fn set_bucket(&mut self, bucket: Bucket) {
-        self.bucket = bucket;
-    }
-
-    /// Set the object
-    pub fn set_object(&mut self, object: Object) {
-        self.object = object;
-    }
-}
-
-/// A struct representing the source of the event
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct Source {
-    pub host: String,
-    pub port: String,
-    #[serde(rename = "userAgent")]
-    pub user_agent: String,
-}
-
-impl Source {
-    /// Create a new Source instance
-    pub fn new(host: String, port: String, user_agent: String) -> Self {
-        Self { host, port, user_agent }
-    }
-
-    /// Set the host
-    pub fn set_host(&mut self, host: String) {
-        self.host = host;
-    }
-
-    /// Set the port
-    pub fn set_port(&mut self, port: String) {
-        self.port = port;
-    }
-
-    /// Set the user agent
-    pub fn set_user_agent(&mut self, user_agent: String) {
-        self.user_agent = user_agent;
-    }
-}
-
-/// Builder for creating an Event.
-///
-/// This struct is used to build an Event object with various parameters.
-/// It provides methods to set each parameter and a build method to create the Event.
-#[derive(Default, Clone)]
-pub struct EventBuilder {
-    event_version: Option<String>,
-    event_source: Option<String>,
-    aws_region: Option<String>,
-    event_time: Option<String>,
-    event_name: Option<Name>,
-    user_identity: Option<Identity>,
-    request_parameters: Option<HashMap<String, String>>,
-    response_elements: Option<HashMap<String, String>>,
-    s3: Option<Metadata>,
-    source: Option<Source>,
-    channels: Option<SmallVec<[String; 2]>>,
-}
-
-impl EventBuilder {
-    /// create a builder that pre filled default values
-    pub fn new() -> Self {
-        Self {
-            event_version: Some(Cow::Borrowed("2.0").to_string()),
-            event_source: Some(Cow::Borrowed("aws:s3").to_string()),
-            aws_region: Some("us-east-1".to_string()),
-            event_time: Some(SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs().to_string()),
-            event_name: None,
-            user_identity: Some(Identity {
-                principal_id: "anonymous".to_string(),
-            }),
-            request_parameters: Some(HashMap::new()),
-            response_elements: Some(HashMap::new()),
-            s3: None,
-            source: None,
-            channels: Some(Vec::new().into()),
-        }
-    }
-
-    /// verify and set the event version
-    pub fn event_version(mut self, event_version: impl Into<String>) -> Self {
-        let event_version = event_version.into();
-        if !event_version.is_empty() {
-            self.event_version = Some(event_version);
-        }
-        self
-    }
-
-    /// verify and set the event source
-    pub fn event_source(mut self, event_source: impl Into<String>) -> Self {
-        let event_source = event_source.into();
-        if !event_source.is_empty() {
-            self.event_source = Some(event_source);
-        }
-        self
-    }
-
-    /// set up aws regions
-    pub fn aws_region(mut self, aws_region: impl Into<String>) -> Self {
-        self.aws_region = Some(aws_region.into());
-        self
-    }
-
-    /// set event time
-    pub fn event_time(mut self, event_time: impl Into<String>) -> Self {
-        self.event_time = Some(event_time.into());
-        self
-    }
-
-    /// set event name
-    pub fn event_name(mut self, event_name: Name) -> Self {
-        self.event_name = Some(event_name);
-        self
-    }
-
-    /// set user identity
-    pub fn user_identity(mut self, user_identity: Identity) -> Self {
-        self.user_identity = Some(user_identity);
-        self
-    }
-
-    /// set request parameters
-    pub fn request_parameters(mut self, request_parameters: HashMap<String, String>) -> Self {
-        self.request_parameters = Some(request_parameters);
-        self
-    }
-
-    /// set response elements
-    pub fn response_elements(mut self, response_elements: HashMap<String, String>) -> Self {
-        self.response_elements = Some(response_elements);
-        self
-    }
-
-    /// setting up s3 metadata
-    pub fn s3(mut self, s3: Metadata) -> Self {
-        self.s3 = Some(s3);
-        self
-    }
-
-    /// set event source information
-    pub fn source(mut self, source: Source) -> Self {
-        self.source = Some(source);
-        self
-    }
-
-    /// set up the sending channel
-    pub fn channels(mut self, channels: Vec<String>) -> Self {
-        self.channels = Some(channels.into());
-        self
-    }
-
-    /// Create a preconfigured builder for common object event scenarios
-    pub fn for_object_creation(s3: Metadata, source: Source) -> Self {
-        Self::new().event_name(Name::ObjectCreatedPut).s3(s3).source(source)
-    }
-
-    /// Create a preconfigured builder for object deletion events
-    pub fn for_object_removal(s3: Metadata, source: Source) -> Self {
-        Self::new().event_name(Name::ObjectRemovedDelete).s3(s3).source(source)
-    }
-
-    /// build event instance
-    ///
-    /// Verify the required fields and create a complete Event object
-    pub fn build(self) -> Result<Event, Error> {
-        let event_version = self.event_version.ok_or(Error::MissingField("event_version"))?;
-
-        let event_source = self.event_source.ok_or(Error::MissingField("event_source"))?;
-
-        let aws_region = self.aws_region.ok_or(Error::MissingField("aws_region"))?;
-
-        let event_time = self.event_time.ok_or(Error::MissingField("event_time"))?;
-
-        let event_name = self.event_name.ok_or(Error::MissingField("event_name"))?;
-
-        let user_identity = self.user_identity.ok_or(Error::MissingField("user_identity"))?;
-
-        let request_parameters = self.request_parameters.unwrap_or_default();
-        let response_elements = self.response_elements.unwrap_or_default();
-
-        let s3 = self.s3.ok_or(Error::MissingField("s3"))?;
-
-        let source = self.source.ok_or(Error::MissingField("source"))?;
-
-        let channels = self.channels.unwrap_or_else(|| smallvec![]);
-
-        Ok(Event {
-            event_version,
-            event_source,
-            aws_region,
-            event_time,
-            event_name,
-            user_identity,
-            request_parameters,
-            response_elements,
-            s3,
-            source,
-            id: Uuid::new_v4(),
-            timestamp: SystemTime::now(),
-            channels,
-        })
-    }
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct Event {
-    #[serde(rename = "eventVersion")]
-    pub event_version: String,
-    #[serde(rename = "eventSource")]
-    pub event_source: String,
-    #[serde(rename = "awsRegion")]
-    pub aws_region: String,
-    #[serde(rename = "eventTime")]
-    pub event_time: String,
-    #[serde(rename = "eventName")]
-    pub event_name: Name,
-    #[serde(rename = "userIdentity")]
-    pub user_identity: Identity,
-    #[serde(rename = "requestParameters")]
-    pub request_parameters: HashMap<String, String>,
-    #[serde(rename = "responseElements")]
-    pub response_elements: HashMap<String, String>,
-    pub s3: Metadata,
-    pub source: Source,
-    pub id: Uuid,
-    pub timestamp: SystemTime,
-    pub channels: SmallVec<[String; 2]>,
-}
-
-impl Event {
-    /// create a new event builder
-    ///
-    /// Returns an EventBuilder instance pre-filled with default values
-    pub fn builder() -> EventBuilder {
-        EventBuilder::new()
-    }
-
-    /// Quickly create Event instances with necessary fields
-    ///
-    /// suitable for common s3 event scenarios
-    pub fn create(event_name: Name, s3: Metadata, source: Source, channels: Vec<String>) -> Self {
-        Self::builder()
-            .event_name(event_name)
-            .s3(s3)
-            .source(source)
-            .channels(channels)
-            .build()
-            .expect("Failed to create event, missing necessary parameters")
-    }
-
-    /// a convenient way to create a preconfigured builder
-    pub fn for_object_creation(s3: Metadata, source: Source) -> EventBuilder {
-        EventBuilder::for_object_creation(s3, source)
-    }
-
-    /// a convenient way to create a preconfigured builder
-    pub fn for_object_removal(s3: Metadata, source: Source) -> EventBuilder {
-        EventBuilder::for_object_removal(s3, source)
-    }
-
-    /// Determine whether an event belongs to a specific type
-    pub fn is_type(&self, event_type: Name) -> bool {
-        let mask = event_type.mask();
-        (self.event_name.mask() & mask) != 0
-    }
-
-    /// Determine whether an event needs to be sent to a specific channel
-    pub fn is_for_channel(&self, channel: &str) -> bool {
-        self.channels.iter().any(|c| c == channel)
-    }
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct Log {
-    #[serde(rename = "eventName")]
-    pub event_name: Name,
-    pub key: String,
-    pub records: Vec<Event>,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, SerializeDisplay, DeserializeFromStr, Display, EnumString)]
-#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
-pub enum Name {
-    ObjectAccessedGet,
-    ObjectAccessedGetRetention,
-    ObjectAccessedGetLegalHold,
-    ObjectAccessedHead,
-    ObjectAccessedAttributes,
-    ObjectCreatedCompleteMultipartUpload,
-    ObjectCreatedCopy,
-    ObjectCreatedPost,
-    ObjectCreatedPut,
-    ObjectCreatedPutRetention,
-    ObjectCreatedPutLegalHold,
-    ObjectCreatedPutTagging,
-    ObjectCreatedDeleteTagging,
-    ObjectRemovedDelete,
-    ObjectRemovedDeleteMarkerCreated,
-    ObjectRemovedDeleteAllVersions,
-    ObjectRemovedNoOp,
-    BucketCreated,
-    BucketRemoved,
-    ObjectReplicationFailed,
-    ObjectReplicationComplete,
-    ObjectReplicationMissedThreshold,
-    ObjectReplicationReplicatedAfterThreshold,
-    ObjectReplicationNotTracked,
-    ObjectRestorePost,
-    ObjectRestoreCompleted,
-    ObjectTransitionFailed,
-    ObjectTransitionComplete,
-    ObjectManyVersions,
-    ObjectLargeVersions,
-    PrefixManyFolders,
-    IlmDelMarkerExpirationDelete,
-    ObjectAccessedAll,
-    ObjectCreatedAll,
-    ObjectRemovedAll,
-    ObjectReplicationAll,
-    ObjectRestoreAll,
-    ObjectTransitionAll,
-    ObjectScannerAll,
-    Everything,
-}
-
-impl Name {
-    pub fn expand(&self) -> Vec<Name> {
-        match self {
-            Name::ObjectAccessedAll => vec![
-                Name::ObjectAccessedGet,
-                Name::ObjectAccessedHead,
-                Name::ObjectAccessedGetRetention,
-                Name::ObjectAccessedGetLegalHold,
-                Name::ObjectAccessedAttributes,
-            ],
-            Name::ObjectCreatedAll => vec![
-                Name::ObjectCreatedCompleteMultipartUpload,
-                Name::ObjectCreatedCopy,
-                Name::ObjectCreatedPost,
-                Name::ObjectCreatedPut,
-                Name::ObjectCreatedPutRetention,
-                Name::ObjectCreatedPutLegalHold,
-                Name::ObjectCreatedPutTagging,
-                Name::ObjectCreatedDeleteTagging,
-            ],
-            Name::ObjectRemovedAll => vec![
-                Name::ObjectRemovedDelete,
-                Name::ObjectRemovedDeleteMarkerCreated,
-                Name::ObjectRemovedNoOp,
-                Name::ObjectRemovedDeleteAllVersions,
-            ],
-            Name::ObjectReplicationAll => vec![
-                Name::ObjectReplicationFailed,
-                Name::ObjectReplicationComplete,
-                Name::ObjectReplicationNotTracked,
-                Name::ObjectReplicationMissedThreshold,
-                Name::ObjectReplicationReplicatedAfterThreshold,
-            ],
-            Name::ObjectRestoreAll => vec![Name::ObjectRestorePost, Name::ObjectRestoreCompleted],
-            Name::ObjectTransitionAll => {
-                vec![Name::ObjectTransitionFailed, Name::ObjectTransitionComplete]
-            }
-            Name::ObjectScannerAll => vec![Name::ObjectManyVersions, Name::ObjectLargeVersions, Name::PrefixManyFolders],
-            Name::Everything => (1..=Name::IlmDelMarkerExpirationDelete as u32)
-                .map(|i| Name::from_repr(i).unwrap())
-                .collect(),
-            _ => vec![*self],
-        }
-    }
-
-    pub fn mask(&self) -> u64 {
-        if (*self as u32) < Name::ObjectAccessedAll as u32 {
-            1 << (*self as u32 - 1)
-        } else {
-            self.expand().iter().fold(0, |acc, n| acc | (1 << (*n as u32 - 1)))
-        }
-    }
-
-    fn from_repr(discriminant: u32) -> Option<Self> {
-        match discriminant {
-            1 => Some(Name::ObjectAccessedGet),
-            2 => Some(Name::ObjectAccessedGetRetention),
-            3 => Some(Name::ObjectAccessedGetLegalHold),
-            4 => Some(Name::ObjectAccessedHead),
-            5 => Some(Name::ObjectAccessedAttributes),
-            6 => Some(Name::ObjectCreatedCompleteMultipartUpload),
-            7 => Some(Name::ObjectCreatedCopy),
-            8 => Some(Name::ObjectCreatedPost),
-            9 => Some(Name::ObjectCreatedPut),
-            10 => Some(Name::ObjectCreatedPutRetention),
-            11 => Some(Name::ObjectCreatedPutLegalHold),
-            12 => Some(Name::ObjectCreatedPutTagging),
-            13 => Some(Name::ObjectCreatedDeleteTagging),
-            14 => Some(Name::ObjectRemovedDelete),
-            15 => Some(Name::ObjectRemovedDeleteMarkerCreated),
-            16 => Some(Name::ObjectRemovedDeleteAllVersions),
-            17 => Some(Name::ObjectRemovedNoOp),
-            18 => Some(Name::BucketCreated),
-            19 => Some(Name::BucketRemoved),
-            20 => Some(Name::ObjectReplicationFailed),
-            21 => Some(Name::ObjectReplicationComplete),
-            22 => Some(Name::ObjectReplicationMissedThreshold),
-            23 => Some(Name::ObjectReplicationReplicatedAfterThreshold),
-            24 => Some(Name::ObjectReplicationNotTracked),
-            25 => Some(Name::ObjectRestorePost),
-            26 => Some(Name::ObjectRestoreCompleted),
-            27 => Some(Name::ObjectTransitionFailed),
-            28 => Some(Name::ObjectTransitionComplete),
-            29 => Some(Name::ObjectManyVersions),
-            30 => Some(Name::ObjectLargeVersions),
-            31 => Some(Name::PrefixManyFolders),
-            32 => Some(Name::IlmDelMarkerExpirationDelete),
-            33 => Some(Name::ObjectAccessedAll),
-            34 => Some(Name::ObjectCreatedAll),
-            35 => Some(Name::ObjectRemovedAll),
-            36 => Some(Name::ObjectReplicationAll),
-            37 => Some(Name::ObjectRestoreAll),
-            38 => Some(Name::ObjectTransitionAll),
-            39 => Some(Name::ObjectScannerAll),
-            40 => Some(Name::Everything),
-            _ => None,
-        }
-    }
-}
diff --git a/crates/event-notifier/src/global.rs b/crates/event-notifier/src/global.rs
deleted file mode 100644
index c9995c38..00000000
--- a/crates/event-notifier/src/global.rs
+++ /dev/null
@@ -1,234 +0,0 @@
-use crate::{Error, Event, NotifierConfig, NotifierSystem, create_adapters};
-use std::sync::{Arc, atomic};
-use tokio::sync::{Mutex, OnceCell};
-use tracing::instrument;
-
-static GLOBAL_SYSTEM: OnceCell<Arc<Mutex<NotifierSystem>>> = OnceCell::const_new();
-static INITIALIZED: atomic::AtomicBool = atomic::AtomicBool::new(false);
-static READY: atomic::AtomicBool = atomic::AtomicBool::new(false);
-static INIT_LOCK: Mutex<()> = Mutex::const_new(());
-
-/// Initializes the global notification system.
-///
-/// This function performs the following steps:
-/// 1. Checks if the system is already initialized.
-/// 2. Creates a new `NotificationSystem` instance.
-/// 3. Creates adapters based on the provided configuration.
-/// 4. Starts the notification system with the created adapters.
-/// 5. Sets the global system instance.
-///
-/// # Errors
-///
-/// Returns an error if:
-/// - The system is already initialized.
-/// - Creating the `NotificationSystem` fails.
-/// - Creating adapters fails.
-/// - Starting the notification system fails.
-/// - Setting the global system instance fails.
-pub async fn initialize(config: NotifierConfig) -> Result<(), Error> {
-    let _lock = INIT_LOCK.lock().await;
-
-    // Check if the system is already initialized.
-    if INITIALIZED.load(atomic::Ordering::SeqCst) {
-        return Err(Error::custom("Notification system has already been initialized"));
-    }
-
-    // Check if the system is already ready.
-    if READY.load(atomic::Ordering::SeqCst) {
-        return Err(Error::custom("Notification system is already ready"));
-    }
-
-    // Check if the system is shutting down.
-    if let Some(system) = GLOBAL_SYSTEM.get() {
-        let system_guard = system.lock().await;
-        if system_guard.shutdown_cancelled() {
-            return Err(Error::custom("Notification system is shutting down"));
-        }
-    }
-
-    // check if config adapters len is than 0
-    if config.adapters.is_empty() {
-        return Err(Error::custom("No adapters configured"));
-    }
-
-    // Attempt to initialize, and reset the INITIALIZED flag if it fails.
-    let result: Result<(), Error> = async {
-        let system = NotifierSystem::new(config.clone()).await.map_err(|e| {
-            tracing::error!("Failed to create NotificationSystem: {:?}", e);
-            e
-        })?;
-        let adapters = create_adapters(&config.adapters).map_err(|e| {
-            tracing::error!("Failed to create adapters: {:?}", e);
-            e
-        })?;
-        tracing::info!("adapters len:{:?}", adapters.len());
-        let system_clone = Arc::new(Mutex::new(system));
-        let adapters_clone = adapters.clone();
-
-        GLOBAL_SYSTEM.set(system_clone.clone()).map_err(|_| {
-            let err = Error::custom("Unable to set up global notification system");
-            tracing::error!("{:?}", err);
-            err
-        })?;
-
-        tokio::spawn(async move {
-            if let Err(e) = system_clone.lock().await.start(adapters_clone).await {
-                tracing::error!("Notification system failed to start: {}", e);
-            }
-            tracing::info!("Notification system started in background");
-        });
-        tracing::info!("system start success,start set READY value");
-
-        READY.store(true, atomic::Ordering::SeqCst);
-        tracing::info!("Notification system is ready to process events");
-
-        Ok(())
-    }
-    .await;
-
-    if result.is_err() {
-        INITIALIZED.store(false, atomic::Ordering::SeqCst);
-        READY.store(false, atomic::Ordering::SeqCst);
-        return result;
-    }
-
-    INITIALIZED.store(true, atomic::Ordering::SeqCst);
-    Ok(())
-}
-
-/// Checks if the notification system is initialized.
-pub fn is_initialized() -> bool {
-    INITIALIZED.load(atomic::Ordering::SeqCst)
-}
-
-/// Checks if the notification system is ready.
-pub fn is_ready() -> bool {
-    READY.load(atomic::Ordering::SeqCst)
-}
-
-/// Sends an event to the notification system.
-///
-/// # Errors
-///
-/// Returns an error if:
-/// - The system is not initialized.
-/// - The system is not ready.
-/// - Sending the event fails.
-#[instrument(fields(event))]
-pub async fn send_event(event: Event) -> Result<(), Error> {
-    if !READY.load(atomic::Ordering::SeqCst) {
-        return Err(Error::custom("Notification system not ready, please wait for initialization to complete"));
-    }
-
-    let system = get_system().await?;
-    let system_guard = system.lock().await;
-    system_guard.send_event(event).await
-}
-
-/// Shuts down the notification system.
-#[instrument]
-pub async fn shutdown() -> Result<(), Error> {
-    if let Some(system) = GLOBAL_SYSTEM.get() {
-        tracing::info!("Shutting down notification system start");
-        let result = {
-            let mut system_guard = system.lock().await;
-            system_guard.shutdown().await
-        };
-        if let Err(e) = &result {
-            tracing::error!("Notification system shutdown failed: {}", e);
-        } else {
-            tracing::info!("Event bus shutdown completed");
-        }
-
-        tracing::info!(
-            "Shutdown method called set static value start, READY: {}, INITIALIZED: {}",
-            READY.load(atomic::Ordering::SeqCst),
-            INITIALIZED.load(atomic::Ordering::SeqCst)
-        );
-        READY.store(false, atomic::Ordering::SeqCst);
-        INITIALIZED.store(false, atomic::Ordering::SeqCst);
-        tracing::info!(
-            "Shutdown method called  set static value end, READY: {}, INITIALIZED: {}",
-            READY.load(atomic::Ordering::SeqCst),
-            INITIALIZED.load(atomic::Ordering::SeqCst)
-        );
-        result
-    } else {
-        Err(Error::custom("Notification system not initialized"))
-    }
-}
-
-/// Retrieves the global notification system instance.
-///
-/// # Errors
-///
-/// Returns an error if the system is not initialized.
-async fn get_system() -> Result<Arc<Mutex<NotifierSystem>>, Error> {
-    GLOBAL_SYSTEM
-        .get()
-        .cloned()
-        .ok_or_else(|| Error::custom("Notification system not initialized"))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::NotifierConfig;
-
-    fn init_tracing() {
-        // Use try_init to avoid panic if already initialized
-        let _ = tracing_subscriber::fmt::try_init();
-    }
-
-    #[tokio::test]
-    async fn test_initialize_success() {
-        init_tracing();
-        let config = NotifierConfig::default(); // assume there is a default configuration
-        let result = initialize(config).await;
-        assert!(result.is_err(), "Initialization should not succeed");
-        assert!(!is_initialized(), "System should not be marked as initialized");
-        assert!(!is_ready(), "System should not be marked as ready");
-    }
-
-    #[tokio::test]
-    async fn test_initialize_twice() {
-        init_tracing();
-        let config = NotifierConfig::default();
-        let _ = initialize(config.clone()).await; // first initialization
-        let result = initialize(config).await; // second initialization
-        assert!(result.is_err(), "Initialization should succeed");
-        assert!(result.is_err(), "Re-initialization should fail");
-    }
-
-    #[tokio::test]
-    async fn test_initialize_failure_resets_state() {
-        init_tracing();
-        // Test with empty adapters to force failure
-        let config = NotifierConfig {
-            adapters: Vec::new(),
-            ..Default::default()
-        };
-        let result = initialize(config).await;
-        assert!(result.is_err(), "Initialization should fail with empty adapters");
-        assert!(!is_initialized(), "System should not be marked as initialized after failure");
-        assert!(!is_ready(), "System should not be marked as ready after failure");
-    }
-
-    #[tokio::test]
-    async fn test_is_initialized_and_is_ready() {
-        init_tracing();
-        // Initially, the system should not be initialized or ready
-        assert!(!is_initialized(), "System should not be initialized initially");
-        assert!(!is_ready(), "System should not be ready initially");
-
-        // Test with empty adapters to ensure failure
-        let config = NotifierConfig {
-            adapters: Vec::new(),
-            ..Default::default()
-        };
-        let result = initialize(config).await;
-        assert!(result.is_err(), "Initialization should fail with empty adapters");
-        assert!(!is_initialized(), "System should not be initialized after failed init");
-        assert!(!is_ready(), "System should not be ready after failed init");
-    }
-}
diff --git a/crates/event-notifier/src/lib.rs b/crates/event-notifier/src/lib.rs
deleted file mode 100644
index e840aa7a..00000000
--- a/crates/event-notifier/src/lib.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-mod adapter;
-mod bus;
-mod config;
-mod error;
-mod event;
-mod global;
-mod notifier;
-mod store;
-
-pub use adapter::ChannelAdapter;
-pub use adapter::create_adapters;
-#[cfg(all(feature = "kafka", target_os = "linux"))]
-pub use adapter::kafka::KafkaAdapter;
-#[cfg(feature = "mqtt")]
-pub use adapter::mqtt::MqttAdapter;
-#[cfg(feature = "webhook")]
-pub use adapter::webhook::WebhookAdapter;
-pub use bus::event_bus;
-#[cfg(all(feature = "kafka", target_os = "linux"))]
-pub use config::KafkaConfig;
-#[cfg(feature = "mqtt")]
-pub use config::MqttConfig;
-#[cfg(feature = "webhook")]
-pub use config::WebhookConfig;
-pub use config::{AdapterConfig, NotifierConfig};
-pub use error::Error;
-
-pub use event::{Bucket, Event, EventBuilder, Identity, Log, Metadata, Name, Object, Source};
-pub use global::{initialize, is_initialized, is_ready, send_event, shutdown};
-pub use notifier::NotifierSystem;
-pub use store::EventStore;
diff --git a/crates/event-notifier/src/notifier.rs b/crates/event-notifier/src/notifier.rs
deleted file mode 100644
index 21f6ac58..00000000
--- a/crates/event-notifier/src/notifier.rs
+++ /dev/null
@@ -1,136 +0,0 @@
-use crate::{ChannelAdapter, Error, Event, EventStore, NotifierConfig, event_bus};
-use std::sync::Arc;
-use tokio::sync::mpsc;
-use tokio_util::sync::CancellationToken;
-use tracing::instrument;
-
-/// The `NotificationSystem` struct represents the notification system.
-/// It manages the event bus and the adapters.
-/// It is responsible for sending and receiving events.
-/// It also handles the shutdown process.
-pub struct NotifierSystem {
-    tx: mpsc::Sender<Event>,
-    rx: Option<mpsc::Receiver<Event>>,
-    store: Arc<EventStore>,
-    shutdown: CancellationToken,
-    shutdown_complete: Option<tokio::sync::oneshot::Sender<()>>,
-    shutdown_receiver: Option<tokio::sync::oneshot::Receiver<()>>,
-}
-
-impl NotifierSystem {
-    /// Creates a new `NotificationSystem` instance.
-    #[instrument(skip(config))]
-    pub async fn new(config: NotifierConfig) -> Result<Self, Error> {
-        let (tx, rx) = mpsc::channel::<Event>(config.channel_capacity);
-        let store = Arc::new(EventStore::new(&config.store_path).await?);
-        let shutdown = CancellationToken::new();
-
-        let restored_logs = store.load_logs().await?;
-        for log in restored_logs {
-            for event in log.records {
-                // For example, where the send method may return a SendError when calling it
-                tx.send(event).await.map_err(|e| Error::ChannelSend(Box::new(e)))?;
-            }
-        }
-        // Initialize shutdown_complete to Some(tx)
-        let (complete_tx, complete_rx) = tokio::sync::oneshot::channel();
-        Ok(Self {
-            tx,
-            rx: Some(rx),
-            store,
-            shutdown,
-            shutdown_complete: Some(complete_tx),
-            shutdown_receiver: Some(complete_rx),
-        })
-    }
-
-    /// Starts the notification system.
-    /// It initializes the event bus and the producer.
-    #[instrument(skip_all)]
-    pub async fn start(&mut self, adapters: Vec<Arc<dyn ChannelAdapter>>) -> Result<(), Error> {
-        if self.shutdown.is_cancelled() {
-            let error = Error::custom("System is shutting down");
-            self.handle_error("start", &error);
-            return Err(error);
-        }
-        self.log(tracing::Level::INFO, "start", "Starting the notification system");
-        let rx = self.rx.take().ok_or_else(|| Error::EventBusStarted)?;
-        let shutdown_clone = self.shutdown.clone();
-        let store_clone = self.store.clone();
-        let shutdown_complete = self.shutdown_complete.take();
-
-        tokio::spawn(async move {
-            if let Err(e) = event_bus(rx, adapters, store_clone, shutdown_clone, shutdown_complete).await {
-                tracing::error!("Event bus failed: {}", e);
-            }
-        });
-        self.log(tracing::Level::INFO, "start", "Notification system started successfully");
-        Ok(())
-    }
-
-    /// Sends an event to the notification system.
-    /// This method is used to send events to the event bus.
-    #[instrument(skip(self))]
-    pub async fn send_event(&self, event: Event) -> Result<(), Error> {
-        self.log(tracing::Level::DEBUG, "send_event", &format!("Sending event: {:?}", event));
-        if self.shutdown.is_cancelled() {
-            let error = Error::custom("System is shutting down");
-            self.handle_error("send_event", &error);
-            return Err(error);
-        }
-        if let Err(e) = self.tx.send(event).await {
-            let error = Error::ChannelSend(Box::new(e));
-            self.handle_error("send_event", &error);
-            return Err(error);
-        }
-        self.log(tracing::Level::INFO, "send_event", "Event sent successfully");
-        Ok(())
-    }
-
-    /// Shuts down the notification system.
-    /// This method is used to cancel the event bus and producer tasks.
-    #[instrument(skip(self))]
-    pub async fn shutdown(&mut self) -> Result<(), Error> {
-        tracing::info!("Shutting down the notification system");
-        self.shutdown.cancel();
-        // wait for the event bus to be completely closed
-        if let Some(receiver) = self.shutdown_receiver.take() {
-            match receiver.await {
-                Ok(_) => {
-                    tracing::info!("Event bus shutdown completed successfully");
-                    Ok(())
-                }
-                Err(e) => {
-                    let error = Error::custom(format!("Failed to receive shutdown completion: {}", e).as_str());
-                    self.handle_error("shutdown", &error);
-                    Err(error)
-                }
-            }
-        } else {
-            tracing::warn!("Shutdown receiver not available, the event bus might still be running");
-            Err(Error::custom("Shutdown receiver not available"))
-        }
-    }
-
-    /// shutdown state  
-    pub fn shutdown_cancelled(&self) -> bool {
-        self.shutdown.is_cancelled()
-    }
-
-    #[instrument(skip(self))]
-    pub fn handle_error(&self, context: &str, error: &Error) {
-        self.log(tracing::Level::ERROR, context, &format!("{:?}", error));
-        // TODO Can be extended to record to files or send to monitoring systems
-    }
-
-    #[instrument(skip(self))]
-    fn log(&self, level: tracing::Level, context: &str, message: &str) {
-        match level {
-            tracing::Level::ERROR => tracing::error!("[{}] {}", context, message),
-            tracing::Level::WARN => tracing::warn!("[{}] {}", context, message),
-            tracing::Level::INFO => tracing::info!("[{}] {}", context, message),
-            tracing::Level::DEBUG => tracing::debug!("[{}] {}", context, message),
-            tracing::Level::TRACE => tracing::trace!("[{}] {}", context, message),
-        }
-    }
-}
diff --git a/crates/event-notifier/src/store.rs b/crates/event-notifier/src/store.rs
deleted file mode 100644
index debc8f83..00000000
--- a/crates/event-notifier/src/store.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use crate::Error;
-use crate::Log;
-use std::sync::Arc;
-use std::time::{SystemTime, UNIX_EPOCH};
-use tokio::fs::{File, OpenOptions, create_dir_all};
-use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader, BufWriter};
-use tokio::sync::RwLock;
-use tracing::instrument;
-
-/// `EventStore` is a struct that manages the storage of event logs.
-pub struct EventStore {
-    path: String,
-    lock: Arc<RwLock<()>>,
-}
-
-impl EventStore {
-    pub async fn new(path: &str) -> Result<Self, Error> {
-        create_dir_all(path).await?;
-        Ok(Self {
-            path: path.to_string(),
-            lock: Arc::new(RwLock::new(())),
-        })
-    }
-
-    #[instrument(skip(self))]
-    pub async fn save_logs(&self, logs: &[Log]) -> Result<(), Error> {
-        let _guard = self.lock.write().await;
-        let file_path = format!(
-            "{}/events_{}.jsonl",
-            self.path,
-            SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs()
-        );
-        let file = OpenOptions::new().create(true).append(true).open(&file_path).await?;
-        let mut writer = BufWriter::new(file);
-        for log in logs {
-            let line = serde_json::to_string(log)?;
-            writer.write_all(line.as_bytes()).await?;
-            writer.write_all(b"\n").await?;
-        }
-        writer.flush().await?;
-        tracing::info!("Saved logs to {} end", file_path);
-        Ok(())
-    }
-
-    pub async fn load_logs(&self) -> Result<Vec<Log>, Error> {
-        let _guard = self.lock.read().await;
-        let mut logs = Vec::new();
-        let mut entries = tokio::fs::read_dir(&self.path).await?;
-        while let Some(entry) = entries.next_entry().await? {
-            let file = File::open(entry.path()).await?;
-            let reader = BufReader::new(file);
-            let mut lines = reader.lines();
-            while let Some(line) = lines.next_line().await? {
-                let log: Log = serde_json::from_str(&line)?;
-                logs.push(log);
-            }
-        }
-        Ok(logs)
-    }
-}
diff --git a/crates/event-notifier/tests/integration.rs b/crates/event-notifier/tests/integration.rs
deleted file mode 100644
index c5743605..00000000
--- a/crates/event-notifier/tests/integration.rs
+++ /dev/null
@@ -1,159 +0,0 @@
-use rustfs_event_notifier::{AdapterConfig, NotifierSystem, WebhookConfig};
-use rustfs_event_notifier::{Bucket, Event, EventBuilder, Identity, Metadata, Name, Object, Source};
-use rustfs_event_notifier::{ChannelAdapter, WebhookAdapter};
-use std::collections::HashMap;
-use std::sync::Arc;
-
-#[tokio::test]
-async fn test_webhook_adapter() {
-    let adapter = WebhookAdapter::new(WebhookConfig {
-        endpoint: "http://localhost:8080/webhook".to_string(),
-        auth_token: None,
-        custom_headers: None,
-        max_retries: 1,
-        timeout: 5,
-    });
-
-    // create an s3 metadata object
-    let metadata = Metadata {
-        schema_version: "1.0".to_string(),
-        configuration_id: "test-config".to_string(),
-        bucket: Bucket {
-            name: "my-bucket".to_string(),
-            owner_identity: Identity {
-                principal_id: "owner123".to_string(),
-            },
-            arn: "arn:aws:s3:::my-bucket".to_string(),
-        },
-        object: Object {
-            key: "test.txt".to_string(),
-            size: Some(1024),
-            etag: Some("abc123".to_string()),
-            content_type: Some("text/plain".to_string()),
-            user_metadata: None,
-            version_id: None,
-            sequencer: "1234567890".to_string(),
-        },
-    };
-
-    // create source object
-    let source = Source {
-        host: "localhost".to_string(),
-        port: "80".to_string(),
-        user_agent: "curl/7.68.0".to_string(),
-    };
-
-    // Create events using builder mode
-    let event = Event::builder()
-        .event_version("2.0")
-        .event_source("aws:s3")
-        .aws_region("us-east-1")
-        .event_time("2023-10-01T12:00:00.000Z")
-        .event_name(Name::ObjectCreatedPut)
-        .user_identity(Identity {
-            principal_id: "user123".to_string(),
-        })
-        .request_parameters(HashMap::new())
-        .response_elements(HashMap::new())
-        .s3(metadata)
-        .source(source)
-        .channels(vec!["webhook".to_string()])
-        .build()
-        .expect("failed to create event");
-
-    let result = adapter.send(&event).await;
-    assert!(result.is_err());
-}
-
-#[tokio::test]
-async fn test_notification_system() {
-    let config = rustfs_event_notifier::NotifierConfig {
-        store_path: "./test_events".to_string(),
-        channel_capacity: 100,
-        adapters: vec![AdapterConfig::Webhook(WebhookConfig {
-            endpoint: "http://localhost:8080/webhook".to_string(),
-            auth_token: None,
-            custom_headers: None,
-            max_retries: 1,
-            timeout: 5,
-        })],
-    };
-    let system = Arc::new(tokio::sync::Mutex::new(NotifierSystem::new(config.clone()).await.unwrap()));
-    let adapters: Vec<Arc<dyn ChannelAdapter>> = vec![Arc::new(WebhookAdapter::new(WebhookConfig {
-        endpoint: "http://localhost:8080/webhook".to_string(),
-        auth_token: None,
-        custom_headers: None,
-        max_retries: 1,
-        timeout: 5,
-    }))];
-
-    // create an s3 metadata object
-    let metadata = Metadata {
-        schema_version: "1.0".to_string(),
-        configuration_id: "test-config".to_string(),
-        bucket: Bucket {
-            name: "my-bucket".to_string(),
-            owner_identity: Identity {
-                principal_id: "owner123".to_string(),
-            },
-            arn: "arn:aws:s3:::my-bucket".to_string(),
-        },
-        object: Object {
-            key: "test.txt".to_string(),
-            size: Some(1024),
-            etag: Some("abc123".to_string()),
-            content_type: Some("text/plain".to_string()),
-            user_metadata: None,
-            version_id: None,
-            sequencer: "1234567890".to_string(),
-        },
-    };
-
-    // create source object
-    let source = Source {
-        host: "localhost".to_string(),
-        port: "80".to_string(),
-        user_agent: "curl/7.68.0".to_string(),
-    };
-
-    // create a preconfigured builder with objects
-    let event = EventBuilder::for_object_creation(metadata, source)
-        .user_identity(Identity {
-            principal_id: "user123".to_string(),
-        })
-        .event_time("2023-10-01T12:00:00.000Z")
-        .channels(vec!["webhook".to_string()])
-        .build()
-        .expect("failed to create event");
-
-    {
-        let system_lock = system.lock().await;
-        system_lock.send_event(event).await.unwrap();
-    }
-
-    let system_clone = Arc::clone(&system);
-    let system_handle = tokio::spawn(async move {
-        let mut system = system_clone.lock().await;
-        system.start(adapters).await
-    });
-
-    // set 10 seconds timeout
-    match tokio::time::timeout(std::time::Duration::from_secs(10), system_handle).await {
-        Ok(result) => {
-            println!("System started successfully");
-            assert!(result.is_ok());
-        }
-        Err(_) => {
-            println!("System operation timed out, forcing shutdown");
-            // create a new task to handle the timeout
-            let system = Arc::clone(&system);
-            tokio::spawn(async move {
-                if let Ok(mut guard) = system.try_lock() {
-                    guard.shutdown().await.unwrap();
-                }
-            });
-            // give the system some time to clean up resources
-            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-        }
-    }
-}
diff --git a/crates/filemeta/Cargo.toml b/crates/filemeta/Cargo.toml
index 0e96bbd0..03e2310e 100644
--- a/crates/filemeta/Cargo.toml
+++ b/crates/filemeta/Cargo.toml
@@ -15,7 +15,7 @@ time.workspace = true
 uuid = { workspace = true, features = ["v4", "fast-rng", "serde"] }
 tokio = { workspace = true, features = ["io-util", "macros", "sync"] }
 xxhash-rust = { version = "0.8.15", features = ["xxh64"] }
-
+bytes.workspace = true
 rustfs-utils = {workspace = true, features= ["hash"]}
 byteorder = "1.5.0"
 tracing.workspace = true
diff --git a/crates/filemeta/src/error.rs b/crates/filemeta/src/error.rs
index 142436e1..a2136a3e 100644
--- a/crates/filemeta/src/error.rs
+++ b/crates/filemeta/src/error.rs
@@ -111,7 +111,20 @@ impl Clone for Error {
 
 impl From<std::io::Error> for Error {
     fn from(e: std::io::Error) -> Self {
-        Error::Io(e)
+        match e.kind() {
+            std::io::ErrorKind::UnexpectedEof => Error::Unexpected,
+            _ => Error::Io(e),
+        }
+    }
+}
+
+impl From<Error> for std::io::Error {
+    fn from(e: Error) -> Self {
+        match e {
+            Error::Unexpected => std::io::Error::new(std::io::ErrorKind::UnexpectedEof, "Unexpected EOF"),
+            Error::Io(e) => e,
+            _ => std::io::Error::other(e.to_string()),
+        }
     }
 }
 
@@ -414,6 +427,9 @@ mod tests {
             let filemeta_error: Error = io_error.into();
 
             match filemeta_error {
+                Error::Unexpected => {
+                    assert_eq!(kind, ErrorKind::UnexpectedEof);
+                }
                 Error::Io(extracted_io_error) => {
                     assert_eq!(extracted_io_error.kind(), kind);
                     assert!(extracted_io_error.to_string().contains("test error"));
diff --git a/crates/filemeta/src/fileinfo.rs b/crates/filemeta/src/fileinfo.rs
index b6905157..108a1d4d 100644
--- a/crates/filemeta/src/fileinfo.rs
+++ b/crates/filemeta/src/fileinfo.rs
@@ -1,5 +1,7 @@
 use crate::error::{Error, Result};
 use crate::headers::RESERVED_METADATA_PREFIX_LOWER;
+use crate::headers::RUSTFS_HEALING;
+use bytes::Bytes;
 use rmp_serde::Serializer;
 use rustfs_utils::HashAlgorithm;
 use serde::Deserialize;
@@ -8,9 +10,6 @@ use std::collections::HashMap;
 use time::OffsetDateTime;
 use uuid::Uuid;
 
-use crate::headers::RESERVED_METADATA_PREFIX;
-use crate::headers::RUSTFS_HEALING;
-
 pub const ERASURE_ALGORITHM: &str = "rs-vandermonde";
 pub const BLOCK_SIZE_V2: usize = 1024 * 1024; // 1M
 
@@ -27,10 +26,10 @@ pub struct ObjectPartInfo {
     pub etag: String,
     pub number: usize,
     pub size: usize,
-    pub actual_size: usize, // Original data size
+    pub actual_size: i64, // Original data size
     pub mod_time: Option<OffsetDateTime>,
     // Index holds the index of the part in the erasure coding
-    pub index: Option<Vec<u8>>,
+    pub index: Option<Bytes>,
     // Checksums holds checksums of the part
     pub checksums: Option<HashMap<String, String>>,
 }
@@ -40,7 +39,7 @@ pub struct ObjectPartInfo {
 pub struct ChecksumInfo {
     pub part_number: usize,
     pub algorithm: HashAlgorithm,
-    pub hash: Vec<u8>,
+    pub hash: Bytes,
 }
 
 #[derive(Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Default, Clone)]
@@ -121,15 +120,21 @@ impl ErasureInfo {
     }
     /// Calculate the total erasure file size for a given original size.
     // Returns the final erasure size from the original size
-    pub fn shard_file_size(&self, total_length: usize) -> usize {
+    pub fn shard_file_size(&self, total_length: i64) -> i64 {
         if total_length == 0 {
             return 0;
         }
 
+        if total_length < 0 {
+            return total_length;
+        }
+
+        let total_length = total_length as usize;
+
         let num_shards = total_length / self.block_size;
         let last_block_size = total_length % self.block_size;
         let last_shard_size = calc_shard_size(last_block_size, self.data_blocks);
-        num_shards * self.shard_size() + last_shard_size
+        (num_shards * self.shard_size() + last_shard_size) as i64
     }
 
     /// Check if this ErasureInfo equals another ErasureInfo
@@ -158,7 +163,7 @@ pub struct FileInfo {
     pub expire_restored: bool,
     pub data_dir: Option<Uuid>,
     pub mod_time: Option<OffsetDateTime>,
-    pub size: usize,
+    pub size: i64,
     // File mode bits
     pub mode: Option<u32>,
     // WrittenByVersion is the unix time stamp of the version that created this version of the object
@@ -170,13 +175,13 @@ pub struct FileInfo {
     pub mark_deleted: bool,
     // ReplicationState - Internal replication state to be passed back in ObjectInfo
     // pub replication_state: Option<ReplicationState>, // TODO: implement ReplicationState
-    pub data: Option<Vec<u8>>,
+    pub data: Option<Bytes>,
     pub num_versions: usize,
     pub successor_mod_time: Option<OffsetDateTime>,
     pub fresh: bool,
     pub idx: usize,
     // Combined checksum when object was uploaded
-    pub checksum: Option<Vec<u8>>,
+    pub checksum: Option<Bytes>,
     pub versioned: bool,
 }
 
@@ -261,7 +266,8 @@ impl FileInfo {
         etag: String,
         part_size: usize,
         mod_time: Option<OffsetDateTime>,
-        actual_size: usize,
+        actual_size: i64,
+        index: Option<Bytes>,
     ) {
         let part = ObjectPartInfo {
             etag,
@@ -269,7 +275,7 @@ impl FileInfo {
             size: part_size,
             mod_time,
             actual_size,
-            index: None,
+            index,
             checksums: None,
         };
 
@@ -341,6 +347,12 @@ impl FileInfo {
         self.metadata
             .insert(format!("{}inline-data", RESERVED_METADATA_PREFIX_LOWER).to_owned(), "true".to_owned());
     }
+
+    pub fn set_data_moved(&mut self) {
+        self.metadata
+            .insert(format!("{}data-moved", RESERVED_METADATA_PREFIX_LOWER).to_owned(), "true".to_owned());
+    }
+
     pub fn inline_data(&self) -> bool {
         self.metadata
             .contains_key(format!("{}inline-data", RESERVED_METADATA_PREFIX_LOWER).as_str())
@@ -350,7 +362,7 @@ impl FileInfo {
     /// Check if the object is compressed
     pub fn is_compressed(&self) -> bool {
         self.metadata
-            .contains_key(&format!("{}compression", RESERVED_METADATA_PREFIX))
+            .contains_key(&format!("{}compression", RESERVED_METADATA_PREFIX_LOWER))
     }
 
     /// Check if the object is remote (transitioned to another tier)
@@ -464,7 +476,7 @@ impl FileInfoVersions {
     }
 
     /// Calculate the total size of all versions for this object
-    pub fn size(&self) -> usize {
+    pub fn size(&self) -> i64 {
         self.versions.iter().map(|v| v.size).sum()
     }
 }
diff --git a/crates/filemeta/src/filemeta.rs b/crates/filemeta/src/filemeta.rs
index b389e635..4abaf0e9 100644
--- a/crates/filemeta/src/filemeta.rs
+++ b/crates/filemeta/src/filemeta.rs
@@ -6,10 +6,12 @@ use crate::headers::{
     RESERVED_METADATA_PREFIX_LOWER, VERSION_PURGE_STATUS_KEY,
 };
 use byteorder::ByteOrder;
+use bytes::Bytes;
 use rmp::Marker;
 use s3s::header::X_AMZ_RESTORE;
 use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
+use std::convert::TryFrom;
 use std::hash::Hasher;
 use std::io::{Read, Write};
 use std::{collections::HashMap, io::Cursor};
@@ -433,7 +435,7 @@ impl FileMeta {
 
         if let Some(ref data) = fi.data {
             let key = vid.unwrap_or_default().to_string();
-            self.data.replace(&key, data.clone())?;
+            self.data.replace(&key, data.to_vec())?;
         }
 
         let version = FileMetaVersion::from(fi);
@@ -629,7 +631,10 @@ impl FileMeta {
             }
 
             if read_data {
-                fi.data = self.data.find(fi.version_id.unwrap_or_default().to_string().as_str())?;
+                fi.data = self
+                    .data
+                    .find(fi.version_id.unwrap_or_default().to_string().as_str())?
+                    .map(bytes::Bytes::from);
             }
 
             fi.num_versions = self.versions.len();
@@ -1462,9 +1467,9 @@ pub struct MetaObject {
     pub part_numbers: Vec<usize>,           // Part Numbers
     pub part_etags: Vec<String>,            // Part ETags
     pub part_sizes: Vec<usize>,             // Part Sizes
-    pub part_actual_sizes: Vec<usize>,      // Part ActualSizes (compression)
-    pub part_indices: Vec<Vec<u8>>,         // Part Indexes (compression)
-    pub size: usize,                        // Object version size
+    pub part_actual_sizes: Vec<i64>,        // Part ActualSizes (compression)
+    pub part_indices: Vec<Bytes>,           // Part Indexes (compression)
+    pub size: i64,                          // Object version size
     pub mod_time: Option<OffsetDateTime>,   // Object version modified time
     pub meta_sys: HashMap<String, Vec<u8>>, // Object version internal metadata
     pub meta_user: HashMap<String, String>, // Object version metadata set by user
@@ -1621,7 +1626,7 @@ impl MetaObject {
                         let mut buf = vec![0u8; blen as usize];
                         cur.read_exact(&mut buf)?;
 
-                        indices.push(buf);
+                        indices.push(Bytes::from(buf));
                     }
 
                     self.part_indices = indices;
@@ -1893,13 +1898,16 @@ impl MetaObject {
         }
 
         for (k, v) in &self.meta_sys {
+            if k == AMZ_STORAGE_CLASS && v == b"STANDARD" {
+                continue;
+            }
+
             if k.starts_with(RESERVED_METADATA_PREFIX)
                 || k.starts_with(RESERVED_METADATA_PREFIX_LOWER)
                 || k == VERSION_PURGE_STATUS_KEY
             {
-                continue;
+                metadata.insert(k.to_owned(), String::from_utf8(v.to_owned()).unwrap_or_default());
             }
-            metadata.insert(k.to_owned(), String::from_utf8(v.to_owned()).unwrap_or_default());
         }
 
         // todo: ReplicationState,Delete
@@ -2616,7 +2624,6 @@ pub async fn read_xl_meta_no_data<R: AsyncRead + Unpin>(reader: &mut R, size: us
 }
 #[cfg(test)]
 mod test {
-
     use super::*;
     use crate::test_data::*;
 
@@ -2736,7 +2743,7 @@ mod test {
 
         // 验证基本属性
         assert_eq!(fm.meta_ver, XL_META_VERSION);
-        assert_eq!(fm.versions.len(), 3, "应该有3个版本（1个对象，1个删除标记，1个Legacy）");
+        assert_eq!(fm.versions.len(), 3, "应该有 3 个版本（1 个对象，1 个删除标记，1 个 Legacy）");
 
         // 验证版本类型
         let mut object_count = 0;
@@ -2752,9 +2759,9 @@ mod test {
             }
         }
 
-        assert_eq!(object_count, 1, "应该有1个对象版本");
-        assert_eq!(delete_count, 1, "应该有1个删除标记");
-        assert_eq!(legacy_count, 1, "应该有1个Legacy版本");
+        assert_eq!(object_count, 1, "应该有 1 个对象版本");
+        assert_eq!(delete_count, 1, "应该有 1 个删除标记");
+        assert_eq!(legacy_count, 1, "应该有 1 个 Legacy 版本");
 
         // 验证兼容性
         assert!(fm.is_compatible_with_meta(), "应该与 xl 格式兼容");
@@ -2777,7 +2784,7 @@ mod test {
         let fm = FileMeta::load(&data).expect("解析复杂数据失败");
 
         // 验证版本数量
-        assert!(fm.versions.len() >= 10, "应该有至少10个版本");
+        assert!(fm.versions.len() >= 10, "应该有至少 10 个版本");
 
         // 验证版本排序
         assert!(fm.is_sorted_by_mod_time(), "版本应该按修改时间排序");
@@ -2798,7 +2805,7 @@ mod test {
         let data = create_xlmeta_with_inline_data().expect("创建内联数据测试失败");
         let fm = FileMeta::load(&data).expect("解析内联数据失败");
 
-        assert_eq!(fm.versions.len(), 1, "应该有1个版本");
+        assert_eq!(fm.versions.len(), 1, "应该有 1 个版本");
         assert!(!fm.data.as_slice().is_empty(), "应该包含内联数据");
 
         // 验证内联数据内容
@@ -2845,7 +2852,7 @@ mod test {
 
         for version in &fm.versions {
             let signature = version.header.get_signature();
-            assert_eq!(signature.len(), 4, "签名应该是4字节");
+            assert_eq!(signature.len(), 4, "签名应该是 4 字节");
 
             // 验证相同版本的签名一致性
             let signature2 = version.header.get_signature();
@@ -2888,7 +2895,7 @@ mod test {
         // 验证版本内容一致性
         for (v1, v2) in fm.versions.iter().zip(fm2.versions.iter()) {
             assert_eq!(v1.header.version_type, v2.header.version_type, "版本类型应该一致");
-            assert_eq!(v1.header.version_id, v2.header.version_id, "版本ID应该一致");
+            assert_eq!(v1.header.version_id, v2.header.version_id, "版本 ID 应该一致");
         }
     }
 
@@ -2909,26 +2916,26 @@ mod test {
         let _serialized = fm.marshal_msg().expect("序列化失败");
         let serialization_time = start.elapsed();
 
-        println!("性能测试结果:");
-        println!("  创建时间: {:?}", creation_time);
-        println!("  解析时间: {:?}", parsing_time);
-        println!("  序列化时间: {:?}", serialization_time);
+        println!("性能测试结果：");
+        println!("  创建时间：{:?}", creation_time);
+        println!("  解析时间：{:?}", parsing_time);
+        println!("  序列化时间：{:?}", serialization_time);
 
         // 基本性能断言（这些值可能需要根据实际性能调整）
-        assert!(parsing_time.as_millis() < 100, "解析时间应该小于100ms");
-        assert!(serialization_time.as_millis() < 100, "序列化时间应该小于100ms");
+        assert!(parsing_time.as_millis() < 100, "解析时间应该小于 100ms");
+        assert!(serialization_time.as_millis() < 100, "序列化时间应该小于 100ms");
     }
 
     #[test]
     fn test_edge_cases() {
         // 测试边界情况
 
-        // 1. 测试空版本ID
+        // 1. 测试空版本 ID
         let mut fm = FileMeta::new();
         let version = FileMetaVersion {
             version_type: VersionType::Object,
             object: Some(MetaObject {
-                version_id: None, // 空版本ID
+                version_id: None, // 空版本 ID
                 data_dir: None,
                 erasure_algorithm: crate::fileinfo::ErasureAlgo::ReedSolomon,
                 erasure_m: 1,
@@ -2961,13 +2968,13 @@ mod test {
 
         // 2. 测试极大的文件大小
         let large_object = MetaObject {
-            size: usize::MAX,
+            size: i64::MAX,
             part_sizes: vec![usize::MAX],
             ..Default::default()
         };
 
         // 应该能够处理大数值
-        assert_eq!(large_object.size, usize::MAX);
+        assert_eq!(large_object.size, i64::MAX);
     }
 
     #[tokio::test]
@@ -3024,9 +3031,9 @@ mod test {
         let large_size = mem::size_of_val(&large_fm);
         println!("Large FileMeta size: {} bytes", large_size);
 
-        // 验证内存使用是合理的（注意：size_of_val只计算栈上的大小，不包括堆分配）
-        // 对于包含Vec的结构体，size_of_val可能相同，因为Vec的容量在堆上
-        println!("版本数量: {}", large_fm.versions.len());
+        // 验证内存使用是合理的（注意：size_of_val 只计算栈上的大小，不包括堆分配）
+        // 对于包含 Vec 的结构体，size_of_val 可能相同，因为 Vec 的容量在堆上
+        println!("版本数量：{}", large_fm.versions.len());
         assert!(!large_fm.versions.is_empty(), "应该有版本数据");
     }
 
@@ -3097,8 +3104,8 @@ mod test {
             };
 
             // 验证参数的合理性
-            assert!(obj.erasure_m > 0, "数据块数量必须大于0");
-            assert!(obj.erasure_n > 0, "校验块数量必须大于0");
+            assert!(obj.erasure_m > 0, "数据块数量必须大于 0");
+            assert!(obj.erasure_n > 0, "校验块数量必须大于 0");
             assert_eq!(obj.erasure_dist.len(), data_blocks + parity_blocks);
 
             // 验证序列化和反序列化
@@ -3259,7 +3266,7 @@ mod test {
         // 测试多个版本列表的合并
         let merged = merge_file_meta_versions(1, false, 0, &[versions1.clone(), versions2.clone()]);
         // 合并结果可能为空，这取决于版本的兼容性，这是正常的
-        println!("合并结果数量: {}", merged.len());
+        println!("合并结果数量：{}", merged.len());
     }
 
     #[test]
@@ -3269,12 +3276,12 @@ mod test {
 
         for flag in flags {
             let flag_value = flag as u8;
-            assert!(flag_value > 0, "标志位值应该大于0");
+            assert!(flag_value > 0, "标志位值应该大于 0");
 
             // 测试标志位组合
             let combined = Flags::FreeVersion as u8 | Flags::UsesDataDir as u8;
             // 对于位运算，组合值可能不总是大于单个值，这是正常的
-            assert!(combined > 0, "组合标志位应该大于0");
+            assert!(combined > 0, "组合标志位应该大于 0");
         }
     }
 
@@ -3410,7 +3417,7 @@ mod test {
             ("tabs", "col1\tcol2\tcol3"),
             ("quotes", "\"quoted\" and 'single'"),
             ("backslashes", "path\\to\\file"),
-            ("mixed", "Mixed: 中文, English, 123, !@#$%"),
+            ("mixed", "Mixed: 中文，English, 123, !@#$%"),
         ];
 
         for (key, value) in special_cases {
@@ -3432,7 +3439,7 @@ mod test {
             ("tabs", "col1\tcol2\tcol3"),
             ("quotes", "\"quoted\" and 'single'"),
             ("backslashes", "path\\to\\file"),
-            ("mixed", "Mixed: 中文, English, 123, !@#$%"),
+            ("mixed", "Mixed: 中文，English, 123, !@#$%"),
         ] {
             assert_eq!(obj2.meta_user.get(key), Some(&expected_value.to_string()));
         }
@@ -3529,7 +3536,7 @@ pub struct DetailedVersionStats {
     pub free_versions: usize,
     pub versions_with_data_dir: usize,
     pub versions_with_inline_data: usize,
-    pub total_size: usize,
+    pub total_size: i64,
     pub latest_mod_time: Option<OffsetDateTime>,
 }
 
diff --git a/crates/filemeta/src/headers.rs b/crates/filemeta/src/headers.rs
index f8a822ef..6f731c27 100644
--- a/crates/filemeta/src/headers.rs
+++ b/crates/filemeta/src/headers.rs
@@ -19,3 +19,5 @@ pub const X_RUSTFS_DATA_MOV: &str = "X-Rustfs-Internal-data-mov";
 pub const AMZ_OBJECT_TAGGING: &str = "X-Amz-Tagging";
 pub const AMZ_BUCKET_REPLICATION_STATUS: &str = "X-Amz-Replication-Status";
 pub const AMZ_DECODED_CONTENT_LENGTH: &str = "X-Amz-Decoded-Content-Length";
+
+pub const RUSTFS_DATA_MOVE: &str = "X-Rustfs-Internal-data-mov";
diff --git a/crates/filemeta/src/test_data.rs b/crates/filemeta/src/test_data.rs
index aaede61c..a725cce6 100644
--- a/crates/filemeta/src/test_data.rs
+++ b/crates/filemeta/src/test_data.rs
@@ -91,7 +91,7 @@ pub fn create_complex_xlmeta() -> Result<Vec<u8>> {
     let mut fm = FileMeta::new();
 
     // 创建10个版本的对象
-    for i in 0..10 {
+    for i in 0i64..10i64 {
         let version_id = Uuid::new_v4();
         let data_dir = if i % 3 == 0 { Some(Uuid::new_v4()) } else { None };
 
@@ -113,9 +113,9 @@ pub fn create_complex_xlmeta() -> Result<Vec<u8>> {
             part_numbers: vec![1],
             part_etags: vec![format!("etag-{:08x}", i)],
             part_sizes: vec![1024 * (i + 1) as usize],
-            part_actual_sizes: vec![1024 * (i + 1) as usize],
+            part_actual_sizes: vec![1024 * (i + 1)],
             part_indices: Vec::new(),
-            size: 1024 * (i + 1) as usize,
+            size: 1024 * (i + 1),
             mod_time: Some(OffsetDateTime::from_unix_timestamp(1705312200 + i * 60)?),
             meta_sys: HashMap::new(),
             meta_user: metadata,
@@ -221,7 +221,7 @@ pub fn create_xlmeta_with_inline_data() -> Result<Vec<u8>> {
         part_sizes: vec![inline_data.len()],
         part_actual_sizes: Vec::new(),
         part_indices: Vec::new(),
-        size: inline_data.len(),
+        size: inline_data.len() as i64,
         mod_time: Some(OffsetDateTime::now_utc()),
         meta_sys: HashMap::new(),
         meta_user: HashMap::new(),
diff --git a/crates/notify/Cargo.toml b/crates/notify/Cargo.toml
new file mode 100644
index 00000000..9737075b
--- /dev/null
+++ b/crates/notify/Cargo.toml
@@ -0,0 +1,41 @@
+[package]
+name = "rustfs-notify"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+rustfs-utils = { workspace = true, features = ["path", "sys"] }
+async-trait = { workspace = true }
+chrono = { workspace = true, features = ["serde"] }
+const-str = { workspace = true }
+dashmap = { workspace = true }
+ecstore = { workspace = true }
+form_urlencoded = { workspace = true }
+once_cell = { workspace = true }
+quick-xml = { workspace = true, features = ["serialize", "async-tokio"] }
+reqwest = { workspace = true }
+rumqttc = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+snap = { workspace = true }
+thiserror = { workspace = true }
+tokio = { workspace = true, features = ["rt-multi-thread", "sync", "time"] }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true, features = ["env-filter"] }
+uuid = { workspace = true, features = ["v4", "serde"] }
+url = { workspace = true }
+urlencoding = { workspace = true }
+wildmatch = { workspace = true, features = ["serde"] }
+
+
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["test-util"] }
+reqwest = { workspace = true, default-features = false, features = ["rustls-tls", "charset", "http2", "system-proxy", "stream", "json", "blocking"] }
+axum = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/crates/notify/examples/full_demo.rs b/crates/notify/examples/full_demo.rs
new file mode 100644
index 00000000..181f850e
--- /dev/null
+++ b/crates/notify/examples/full_demo.rs
@@ -0,0 +1,171 @@
+use ecstore::config::{Config, ENABLE_KEY, ENABLE_ON, KV, KVS};
+use rustfs_notify::arn::TargetID;
+use rustfs_notify::factory::{
+    DEFAULT_TARGET, MQTT_BROKER, MQTT_PASSWORD, MQTT_QOS, MQTT_QUEUE_DIR, MQTT_QUEUE_LIMIT, MQTT_TOPIC, MQTT_USERNAME,
+    NOTIFY_MQTT_SUB_SYS, NOTIFY_WEBHOOK_SUB_SYS, WEBHOOK_AUTH_TOKEN, WEBHOOK_ENDPOINT, WEBHOOK_QUEUE_DIR, WEBHOOK_QUEUE_LIMIT,
+};
+use rustfs_notify::store::DEFAULT_LIMIT;
+use rustfs_notify::{BucketNotificationConfig, Event, EventName, LogLevel, NotificationError, init_logger};
+use rustfs_notify::{initialize, notification_system};
+use std::sync::Arc;
+use std::time::Duration;
+use tracing::info;
+
+#[tokio::main]
+async fn main() -> Result<(), NotificationError> {
+    init_logger(LogLevel::Debug);
+
+    let system = match notification_system() {
+        Some(sys) => sys,
+        None => {
+            let config = Config::new();
+            initialize(config).await?;
+            notification_system().expect("Failed to initialize notification system")
+        }
+    };
+
+    // --- Initial configuration (Webhook and MQTT) ---
+    let mut config = Config::new();
+    let current_root = rustfs_utils::dirs::get_project_root().expect("failed to get project root");
+    println!("Current project root: {}", current_root.display());
+
+    let webhook_kvs_vec = vec![
+        KV {
+            key: ENABLE_KEY.to_string(),
+            value: ENABLE_ON.to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: WEBHOOK_ENDPOINT.to_string(),
+            value: "http://127.0.0.1:3020/webhook".to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: WEBHOOK_AUTH_TOKEN.to_string(),
+            value: "secret-token".to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: WEBHOOK_QUEUE_DIR.to_string(),
+            value: current_root
+                .clone()
+                .join("../../deploy/logs/notify/webhook")
+                .to_str()
+                .unwrap()
+                .to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: WEBHOOK_QUEUE_LIMIT.to_string(),
+            value: DEFAULT_LIMIT.to_string(),
+            hidden_if_empty: false,
+        },
+    ];
+    let webhook_kvs = KVS(webhook_kvs_vec);
+
+    let mut webhook_targets = std::collections::HashMap::new();
+    webhook_targets.insert(DEFAULT_TARGET.to_string(), webhook_kvs);
+    config.0.insert(NOTIFY_WEBHOOK_SUB_SYS.to_string(), webhook_targets);
+
+    // MQTT target configuration
+    let mqtt_kvs_vec = vec![
+        KV {
+            key: ENABLE_KEY.to_string(),
+            value: ENABLE_ON.to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: MQTT_BROKER.to_string(),
+            value: "mqtt://localhost:1883".to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: MQTT_TOPIC.to_string(),
+            value: "rustfs/events".to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: MQTT_QOS.to_string(),
+            value: "1".to_string(), // AtLeastOnce
+            hidden_if_empty: false,
+        },
+        KV {
+            key: MQTT_USERNAME.to_string(),
+            value: "test".to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: MQTT_PASSWORD.to_string(),
+            value: "123456".to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: MQTT_QUEUE_DIR.to_string(),
+            value: current_root
+                .join("../../deploy/logs/notify/mqtt")
+                .to_str()
+                .unwrap()
+                .to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: MQTT_QUEUE_LIMIT.to_string(),
+            value: DEFAULT_LIMIT.to_string(),
+            hidden_if_empty: false,
+        },
+    ];
+
+    let mqtt_kvs = KVS(mqtt_kvs_vec);
+    let mut mqtt_targets = std::collections::HashMap::new();
+    mqtt_targets.insert(DEFAULT_TARGET.to_string(), mqtt_kvs);
+    config.0.insert(NOTIFY_MQTT_SUB_SYS.to_string(), mqtt_targets);
+
+    // Load the configuration and initialize the system
+    *system.config.write().await = config;
+    system.init().await?;
+    info!("✅ System initialized with Webhook and MQTT targets.");
+
+    // --- Query the currently active Target ---
+    let active_targets = system.get_active_targets().await;
+    info!("\n---> Currently active targets: {:?}", active_targets);
+    assert_eq!(active_targets.len(), 2);
+
+    tokio::time::sleep(Duration::from_secs(1)).await;
+
+    // --- Exactly delete a Target (e.g. MQTT) ---
+    info!("\n---> Removing MQTT target...");
+    let mqtt_target_id = TargetID::new(DEFAULT_TARGET.to_string(), "mqtt".to_string());
+    system.remove_target(&mqtt_target_id, NOTIFY_MQTT_SUB_SYS).await?;
+    info!("✅ MQTT target removed.");
+
+    // --- Query the activity's Target again ---
+    let active_targets_after_removal = system.get_active_targets().await;
+    info!("\n---> Active targets after removal: {:?}", active_targets_after_removal);
+    assert_eq!(active_targets_after_removal.len(), 1);
+    assert_eq!(active_targets_after_removal[0].id, DEFAULT_TARGET.to_string());
+
+    // --- Send events for verification ---
+    // Configure a rule to point to the Webhook and deleted MQTT
+    let mut bucket_config = BucketNotificationConfig::new("us-east-1");
+    bucket_config.add_rule(
+        &[EventName::ObjectCreatedPut],
+        "*".to_string(),
+        TargetID::new(DEFAULT_TARGET.to_string(), "webhook".to_string()),
+    );
+    bucket_config.add_rule(
+        &[EventName::ObjectCreatedPut],
+        "*".to_string(),
+        TargetID::new(DEFAULT_TARGET.to_string(), "mqtt".to_string()), // This rule will match, but the Target cannot be found
+    );
+    system.load_bucket_notification_config("my-bucket", &bucket_config).await?;
+
+    info!("\n---> Sending an event...");
+    let event = Arc::new(Event::new_test_event("my-bucket", "document.pdf", EventName::ObjectCreatedPut));
+    system.send_event(event).await;
+    info!("✅ Event sent. Only the Webhook target should receive it. Check logs for warnings about the missing MQTT target.");
+
+    tokio::time::sleep(Duration::from_secs(2)).await;
+
+    info!("\nDemo completed successfully");
+    Ok(())
+}
diff --git a/crates/notify/examples/full_demo_one.rs b/crates/notify/examples/full_demo_one.rs
new file mode 100644
index 00000000..381287bc
--- /dev/null
+++ b/crates/notify/examples/full_demo_one.rs
@@ -0,0 +1,174 @@
+use ecstore::config::{Config, ENABLE_KEY, ENABLE_ON, KV, KVS};
+use std::sync::Arc;
+// Using Global Accessories
+use rustfs_notify::arn::TargetID;
+use rustfs_notify::factory::{
+    DEFAULT_TARGET, MQTT_BROKER, MQTT_PASSWORD, MQTT_QOS, MQTT_QUEUE_DIR, MQTT_QUEUE_LIMIT, MQTT_TOPIC, MQTT_USERNAME,
+    NOTIFY_MQTT_SUB_SYS, NOTIFY_WEBHOOK_SUB_SYS, WEBHOOK_AUTH_TOKEN, WEBHOOK_ENDPOINT, WEBHOOK_QUEUE_DIR, WEBHOOK_QUEUE_LIMIT,
+};
+use rustfs_notify::store::DEFAULT_LIMIT;
+use rustfs_notify::{BucketNotificationConfig, Event, EventName, LogLevel, NotificationError, init_logger};
+use rustfs_notify::{initialize, notification_system};
+use std::time::Duration;
+use tracing::info;
+
+#[tokio::main]
+async fn main() -> Result<(), NotificationError> {
+    init_logger(LogLevel::Debug);
+
+    // Get global NotificationSystem instance
+    let system = match notification_system() {
+        Some(sys) => sys,
+        None => {
+            let config = Config::new();
+            initialize(config).await?;
+            notification_system().expect("Failed to initialize notification system")
+        }
+    };
+
+    // --- Initial configuration ---
+    let mut config = Config::new();
+    let current_root = rustfs_utils::dirs::get_project_root().expect("failed to get project root");
+    // Webhook target
+    let webhook_kvs_vec = vec![
+        KV {
+            key: ENABLE_KEY.to_string(),
+            value: ENABLE_ON.to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: WEBHOOK_ENDPOINT.to_string(),
+            value: "http://127.0.0.1:3020/webhook".to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: WEBHOOK_AUTH_TOKEN.to_string(),
+            value: "secret-token".to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: WEBHOOK_QUEUE_DIR.to_string(),
+            value: current_root
+                .clone()
+                .join("../../deploy/logs/notify/webhook")
+                .to_str()
+                .unwrap()
+                .to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: WEBHOOK_QUEUE_LIMIT.to_string(),
+            value: DEFAULT_LIMIT.to_string(),
+            hidden_if_empty: false,
+        },
+    ];
+    let webhook_kvs = KVS(webhook_kvs_vec);
+
+    let mut webhook_targets = std::collections::HashMap::new();
+    webhook_targets.insert(DEFAULT_TARGET.to_string(), webhook_kvs);
+    config.0.insert(NOTIFY_WEBHOOK_SUB_SYS.to_string(), webhook_targets);
+
+    // Load the initial configuration and initialize the system
+    *system.config.write().await = config;
+    system.init().await?;
+    info!("✅ System initialized with Webhook target.");
+
+    tokio::time::sleep(Duration::from_secs(1)).await;
+
+    // --- Dynamically update system configuration: Add an MQTT Target ---
+    info!("\n---> Dynamically adding MQTT target...");
+
+    let mqtt_kvs_vec = vec![
+        KV {
+            key: ENABLE_KEY.to_string(),
+            value: ENABLE_ON.to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: MQTT_BROKER.to_string(),
+            value: "mqtt://localhost:1883".to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: MQTT_TOPIC.to_string(),
+            value: "rustfs/events".to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: MQTT_QOS.to_string(),
+            value: "1".to_string(), // AtLeastOnce
+            hidden_if_empty: false,
+        },
+        KV {
+            key: MQTT_USERNAME.to_string(),
+            value: "test".to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: MQTT_PASSWORD.to_string(),
+            value: "123456".to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: MQTT_QUEUE_DIR.to_string(),
+            value: current_root
+                .join("../../deploy/logs/notify/mqtt")
+                .to_str()
+                .unwrap()
+                .to_string(),
+            hidden_if_empty: false,
+        },
+        KV {
+            key: MQTT_QUEUE_LIMIT.to_string(),
+            value: DEFAULT_LIMIT.to_string(),
+            hidden_if_empty: false,
+        },
+    ];
+
+    let mqtt_kvs = KVS(mqtt_kvs_vec);
+    // let mut mqtt_targets = std::collections::HashMap::new();
+    // mqtt_targets.insert(DEFAULT_TARGET.to_string(), mqtt_kvs.clone());
+
+    system
+        .set_target_config(NOTIFY_MQTT_SUB_SYS, DEFAULT_TARGET, mqtt_kvs)
+        .await?;
+    info!("✅ MQTT target added and system reloaded.");
+
+    tokio::time::sleep(Duration::from_secs(1)).await;
+
+    // --- Loading and managing Bucket configurations ---
+    info!("\n---> Loading bucket notification config...");
+    let mut bucket_config = BucketNotificationConfig::new("us-east-1");
+    bucket_config.add_rule(
+        &[EventName::ObjectCreatedPut],
+        "*".to_string(),
+        TargetID::new(DEFAULT_TARGET.to_string(), "webhook".to_string()),
+    );
+    bucket_config.add_rule(
+        &[EventName::ObjectCreatedPut],
+        "*".to_string(),
+        TargetID::new(DEFAULT_TARGET.to_string(), "mqtt".to_string()),
+    );
+    system.load_bucket_notification_config("my-bucket", &bucket_config).await?;
+    info!("✅ Bucket 'my-bucket' config loaded.");
+
+    // --- Send events ---
+    info!("\n---> Sending an event...");
+    let event = Arc::new(Event::new_test_event("my-bucket", "document.pdf", EventName::ObjectCreatedPut));
+    system.send_event(event).await;
+    info!("✅ Event sent. Both Webhook and MQTT targets should receive it.");
+
+    tokio::time::sleep(Duration::from_secs(2)).await;
+
+    // --- Dynamically remove configuration ---
+    info!("\n---> Dynamically removing Webhook target...");
+    system.remove_target_config("notify_webhook", "1").await?;
+    info!("✅ Webhook target removed and system reloaded.");
+
+    info!("\n---> Removing bucket notification config...");
+    system.remove_bucket_notification_config("my-bucket").await;
+    info!("✅ Bucket 'my-bucket' config removed.");
+
+    info!("\nDemo completed successfully");
+    Ok(())
+}
diff --git a/crates/notify/examples/webhook.rs b/crates/notify/examples/webhook.rs
new file mode 100644
index 00000000..0357b6cf
--- /dev/null
+++ b/crates/notify/examples/webhook.rs
@@ -0,0 +1,201 @@
+use axum::routing::get;
+use axum::{
+    Router,
+    extract::Json,
+    http::{HeaderMap, Response, StatusCode},
+    routing::post,
+};
+use serde_json::Value;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use axum::extract::Query;
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+struct ResetParams {
+    reason: Option<String>,
+}
+
+// Define a global variable and count the number of data received
+use std::sync::atomic::{AtomicU64, Ordering};
+
+static WEBHOOK_COUNT: AtomicU64 = AtomicU64::new(0);
+
+#[tokio::main]
+async fn main() {
+    // Build an application
+    let app = Router::new()
+        .route("/webhook", post(receive_webhook))
+        .route("/webhook/reset/{reason}", get(reset_webhook_count_with_path))
+        .route("/webhook/reset", get(reset_webhook_count))
+        .route("/webhook", get(receive_webhook));
+    // Start the server
+    let addr = "0.0.0.0:3020";
+    let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
+    println!("Server running on {}", addr);
+
+    // Self-checking after the service is started
+    tokio::spawn(async move {
+        // Give the server some time to start
+        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+
+        match is_service_active(addr).await {
+            Ok(true) => println!("Service health check: Successful - Service is running normally"),
+            Ok(false) => eprintln!("Service Health Check: Failed - Service Not Responded"),
+            Err(e) => eprintln!("Service health check errors:{}", e),
+        }
+    });
+
+    // Create a shutdown signal processing
+    tokio::select! {
+        result = axum::serve(listener, app) => {
+            if let Err(e) = result {
+                eprintln!("Server error: {}", e);
+            }
+        }
+        _ = tokio::signal::ctrl_c() => {
+            println!("Shutting down server...");
+        }
+    }
+}
+
+/// Create a method to reset the value of WEBHOOK_COUNT
+async fn reset_webhook_count_with_path(axum::extract::Path(reason): axum::extract::Path<String>) -> Response<String> {
+    // Output the value of the current counter
+    let current_count = WEBHOOK_COUNT.load(Ordering::SeqCst);
+    println!("Current webhook count: {}", current_count);
+
+    println!("Reset webhook count, reason: {}", reason);
+    // Reset the counter to 0
+    WEBHOOK_COUNT.store(0, Ordering::SeqCst);
+    println!("Webhook count has been reset to 0.");
+
+    Response::builder()
+        .header("Foo", "Bar")
+        .status(StatusCode::OK)
+        .body(format!(
+            "Webhook count reset successfully. Previous count: {}. Reason: {}",
+            current_count, reason
+        ))
+        .unwrap()
+}
+
+/// Create a method to reset the value of WEBHOOK_COUNT
+/// You can reset the counter by calling this method
+async fn reset_webhook_count(Query(params): Query<ResetParams>, headers: HeaderMap) -> Response<String> {
+    // Output the value of the current counter
+    let current_count = WEBHOOK_COUNT.load(Ordering::SeqCst);
+    println!("Current webhook count: {}", current_count);
+
+    let reason = params.reason.unwrap_or_else(|| "Reason not provided".to_string());
+    println!("Reset webhook count, reason: {}", reason);
+
+    for header in headers {
+        let (key, value) = header;
+        println!("Header: {:?}: {:?}", key, value);
+    }
+
+    println!("Reset webhook count printed headers");
+    // Reset the counter to 0
+    WEBHOOK_COUNT.store(0, Ordering::SeqCst);
+    println!("Webhook count has been reset to 0.");
+    Response::builder()
+        .header("Foo", "Bar")
+        .status(StatusCode::OK)
+        .body(format!("Webhook count reset successfully current_count:{}", current_count))
+        .unwrap()
+}
+
+async fn is_service_active(addr: &str) -> Result<bool, String> {
+    let socket_addr = tokio::net::lookup_host(addr)
+        .await
+        .map_err(|e| format!("Unable to resolve host:{}", e))?
+        .next()
+        .ok_or_else(|| "Address not found".to_string())?;
+
+    println!("Checking service status:{}", socket_addr);
+
+    match tokio::time::timeout(std::time::Duration::from_secs(5), tokio::net::TcpStream::connect(socket_addr)).await {
+        Ok(Ok(_)) => Ok(true),
+        Ok(Err(e)) => {
+            if e.kind() == std::io::ErrorKind::ConnectionRefused {
+                Ok(false)
+            } else {
+                Err(format!("Connection failed:{}", e))
+            }
+        }
+        Err(_) => Err("Connection timeout".to_string()),
+    }
+}
+
+async fn receive_webhook(Json(payload): Json<Value>) -> StatusCode {
+    let start = SystemTime::now();
+    let since_the_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards");
+
+    // get the number of seconds since the unix era
+    let seconds = since_the_epoch.as_secs();
+
+    // Manually calculate year, month, day, hour, minute, and second
+    let (year, month, day, hour, minute, second) = convert_seconds_to_date(seconds);
+
+    // output result
+    println!("current time:{:04}-{:02}-{:02} {:02}:{:02}:{:02}", year, month, day, hour, minute, second);
+    println!(
+        "received a webhook request time:{} content:\n {}",
+        seconds,
+        serde_json::to_string_pretty(&payload).unwrap()
+    );
+    WEBHOOK_COUNT.fetch_add(1, Ordering::SeqCst);
+    println!("Total webhook requests received: {}", WEBHOOK_COUNT.load(Ordering::SeqCst));
+    StatusCode::OK
+}
+
+fn convert_seconds_to_date(seconds: u64) -> (u32, u32, u32, u32, u32, u32) {
+    // assume that the time zone is utc
+    let seconds_per_minute = 60;
+    let seconds_per_hour = 3600;
+    let seconds_per_day = 86400;
+
+    // Calculate the year, month, day, hour, minute, and second corresponding to the number of seconds
+    let mut total_seconds = seconds;
+    let mut year = 1970;
+    let mut month = 1;
+    let mut day = 1;
+    let mut hour = 0;
+    let mut minute = 0;
+    let mut second = 0;
+
+    // calculate year
+    while total_seconds >= 31536000 {
+        year += 1;
+        total_seconds -= 31536000; // simplified processing no leap year considered
+    }
+
+    // calculate month
+    let days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    for m in &days_in_month {
+        if total_seconds >= m * seconds_per_day {
+            month += 1;
+            total_seconds -= m * seconds_per_day;
+        } else {
+            break;
+        }
+    }
+
+    // calculate the number of days
+    day += total_seconds / seconds_per_day;
+    total_seconds %= seconds_per_day;
+
+    // calculate hours
+    hour += total_seconds / seconds_per_hour;
+    total_seconds %= seconds_per_hour;
+
+    // calculate minutes
+    minute += total_seconds / seconds_per_minute;
+    total_seconds %= seconds_per_minute;
+
+    // calculate the number of seconds
+    second += total_seconds;
+
+    (year as u32, month as u32, day as u32, hour as u32, minute as u32, second as u32)
+}
diff --git a/crates/notify/src/arn.rs b/crates/notify/src/arn.rs
new file mode 100644
index 00000000..9be689b8
--- /dev/null
+++ b/crates/notify/src/arn.rs
@@ -0,0 +1,236 @@
+use crate::TargetError;
+use const_str::concat;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::fmt;
+use std::str::FromStr;
+use thiserror::Error;
+
+pub(crate) const DEFAULT_ARN_PARTITION: &str = "rustfs";
+
+pub(crate) const DEFAULT_ARN_SERVICE: &str = "sqs";
+
+/// Default ARN prefix for SQS
+/// "arn:rustfs:sqs:"
+const ARN_PREFIX: &str = concat!("arn:", DEFAULT_ARN_PARTITION, ":", DEFAULT_ARN_SERVICE, ":");
+
+#[derive(Debug, Error)]
+pub enum TargetIDError {
+    #[error("Invalid TargetID format '{0}', expect 'ID:Name'")]
+    InvalidFormat(String),
+}
+
+/// Target ID, used to identify notification targets
+#[derive(Debug, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
+pub struct TargetID {
+    pub id: String,
+    pub name: String,
+}
+
+impl TargetID {
+    pub fn new(id: String, name: String) -> Self {
+        Self { id, name }
+    }
+
+    /// Convert to string representation
+    pub fn to_id_string(&self) -> String {
+        format!("{}:{}", self.id, self.name)
+    }
+
+    /// Create an ARN
+    pub fn to_arn(&self, region: &str) -> ARN {
+        ARN {
+            target_id: self.clone(),
+            region: region.to_string(),
+            service: DEFAULT_ARN_SERVICE.to_string(),     // Default Service
+            partition: DEFAULT_ARN_PARTITION.to_string(), // Default partition
+        }
+    }
+}
+
+impl fmt::Display for TargetID {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}:{}", self.id, self.name)
+    }
+}
+
+impl FromStr for TargetID {
+    type Err = TargetIDError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let parts: Vec<&str> = s.splitn(2, ':').collect();
+        if parts.len() == 2 {
+            Ok(TargetID {
+                id: parts[0].to_string(),
+                name: parts[1].to_string(),
+            })
+        } else {
+            Err(TargetIDError::InvalidFormat(s.to_string()))
+        }
+    }
+}
+
+impl Serialize for TargetID {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&self.to_id_string())
+    }
+}
+
+impl<'de> Deserialize<'de> for TargetID {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        TargetID::from_str(&s).map_err(serde::de::Error::custom)
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum ArnError {
+    #[error("Invalid ARN format '{0}'")]
+    InvalidFormat(String),
+    #[error("ARN component missing")]
+    MissingComponents,
+}
+
+/// ARN - AWS resource name representation
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct ARN {
+    pub target_id: TargetID,
+    pub region: String,
+    // Service types, such as "sqs", "sns", "lambda", etc. This defaults to "sqs" to match the Go example.
+    pub service: String,
+    // Partitions such as "aws", "aws-cn", or customizations such as "rustfs","rustfs", etc.
+    pub partition: String,
+}
+
+impl ARN {
+    pub fn new(target_id: TargetID, region: String) -> Self {
+        ARN {
+            target_id,
+            region,
+            service: DEFAULT_ARN_SERVICE.to_string(),     // Default is sqs
+            partition: DEFAULT_ARN_PARTITION.to_string(), // Default is rustfs partition
+        }
+    }
+
+    /// Returns the string representation of ARN
+    /// Returns the ARN string in the format "{ARN_PREFIX}:{region}:{target_id}"
+    #[allow(clippy::inherent_to_string)]
+    pub fn to_arn_string(&self) -> String {
+        if self.target_id.id.is_empty() && self.target_id.name.is_empty() && self.region.is_empty() {
+            return String::new();
+        }
+        format!("{}:{}:{}", ARN_PREFIX, self.region, self.target_id.to_id_string())
+    }
+
+    /// Parsing ARN from string
+    pub fn parse(s: &str) -> Result<Self, TargetError> {
+        if !s.starts_with(ARN_PREFIX) {
+            return Err(TargetError::InvalidARN(s.to_string()));
+        }
+
+        let tokens: Vec<&str> = s.split(':').collect();
+        if tokens.len() != 6 {
+            return Err(TargetError::InvalidARN(s.to_string()));
+        }
+
+        if tokens[4].is_empty() || tokens[5].is_empty() {
+            return Err(TargetError::InvalidARN(s.to_string()));
+        }
+
+        Ok(ARN {
+            region: tokens[3].to_string(),
+            target_id: TargetID {
+                id: tokens[4].to_string(),
+                name: tokens[5].to_string(),
+            },
+            service: tokens[2].to_string(),   // Service Type
+            partition: tokens[1].to_string(), // Partition
+        })
+    }
+}
+
+impl fmt::Display for ARN {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.target_id.id.is_empty() && self.target_id.name.is_empty() && self.region.is_empty() {
+            // Returns an empty string if all parts are empty
+            return Ok(());
+        }
+        write!(
+            f,
+            "arn:{}:{}:{}:{}:{}",
+            self.partition, self.service, self.region, self.target_id.id, self.target_id.name
+        )
+    }
+}
+
+impl FromStr for ARN {
+    type Err = ArnError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let parts: Vec<&str> = s.split(':').collect();
+        if parts.len() < 6 {
+            return Err(ArnError::InvalidFormat(s.to_string()));
+        }
+
+        if parts[0] != "arn" {
+            return Err(ArnError::InvalidFormat(s.to_string()));
+        }
+
+        let partition = parts[1].to_string();
+        let service = parts[2].to_string();
+        let region = parts[3].to_string();
+        let id = parts[4].to_string();
+        let name = parts[5..].join(":"); // The name section may contain colons, although this is not usually the case in SQS ARN
+
+        if id.is_empty() || name.is_empty() {
+            return Err(ArnError::MissingComponents);
+        }
+
+        Ok(ARN {
+            target_id: TargetID { id, name },
+            region,
+            service,
+            partition,
+        })
+    }
+}
+
+// Serialization implementation
+impl Serialize for ARN {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&self.to_arn_string())
+    }
+}
+
+impl<'de> Deserialize<'de> for ARN {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        // deserializer.deserialize_str(ARNVisitor)
+        let s = String::deserialize(deserializer)?;
+        if s.is_empty() {
+            // Handle an empty ARN string, for example, creating an empty or default Arn instance
+            // Or return an error based on business logic
+            // Here we create an empty TargetID and region Arn
+            return Ok(ARN {
+                target_id: TargetID {
+                    id: String::new(),
+                    name: String::new(),
+                },
+                region: String::new(),
+                service: DEFAULT_ARN_SERVICE.to_string(),
+                partition: DEFAULT_ARN_PARTITION.to_string(),
+            });
+        }
+        ARN::from_str(&s).map_err(serde::de::Error::custom)
+    }
+}
diff --git a/crates/notify/src/error.rs b/crates/notify/src/error.rs
new file mode 100644
index 00000000..6522aeb5
--- /dev/null
+++ b/crates/notify/src/error.rs
@@ -0,0 +1,120 @@
+use crate::arn::TargetID;
+use std::io;
+use thiserror::Error;
+
+/// Error types for the store
+#[derive(Debug, Error)]
+pub enum StoreError {
+    #[error("I/O error: {0}")]
+    Io(#[from] io::Error),
+
+    #[error("Serialization error: {0}")]
+    Serialization(String),
+
+    #[error("Deserialization error: {0}")]
+    Deserialization(String),
+
+    #[error("Compression error: {0}")]
+    Compression(String),
+
+    #[error("Entry limit exceeded")]
+    LimitExceeded,
+
+    #[error("Entry not found")]
+    NotFound,
+
+    #[error("Invalid entry: {0}")]
+    Internal(String), // Added internal error type
+}
+
+/// Error types for targets
+#[derive(Debug, Error)]
+pub enum TargetError {
+    #[error("Storage error: {0}")]
+    Storage(String),
+
+    #[error("Network error: {0}")]
+    Network(String),
+
+    #[error("Request error: {0}")]
+    Request(String),
+
+    #[error("Timeout error: {0}")]
+    Timeout(String),
+
+    #[error("Authentication error: {0}")]
+    Authentication(String),
+
+    #[error("Configuration error: {0}")]
+    Configuration(String),
+
+    #[error("Encoding error: {0}")]
+    Encoding(String),
+
+    #[error("Serialization error: {0}")]
+    Serialization(String),
+
+    #[error("Target not connected")]
+    NotConnected,
+
+    #[error("Target initialization failed: {0}")]
+    Initialization(String),
+
+    #[error("Invalid ARN: {0}")]
+    InvalidARN(String),
+
+    #[error("Unknown error: {0}")]
+    Unknown(String),
+
+    #[error("Target is disabled")]
+    Disabled,
+}
+
+/// Error types for the notification system
+#[derive(Debug, Error)]
+pub enum NotificationError {
+    #[error("Target error: {0}")]
+    Target(#[from] TargetError),
+
+    #[error("Configuration error: {0}")]
+    Configuration(String),
+
+    #[error("ARN not found: {0}")]
+    ARNNotFound(String),
+
+    #[error("Invalid ARN: {0}")]
+    InvalidARN(String),
+
+    #[error("Bucket notification error: {0}")]
+    BucketNotification(String),
+
+    #[error("Rule configuration error: {0}")]
+    RuleConfiguration(String),
+
+    #[error("System initialization error: {0}")]
+    Initialization(String),
+
+    #[error("Notification system has already been initialized")]
+    AlreadyInitialized,
+
+    #[error("I/O error: {0}")]
+    Io(std::io::Error),
+
+    #[error("Failed to read configuration: {0}")]
+    ReadConfig(String),
+
+    #[error("Failed to save configuration: {0}")]
+    SaveConfig(String),
+
+    #[error("Target '{0}' not found")]
+    TargetNotFound(TargetID),
+
+    #[error("Server not initialized")]
+    ServerNotInitialized,
+}
+
+impl From<url::ParseError> for TargetError {
+    fn from(err: url::ParseError) -> Self {
+        TargetError::Configuration(format!("URL parse error: {}", err))
+    }
+}
diff --git a/crates/notify/src/event.rs b/crates/notify/src/event.rs
new file mode 100644
index 00000000..f4c06441
--- /dev/null
+++ b/crates/notify/src/event.rs
@@ -0,0 +1,543 @@
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::fmt;
+use url::form_urlencoded;
+
+/// Error returned when parsing event name string fails。
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ParseEventNameError(String);
+
+impl fmt::Display for ParseEventNameError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Invalid event name:{}", self.0)
+    }
+}
+
+impl std::error::Error for ParseEventNameError {}
+
+/// Represents the type of event that occurs on the object.
+/// Based on AWS S3 event type and includes RustFS extension.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub enum EventName {
+    // Single event type (values are 1-32 for compatible mask logic)
+    ObjectAccessedGet = 1,
+    ObjectAccessedGetRetention = 2,
+    ObjectAccessedGetLegalHold = 3,
+    ObjectAccessedHead = 4,
+    ObjectAccessedAttributes = 5,
+    ObjectCreatedCompleteMultipartUpload = 6,
+    ObjectCreatedCopy = 7,
+    ObjectCreatedPost = 8,
+    ObjectCreatedPut = 9,
+    ObjectCreatedPutRetention = 10,
+    ObjectCreatedPutLegalHold = 11,
+    ObjectCreatedPutTagging = 12,
+    ObjectCreatedDeleteTagging = 13,
+    ObjectRemovedDelete = 14,
+    ObjectRemovedDeleteMarkerCreated = 15,
+    ObjectRemovedDeleteAllVersions = 16,
+    ObjectRemovedNoOP = 17,
+    BucketCreated = 18,
+    BucketRemoved = 19,
+    ObjectReplicationFailed = 20,
+    ObjectReplicationComplete = 21,
+    ObjectReplicationMissedThreshold = 22,
+    ObjectReplicationReplicatedAfterThreshold = 23,
+    ObjectReplicationNotTracked = 24,
+    ObjectRestorePost = 25,
+    ObjectRestoreCompleted = 26,
+    ObjectTransitionFailed = 27,
+    ObjectTransitionComplete = 28,
+    ScannerManyVersions = 29,                // ObjectManyVersions corresponding to Go
+    ScannerLargeVersions = 30,               // ObjectLargeVersions corresponding to Go
+    ScannerBigPrefix = 31,                   // PrefixManyFolders corresponding to Go
+    LifecycleDelMarkerExpirationDelete = 32, // ILMDelMarkerExpirationDelete corresponding to Go
+
+    // Compound "All" event type (no sequential value for mask)
+    ObjectAccessedAll,
+    ObjectCreatedAll,
+    ObjectRemovedAll,
+    ObjectReplicationAll,
+    ObjectRestoreAll,
+    ObjectTransitionAll,
+    ObjectScannerAll, // New, from Go
+    Everything,       // New, from Go
+}
+
+// Single event type sequential array for Everything.expand()
+const SINGLE_EVENT_NAMES_IN_ORDER: [EventName; 32] = [
+    EventName::ObjectAccessedGet,
+    EventName::ObjectAccessedGetRetention,
+    EventName::ObjectAccessedGetLegalHold,
+    EventName::ObjectAccessedHead,
+    EventName::ObjectAccessedAttributes,
+    EventName::ObjectCreatedCompleteMultipartUpload,
+    EventName::ObjectCreatedCopy,
+    EventName::ObjectCreatedPost,
+    EventName::ObjectCreatedPut,
+    EventName::ObjectCreatedPutRetention,
+    EventName::ObjectCreatedPutLegalHold,
+    EventName::ObjectCreatedPutTagging,
+    EventName::ObjectCreatedDeleteTagging,
+    EventName::ObjectRemovedDelete,
+    EventName::ObjectRemovedDeleteMarkerCreated,
+    EventName::ObjectRemovedDeleteAllVersions,
+    EventName::ObjectRemovedNoOP,
+    EventName::BucketCreated,
+    EventName::BucketRemoved,
+    EventName::ObjectReplicationFailed,
+    EventName::ObjectReplicationComplete,
+    EventName::ObjectReplicationMissedThreshold,
+    EventName::ObjectReplicationReplicatedAfterThreshold,
+    EventName::ObjectReplicationNotTracked,
+    EventName::ObjectRestorePost,
+    EventName::ObjectRestoreCompleted,
+    EventName::ObjectTransitionFailed,
+    EventName::ObjectTransitionComplete,
+    EventName::ScannerManyVersions,
+    EventName::ScannerLargeVersions,
+    EventName::ScannerBigPrefix,
+    EventName::LifecycleDelMarkerExpirationDelete,
+];
+
+const LAST_SINGLE_TYPE_VALUE: u32 = EventName::LifecycleDelMarkerExpirationDelete as u32;
+
+impl EventName {
+    /// The parsed string is EventName.
+    pub fn parse(s: &str) -> Result<Self, ParseEventNameError> {
+        match s {
+            "s3:BucketCreated:*" => Ok(EventName::BucketCreated),
+            "s3:BucketRemoved:*" => Ok(EventName::BucketRemoved),
+            "s3:ObjectAccessed:*" => Ok(EventName::ObjectAccessedAll),
+            "s3:ObjectAccessed:Get" => Ok(EventName::ObjectAccessedGet),
+            "s3:ObjectAccessed:GetRetention" => Ok(EventName::ObjectAccessedGetRetention),
+            "s3:ObjectAccessed:GetLegalHold" => Ok(EventName::ObjectAccessedGetLegalHold),
+            "s3:ObjectAccessed:Head" => Ok(EventName::ObjectAccessedHead),
+            "s3:ObjectAccessed:Attributes" => Ok(EventName::ObjectAccessedAttributes),
+            "s3:ObjectCreated:*" => Ok(EventName::ObjectCreatedAll),
+            "s3:ObjectCreated:CompleteMultipartUpload" => Ok(EventName::ObjectCreatedCompleteMultipartUpload),
+            "s3:ObjectCreated:Copy" => Ok(EventName::ObjectCreatedCopy),
+            "s3:ObjectCreated:Post" => Ok(EventName::ObjectCreatedPost),
+            "s3:ObjectCreated:Put" => Ok(EventName::ObjectCreatedPut),
+            "s3:ObjectCreated:PutRetention" => Ok(EventName::ObjectCreatedPutRetention),
+            "s3:ObjectCreated:PutLegalHold" => Ok(EventName::ObjectCreatedPutLegalHold),
+            "s3:ObjectCreated:PutTagging" => Ok(EventName::ObjectCreatedPutTagging),
+            "s3:ObjectCreated:DeleteTagging" => Ok(EventName::ObjectCreatedDeleteTagging),
+            "s3:ObjectRemoved:*" => Ok(EventName::ObjectRemovedAll),
+            "s3:ObjectRemoved:Delete" => Ok(EventName::ObjectRemovedDelete),
+            "s3:ObjectRemoved:DeleteMarkerCreated" => Ok(EventName::ObjectRemovedDeleteMarkerCreated),
+            "s3:ObjectRemoved:NoOP" => Ok(EventName::ObjectRemovedNoOP),
+            "s3:ObjectRemoved:DeleteAllVersions" => Ok(EventName::ObjectRemovedDeleteAllVersions),
+            "s3:LifecycleDelMarkerExpiration:Delete" => Ok(EventName::LifecycleDelMarkerExpirationDelete),
+            "s3:Replication:*" => Ok(EventName::ObjectReplicationAll),
+            "s3:Replication:OperationFailedReplication" => Ok(EventName::ObjectReplicationFailed),
+            "s3:Replication:OperationCompletedReplication" => Ok(EventName::ObjectReplicationComplete),
+            "s3:Replication:OperationMissedThreshold" => Ok(EventName::ObjectReplicationMissedThreshold),
+            "s3:Replication:OperationReplicatedAfterThreshold" => Ok(EventName::ObjectReplicationReplicatedAfterThreshold),
+            "s3:Replication:OperationNotTracked" => Ok(EventName::ObjectReplicationNotTracked),
+            "s3:ObjectRestore:*" => Ok(EventName::ObjectRestoreAll),
+            "s3:ObjectRestore:Post" => Ok(EventName::ObjectRestorePost),
+            "s3:ObjectRestore:Completed" => Ok(EventName::ObjectRestoreCompleted),
+            "s3:ObjectTransition:Failed" => Ok(EventName::ObjectTransitionFailed),
+            "s3:ObjectTransition:Complete" => Ok(EventName::ObjectTransitionComplete),
+            "s3:ObjectTransition:*" => Ok(EventName::ObjectTransitionAll),
+            "s3:Scanner:ManyVersions" => Ok(EventName::ScannerManyVersions),
+            "s3:Scanner:LargeVersions" => Ok(EventName::ScannerLargeVersions),
+            "s3:Scanner:BigPrefix" => Ok(EventName::ScannerBigPrefix),
+            // ObjectScannerAll and Everything cannot be parsed from strings, because the Go version also does not define their string representation.
+            _ => Err(ParseEventNameError(s.to_string())),
+        }
+    }
+
+    /// Returns a string representation of the event type.
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            EventName::BucketCreated => "s3:BucketCreated:*",
+            EventName::BucketRemoved => "s3:BucketRemoved:*",
+            EventName::ObjectAccessedAll => "s3:ObjectAccessed:*",
+            EventName::ObjectAccessedGet => "s3:ObjectAccessed:Get",
+            EventName::ObjectAccessedGetRetention => "s3:ObjectAccessed:GetRetention",
+            EventName::ObjectAccessedGetLegalHold => "s3:ObjectAccessed:GetLegalHold",
+            EventName::ObjectAccessedHead => "s3:ObjectAccessed:Head",
+            EventName::ObjectAccessedAttributes => "s3:ObjectAccessed:Attributes",
+            EventName::ObjectCreatedAll => "s3:ObjectCreated:*",
+            EventName::ObjectCreatedCompleteMultipartUpload => "s3:ObjectCreated:CompleteMultipartUpload",
+            EventName::ObjectCreatedCopy => "s3:ObjectCreated:Copy",
+            EventName::ObjectCreatedPost => "s3:ObjectCreated:Post",
+            EventName::ObjectCreatedPut => "s3:ObjectCreated:Put",
+            EventName::ObjectCreatedPutTagging => "s3:ObjectCreated:PutTagging",
+            EventName::ObjectCreatedDeleteTagging => "s3:ObjectCreated:DeleteTagging",
+            EventName::ObjectCreatedPutRetention => "s3:ObjectCreated:PutRetention",
+            EventName::ObjectCreatedPutLegalHold => "s3:ObjectCreated:PutLegalHold",
+            EventName::ObjectRemovedAll => "s3:ObjectRemoved:*",
+            EventName::ObjectRemovedDelete => "s3:ObjectRemoved:Delete",
+            EventName::ObjectRemovedDeleteMarkerCreated => "s3:ObjectRemoved:DeleteMarkerCreated",
+            EventName::ObjectRemovedNoOP => "s3:ObjectRemoved:NoOP",
+            EventName::ObjectRemovedDeleteAllVersions => "s3:ObjectRemoved:DeleteAllVersions",
+            EventName::LifecycleDelMarkerExpirationDelete => "s3:LifecycleDelMarkerExpiration:Delete",
+            EventName::ObjectReplicationAll => "s3:Replication:*",
+            EventName::ObjectReplicationFailed => "s3:Replication:OperationFailedReplication",
+            EventName::ObjectReplicationComplete => "s3:Replication:OperationCompletedReplication",
+            EventName::ObjectReplicationNotTracked => "s3:Replication:OperationNotTracked",
+            EventName::ObjectReplicationMissedThreshold => "s3:Replication:OperationMissedThreshold",
+            EventName::ObjectReplicationReplicatedAfterThreshold => "s3:Replication:OperationReplicatedAfterThreshold",
+            EventName::ObjectRestoreAll => "s3:ObjectRestore:*",
+            EventName::ObjectRestorePost => "s3:ObjectRestore:Post",
+            EventName::ObjectRestoreCompleted => "s3:ObjectRestore:Completed",
+            EventName::ObjectTransitionAll => "s3:ObjectTransition:*",
+            EventName::ObjectTransitionFailed => "s3:ObjectTransition:Failed",
+            EventName::ObjectTransitionComplete => "s3:ObjectTransition:Complete",
+            EventName::ScannerManyVersions => "s3:Scanner:ManyVersions",
+            EventName::ScannerLargeVersions => "s3:Scanner:LargeVersions",
+            EventName::ScannerBigPrefix => "s3:Scanner:BigPrefix",
+            // Go's String() returns "" for ObjectScannerAll and Everything
+            EventName::ObjectScannerAll => "s3:Scanner:*", // Follow the pattern in Go Expand
+            EventName::Everything => "",                   // Go String() returns "" to unprocessed
+        }
+    }
+
+    /// Returns the extended value of the abbreviation event type.
+    pub fn expand(&self) -> Vec<Self> {
+        match self {
+            EventName::ObjectAccessedAll => vec![
+                EventName::ObjectAccessedGet,
+                EventName::ObjectAccessedHead,
+                EventName::ObjectAccessedGetRetention,
+                EventName::ObjectAccessedGetLegalHold,
+                EventName::ObjectAccessedAttributes,
+            ],
+            EventName::ObjectCreatedAll => vec![
+                EventName::ObjectCreatedCompleteMultipartUpload,
+                EventName::ObjectCreatedCopy,
+                EventName::ObjectCreatedPost,
+                EventName::ObjectCreatedPut,
+                EventName::ObjectCreatedPutRetention,
+                EventName::ObjectCreatedPutLegalHold,
+                EventName::ObjectCreatedPutTagging,
+                EventName::ObjectCreatedDeleteTagging,
+            ],
+            EventName::ObjectRemovedAll => vec![
+                EventName::ObjectRemovedDelete,
+                EventName::ObjectRemovedDeleteMarkerCreated,
+                EventName::ObjectRemovedNoOP,
+                EventName::ObjectRemovedDeleteAllVersions,
+            ],
+            EventName::ObjectReplicationAll => vec![
+                EventName::ObjectReplicationFailed,
+                EventName::ObjectReplicationComplete,
+                EventName::ObjectReplicationNotTracked,
+                EventName::ObjectReplicationMissedThreshold,
+                EventName::ObjectReplicationReplicatedAfterThreshold,
+            ],
+            EventName::ObjectRestoreAll => vec![EventName::ObjectRestorePost, EventName::ObjectRestoreCompleted],
+            EventName::ObjectTransitionAll => vec![EventName::ObjectTransitionFailed, EventName::ObjectTransitionComplete],
+            EventName::ObjectScannerAll => vec![
+                // New
+                EventName::ScannerManyVersions,
+                EventName::ScannerLargeVersions,
+                EventName::ScannerBigPrefix,
+            ],
+            EventName::Everything => {
+                // New
+                SINGLE_EVENT_NAMES_IN_ORDER.to_vec()
+            }
+            // A single type returns to itself directly
+            _ => vec![*self],
+        }
+    }
+
+    /// Returns the mask of type.
+    /// The compound "All" type will be expanded.
+    pub fn mask(&self) -> u64 {
+        let value = *self as u32;
+        if value > 0 && value <= LAST_SINGLE_TYPE_VALUE {
+            // It's a single type
+            1u64 << (value - 1)
+        } else {
+            // It's a compound type
+            let mut mask = 0u64;
+            for n in self.expand() {
+                mask |= n.mask(); // Recursively call mask
+            }
+            mask
+        }
+    }
+}
+
+impl fmt::Display for EventName {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+/// Convert to `EventName` according to string
+impl From<&str> for EventName {
+    fn from(event_str: &str) -> Self {
+        EventName::parse(event_str).unwrap_or_else(|e| panic!("{}", e))
+    }
+}
+
+/// Represents the identity of the user who triggered the event
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Identity {
+    /// The principal ID of the user
+    pub principal_id: String,
+}
+
+/// Represents the bucket that the object is in
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Bucket {
+    /// The name of the bucket
+    pub name: String,
+    /// The owner identity of the bucket
+    pub owner_identity: Identity,
+    /// The Amazon Resource Name (ARN) of the bucket
+    pub arn: String,
+}
+
+/// Represents the object that the event occurred on
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct Object {
+    /// The key (name) of the object
+    pub key: String,
+    /// The size of the object in bytes
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub size: Option<i64>,
+    /// The entity tag (ETag) of the object
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    /// The content type of the object
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub content_type: Option<String>,
+    /// User-defined metadata associated with the object
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub user_metadata: Option<HashMap<String, String>>,
+    /// The version ID of the object (if versioning is enabled)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub version_id: Option<String>,
+    /// A unique identifier for the event
+    pub sequencer: String,
+}
+
+/// Metadata about the event
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Metadata {
+    /// The schema version of the event
+    #[serde(rename = "s3SchemaVersion")]
+    pub schema_version: String,
+    /// The ID of the configuration that triggered the event
+    pub configuration_id: String,
+    /// Information about the bucket
+    pub bucket: Bucket,
+    /// Information about the object
+    pub object: Object,
+}
+
+/// Information about the source of the event
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Source {
+    /// The host where the event originated
+    pub host: String,
+    /// The port on the host
+    pub port: String,
+    /// The user agent that caused the event
+    #[serde(rename = "userAgent")]
+    pub user_agent: String,
+}
+
+/// Represents a storage event
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Event {
+    /// The version of the event
+    pub event_version: String,
+    /// The source of the event
+    pub event_source: String,
+    /// The AWS region where the event occurred
+    pub aws_region: String,
+    /// The time when the event occurred
+    pub event_time: DateTime<Utc>,
+    /// The name of the event
+    pub event_name: EventName,
+    /// The identity of the user who triggered the event
+    pub user_identity: Identity,
+    /// Parameters from the request that caused the event
+    pub request_parameters: HashMap<String, String>,
+    /// Elements from the response
+    pub response_elements: HashMap<String, String>,
+    /// Metadata about the event
+    pub s3: Metadata,
+    /// Information about the source of the event
+    pub source: Source,
+}
+
+impl Event {
+    /// Creates a test event for a given bucket and object
+    pub fn new_test_event(bucket: &str, key: &str, event_name: EventName) -> Self {
+        let mut user_metadata = HashMap::new();
+        user_metadata.insert("x-amz-meta-test".to_string(), "value".to_string());
+        user_metadata.insert("x-amz-storage-storage-options".to_string(), "value".to_string());
+        user_metadata.insert("x-amz-meta-".to_string(), "value".to_string());
+        user_metadata.insert("x-rustfs-meta-".to_string(), "rustfs-value".to_string());
+        user_metadata.insert("x-request-id".to_string(), "request-id-123".to_string());
+        user_metadata.insert("x-bucket".to_string(), "bucket".to_string());
+        user_metadata.insert("x-object".to_string(), "object".to_string());
+        user_metadata.insert("x-rustfs-origin-endpoint".to_string(), "http://127.0.0.1".to_string());
+        user_metadata.insert("x-rustfs-user-metadata".to_string(), "metadata".to_string());
+        user_metadata.insert("x-rustfs-deployment-id".to_string(), "deployment-id-123".to_string());
+        user_metadata.insert("x-rustfs-origin-endpoint-code".to_string(), "http://127.0.0.1".to_string());
+        user_metadata.insert("x-rustfs-bucket-name".to_string(), "bucket".to_string());
+        user_metadata.insert("x-rustfs-object-key".to_string(), key.to_string());
+        user_metadata.insert("x-rustfs-object-size".to_string(), "1024".to_string());
+        user_metadata.insert("x-rustfs-object-etag".to_string(), "etag123".to_string());
+        user_metadata.insert("x-rustfs-object-version-id".to_string(), "1".to_string());
+        user_metadata.insert("x-request-time".to_string(), Utc::now().to_rfc3339());
+
+        Event {
+            event_version: "2.1".to_string(),
+            event_source: "rustfs:s3".to_string(),
+            aws_region: "us-east-1".to_string(),
+            event_time: Utc::now(),
+            event_name,
+            user_identity: Identity {
+                principal_id: "rustfs".to_string(),
+            },
+            request_parameters: HashMap::new(),
+            response_elements: HashMap::new(),
+            s3: Metadata {
+                schema_version: "1.0".to_string(),
+                configuration_id: "test-config".to_string(),
+                bucket: Bucket {
+                    name: bucket.to_string(),
+                    owner_identity: Identity {
+                        principal_id: "rustfs".to_string(),
+                    },
+                    arn: format!("arn:rustfs:s3:::{}", bucket),
+                },
+                object: Object {
+                    key: key.to_string(),
+                    size: Some(1024),
+                    etag: Some("etag123".to_string()),
+                    content_type: Some("application/octet-stream".to_string()),
+                    user_metadata: Some(user_metadata),
+                    version_id: Some("1".to_string()),
+                    sequencer: "0055AED6DCD90281E5".to_string(),
+                },
+            },
+            source: Source {
+                host: "127.0.0.1".to_string(),
+                port: "9000".to_string(),
+                user_agent: "RustFS (linux; amd64) rustfs-rs/0.1".to_string(),
+            },
+        }
+    }
+    /// Return event mask
+    pub fn mask(&self) -> u64 {
+        self.event_name.mask()
+    }
+
+    pub fn new(args: EventArgs) -> Self {
+        let event_time = Utc::now().naive_local();
+        let unique_id = match args.object.mod_time {
+            Some(t) => format!("{:X}", t.unix_timestamp_nanos()),
+            None => format!("{:X}", event_time.and_utc().timestamp_nanos_opt().unwrap_or(0)),
+        };
+
+        let mut resp_elements = args.resp_elements.clone();
+        initialize_response_elements(&mut resp_elements, &["x-amz-request-id", "x-amz-id-2"]);
+
+        // URL encoding of object keys
+        let key_name = form_urlencoded::byte_serialize(args.object.name.as_bytes()).collect::<String>();
+        let principal_id = args.req_params.get("principalId").unwrap_or(&String::new()).to_string();
+
+        let mut s3_metadata = Metadata {
+            schema_version: "1.0".to_string(),
+            configuration_id: "Config".to_string(), // or from args
+            bucket: Bucket {
+                name: args.bucket_name.clone(),
+                owner_identity: Identity {
+                    principal_id: principal_id.clone(),
+                },
+                arn: format!("arn:aws:s3:::{}", args.bucket_name),
+            },
+            object: Object {
+                key: key_name,
+                version_id: Some(args.object.version_id.unwrap().to_string()),
+                sequencer: unique_id,
+                ..Default::default()
+            },
+        };
+
+        let is_removed_event = matches!(
+            args.event_name,
+            EventName::ObjectRemovedDelete | EventName::ObjectRemovedDeleteMarkerCreated
+        );
+
+        if !is_removed_event {
+            s3_metadata.object.size = Some(args.object.size);
+            s3_metadata.object.etag = args.object.etag.clone();
+            s3_metadata.object.content_type = args.object.content_type.clone();
+            // Filter out internal reserved metadata
+            let mut user_metadata = HashMap::new();
+            for (k, v) in &args.object.user_defined.unwrap_or_default() {
+                if !k.to_lowercase().starts_with("x-amz-meta-internal-") {
+                    user_metadata.insert(k.clone(), v.clone());
+                }
+            }
+            s3_metadata.object.user_metadata = Some(user_metadata);
+        }
+
+        Self {
+            event_version: "2.1".to_string(),
+            event_source: "rustfs:s3".to_string(),
+            aws_region: args.req_params.get("region").cloned().unwrap_or_default(),
+            event_time: event_time.and_utc(),
+            event_name: args.event_name,
+            user_identity: Identity { principal_id },
+            request_parameters: args.req_params,
+            response_elements: resp_elements,
+            s3: s3_metadata,
+            source: Source {
+                host: args.host,
+                port: "".to_string(),
+                user_agent: args.user_agent,
+            },
+        }
+    }
+}
+
+fn initialize_response_elements(elements: &mut HashMap<String, String>, keys: &[&str]) {
+    for key in keys {
+        elements.entry(key.to_string()).or_default();
+    }
+}
+
+/// Represents a log of events for sending to targets
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EventLog {
+    /// The event name
+    pub event_name: EventName,
+    /// The object key
+    pub key: String,
+    /// The list of events
+    pub records: Vec<Event>,
+}
+
+#[derive(Debug, Clone)]
+pub struct EventArgs {
+    pub event_name: EventName,
+    pub bucket_name: String,
+    pub object: ecstore::store_api::ObjectInfo,
+    pub req_params: HashMap<String, String>,
+    pub resp_elements: HashMap<String, String>,
+    pub host: String,
+    pub user_agent: String,
+}
+
+impl EventArgs {
+    // Helper function to check if it is a copy request
+    pub fn is_replication_request(&self) -> bool {
+        self.req_params.contains_key("x-rustfs-source-replication-request")
+    }
+}
diff --git a/crates/notify/src/factory.rs b/crates/notify/src/factory.rs
new file mode 100644
index 00000000..b21ed419
--- /dev/null
+++ b/crates/notify/src/factory.rs
@@ -0,0 +1,303 @@
+use crate::store::DEFAULT_LIMIT;
+use crate::{
+    error::TargetError,
+    target::{Target, mqtt::MQTTArgs, webhook::WebhookArgs},
+};
+use async_trait::async_trait;
+use ecstore::config::{ENABLE_KEY, ENABLE_ON, KVS};
+use rumqttc::QoS;
+use std::time::Duration;
+use tracing::warn;
+use url::Url;
+
+// --- Configuration Constants ---
+
+// General
+
+pub const DEFAULT_TARGET: &str = "1";
+
+#[allow(dead_code)]
+pub const NOTIFY_KAFKA_SUB_SYS: &str = "notify_kafka";
+#[allow(dead_code)]
+pub const NOTIFY_MQTT_SUB_SYS: &str = "notify_mqtt";
+#[allow(dead_code)]
+pub const NOTIFY_MY_SQL_SUB_SYS: &str = "notify_mysql";
+#[allow(dead_code)]
+pub const NOTIFY_NATS_SUB_SYS: &str = "notify_nats";
+#[allow(dead_code)]
+pub const NOTIFY_NSQ_SUB_SYS: &str = "notify_nsq";
+#[allow(dead_code)]
+pub const NOTIFY_ES_SUB_SYS: &str = "notify_elasticsearch";
+#[allow(dead_code)]
+pub const NOTIFY_AMQP_SUB_SYS: &str = "notify_amqp";
+#[allow(dead_code)]
+pub const NOTIFY_POSTGRES_SUB_SYS: &str = "notify_postgres";
+#[allow(dead_code)]
+pub const NOTIFY_REDIS_SUB_SYS: &str = "notify_redis";
+pub const NOTIFY_WEBHOOK_SUB_SYS: &str = "notify_webhook";
+
+#[allow(dead_code)]
+pub const NOTIFY_SUB_SYSTEMS: &[&str] = &[NOTIFY_MQTT_SUB_SYS, NOTIFY_WEBHOOK_SUB_SYS];
+
+// Webhook Keys
+pub const WEBHOOK_ENDPOINT: &str = "endpoint";
+pub const WEBHOOK_AUTH_TOKEN: &str = "auth_token";
+pub const WEBHOOK_QUEUE_LIMIT: &str = "queue_limit";
+pub const WEBHOOK_QUEUE_DIR: &str = "queue_dir";
+pub const WEBHOOK_CLIENT_CERT: &str = "client_cert";
+pub const WEBHOOK_CLIENT_KEY: &str = "client_key";
+
+// Webhook Environment Variables
+const ENV_WEBHOOK_ENABLE: &str = "RUSTFS_NOTIFY_WEBHOOK_ENABLE";
+const ENV_WEBHOOK_ENDPOINT: &str = "RUSTFS_NOTIFY_WEBHOOK_ENDPOINT";
+const ENV_WEBHOOK_AUTH_TOKEN: &str = "RUSTFS_NOTIFY_WEBHOOK_AUTH_TOKEN";
+const ENV_WEBHOOK_QUEUE_LIMIT: &str = "RUSTFS_NOTIFY_WEBHOOK_QUEUE_LIMIT";
+const ENV_WEBHOOK_QUEUE_DIR: &str = "RUSTFS_NOTIFY_WEBHOOK_QUEUE_DIR";
+const ENV_WEBHOOK_CLIENT_CERT: &str = "RUSTFS_NOTIFY_WEBHOOK_CLIENT_CERT";
+const ENV_WEBHOOK_CLIENT_KEY: &str = "RUSTFS_NOTIFY_WEBHOOK_CLIENT_KEY";
+
+// MQTT Keys
+pub const MQTT_BROKER: &str = "broker";
+pub const MQTT_TOPIC: &str = "topic";
+pub const MQTT_QOS: &str = "qos";
+pub const MQTT_USERNAME: &str = "username";
+pub const MQTT_PASSWORD: &str = "password";
+pub const MQTT_RECONNECT_INTERVAL: &str = "reconnect_interval";
+pub const MQTT_KEEP_ALIVE_INTERVAL: &str = "keep_alive_interval";
+pub const MQTT_QUEUE_DIR: &str = "queue_dir";
+pub const MQTT_QUEUE_LIMIT: &str = "queue_limit";
+
+// MQTT Environment Variables
+const ENV_MQTT_ENABLE: &str = "RUSTFS_NOTIFY_MQTT_ENABLE";
+const ENV_MQTT_BROKER: &str = "RUSTFS_NOTIFY_MQTT_BROKER";
+const ENV_MQTT_TOPIC: &str = "RUSTFS_NOTIFY_MQTT_TOPIC";
+const ENV_MQTT_QOS: &str = "RUSTFS_NOTIFY_MQTT_QOS";
+const ENV_MQTT_USERNAME: &str = "RUSTFS_NOTIFY_MQTT_USERNAME";
+const ENV_MQTT_PASSWORD: &str = "RUSTFS_NOTIFY_MQTT_PASSWORD";
+const ENV_MQTT_RECONNECT_INTERVAL: &str = "RUSTFS_NOTIFY_MQTT_RECONNECT_INTERVAL";
+const ENV_MQTT_KEEP_ALIVE_INTERVAL: &str = "RUSTFS_NOTIFY_MQTT_KEEP_ALIVE_INTERVAL";
+const ENV_MQTT_QUEUE_DIR: &str = "RUSTFS_NOTIFY_MQTT_QUEUE_DIR";
+const ENV_MQTT_QUEUE_LIMIT: &str = "RUSTFS_NOTIFY_MQTT_QUEUE_LIMIT";
+
+/// Helper function to get values from environment variables or KVS configurations.
+///
+/// It will give priority to reading from environment variables such as `BASE_ENV_KEY_ID` and fall back to the KVS configuration if it fails.
+fn get_config_value(id: &str, base_env_key: &str, config_key: &str, config: &KVS) -> Option<String> {
+    let env_key = if id != DEFAULT_TARGET {
+        format!("{}_{}", base_env_key, id.to_uppercase().replace('-', "_"))
+    } else {
+        base_env_key.to_string()
+    };
+
+    match std::env::var(&env_key) {
+        Ok(val) => Some(val),
+        Err(_) => config.lookup(config_key),
+    }
+}
+
+/// Trait for creating targets from configuration
+#[async_trait]
+pub trait TargetFactory: Send + Sync {
+    /// Creates a target from configuration
+    async fn create_target(&self, id: String, config: &KVS) -> Result<Box<dyn Target + Send + Sync>, TargetError>;
+
+    /// Validates target configuration
+    fn validate_config(&self, id: &str, config: &KVS) -> Result<(), TargetError>;
+}
+
+/// Factory for creating Webhook targets
+pub struct WebhookTargetFactory;
+
+#[async_trait]
+impl TargetFactory for WebhookTargetFactory {
+    async fn create_target(&self, id: String, config: &KVS) -> Result<Box<dyn Target + Send + Sync>, TargetError> {
+        let get = |base_env_key: &str, config_key: &str| get_config_value(&id, base_env_key, config_key, config);
+
+        let enable = get(ENV_WEBHOOK_ENABLE, ENABLE_KEY)
+            .map(|v| v.eq_ignore_ascii_case(ENABLE_ON) || v.eq_ignore_ascii_case("true"))
+            .unwrap_or(false);
+
+        if !enable {
+            return Err(TargetError::Configuration("Target is disabled".to_string()));
+        }
+
+        let endpoint = get(ENV_WEBHOOK_ENDPOINT, WEBHOOK_ENDPOINT)
+            .ok_or_else(|| TargetError::Configuration("Missing webhook endpoint".to_string()))?;
+        let endpoint_url =
+            Url::parse(&endpoint).map_err(|e| TargetError::Configuration(format!("Invalid endpoint URL: {}", e)))?;
+
+        let auth_token = get(ENV_WEBHOOK_AUTH_TOKEN, WEBHOOK_AUTH_TOKEN).unwrap_or_default();
+        let queue_dir = get(ENV_WEBHOOK_QUEUE_DIR, WEBHOOK_QUEUE_DIR).unwrap_or_default();
+
+        let queue_limit = get(ENV_WEBHOOK_QUEUE_LIMIT, WEBHOOK_QUEUE_LIMIT)
+            .and_then(|v| v.parse::<u64>().ok())
+            .unwrap_or(DEFAULT_LIMIT);
+
+        let client_cert = get(ENV_WEBHOOK_CLIENT_CERT, WEBHOOK_CLIENT_CERT).unwrap_or_default();
+        let client_key = get(ENV_WEBHOOK_CLIENT_KEY, WEBHOOK_CLIENT_KEY).unwrap_or_default();
+
+        let args = WebhookArgs {
+            enable,
+            endpoint: endpoint_url,
+            auth_token,
+            queue_dir,
+            queue_limit,
+            client_cert,
+            client_key,
+        };
+
+        let target = crate::target::webhook::WebhookTarget::new(id, args)?;
+        Ok(Box::new(target))
+    }
+
+    fn validate_config(&self, id: &str, config: &KVS) -> Result<(), TargetError> {
+        let get = |base_env_key: &str, config_key: &str| get_config_value(id, base_env_key, config_key, config);
+
+        let enable = get(ENV_WEBHOOK_ENABLE, ENABLE_KEY)
+            .map(|v| v.eq_ignore_ascii_case(ENABLE_ON) || v.eq_ignore_ascii_case("true"))
+            .unwrap_or(false);
+
+        if !enable {
+            return Ok(());
+        }
+
+        let endpoint = get(ENV_WEBHOOK_ENDPOINT, WEBHOOK_ENDPOINT)
+            .ok_or_else(|| TargetError::Configuration("Missing webhook endpoint".to_string()))?;
+        Url::parse(&endpoint).map_err(|e| TargetError::Configuration(format!("Invalid endpoint URL: {}", e)))?;
+
+        let client_cert = get(ENV_WEBHOOK_CLIENT_CERT, WEBHOOK_CLIENT_CERT).unwrap_or_default();
+        let client_key = get(ENV_WEBHOOK_CLIENT_KEY, WEBHOOK_CLIENT_KEY).unwrap_or_default();
+
+        if client_cert.is_empty() != client_key.is_empty() {
+            return Err(TargetError::Configuration(
+                "Both client_cert and client_key must be specified together".to_string(),
+            ));
+        }
+
+        let queue_dir = get(ENV_WEBHOOK_QUEUE_DIR, WEBHOOK_QUEUE_DIR).unwrap_or_default();
+        if !queue_dir.is_empty() && !std::path::Path::new(&queue_dir).is_absolute() {
+            return Err(TargetError::Configuration("Webhook queue directory must be an absolute path".to_string()));
+        }
+
+        Ok(())
+    }
+}
+
+/// Factory for creating MQTT targets
+pub struct MQTTTargetFactory;
+
+#[async_trait]
+impl TargetFactory for MQTTTargetFactory {
+    async fn create_target(&self, id: String, config: &KVS) -> Result<Box<dyn Target + Send + Sync>, TargetError> {
+        let get = |base_env_key: &str, config_key: &str| get_config_value(&id, base_env_key, config_key, config);
+
+        let enable = get(ENV_MQTT_ENABLE, ENABLE_KEY)
+            .map(|v| v.eq_ignore_ascii_case(ENABLE_ON) || v.eq_ignore_ascii_case("true"))
+            .unwrap_or(false);
+
+        if !enable {
+            return Err(TargetError::Configuration("Target is disabled".to_string()));
+        }
+
+        let broker =
+            get(ENV_MQTT_BROKER, MQTT_BROKER).ok_or_else(|| TargetError::Configuration("Missing MQTT broker".to_string()))?;
+        let broker_url = Url::parse(&broker).map_err(|e| TargetError::Configuration(format!("Invalid broker URL: {}", e)))?;
+
+        let topic =
+            get(ENV_MQTT_TOPIC, MQTT_TOPIC).ok_or_else(|| TargetError::Configuration("Missing MQTT topic".to_string()))?;
+
+        let qos = get(ENV_MQTT_QOS, MQTT_QOS)
+            .and_then(|v| v.parse::<u8>().ok())
+            .map(|q| match q {
+                0 => QoS::AtMostOnce,
+                1 => QoS::AtLeastOnce,
+                2 => QoS::ExactlyOnce,
+                _ => QoS::AtLeastOnce,
+            })
+            .unwrap_or(QoS::AtLeastOnce);
+
+        let username = get(ENV_MQTT_USERNAME, MQTT_USERNAME).unwrap_or_default();
+        let password = get(ENV_MQTT_PASSWORD, MQTT_PASSWORD).unwrap_or_default();
+
+        let reconnect_interval = get(ENV_MQTT_RECONNECT_INTERVAL, MQTT_RECONNECT_INTERVAL)
+            .and_then(|v| v.parse::<u64>().ok())
+            .map(Duration::from_secs)
+            .unwrap_or_else(|| Duration::from_secs(5));
+
+        let keep_alive = get(ENV_MQTT_KEEP_ALIVE_INTERVAL, MQTT_KEEP_ALIVE_INTERVAL)
+            .and_then(|v| v.parse::<u64>().ok())
+            .map(Duration::from_secs)
+            .unwrap_or_else(|| Duration::from_secs(30));
+
+        let queue_dir = get(ENV_MQTT_QUEUE_DIR, MQTT_QUEUE_DIR).unwrap_or_default();
+        let queue_limit = get(ENV_MQTT_QUEUE_LIMIT, MQTT_QUEUE_LIMIT)
+            .and_then(|v| v.parse::<u64>().ok())
+            .unwrap_or(DEFAULT_LIMIT);
+
+        let args = MQTTArgs {
+            enable,
+            broker: broker_url,
+            topic,
+            qos,
+            username,
+            password,
+            max_reconnect_interval: reconnect_interval,
+            keep_alive,
+            queue_dir,
+            queue_limit,
+        };
+
+        let target = crate::target::mqtt::MQTTTarget::new(id, args)?;
+        Ok(Box::new(target))
+    }
+
+    fn validate_config(&self, id: &str, config: &KVS) -> Result<(), TargetError> {
+        let get = |base_env_key: &str, config_key: &str| get_config_value(id, base_env_key, config_key, config);
+
+        let enable = get(ENV_MQTT_ENABLE, ENABLE_KEY)
+            .map(|v| v.eq_ignore_ascii_case(ENABLE_ON) || v.eq_ignore_ascii_case("true"))
+            .unwrap_or(false);
+
+        if !enable {
+            return Ok(());
+        }
+
+        let broker =
+            get(ENV_MQTT_BROKER, MQTT_BROKER).ok_or_else(|| TargetError::Configuration("Missing MQTT broker".to_string()))?;
+        let url = Url::parse(&broker).map_err(|e| TargetError::Configuration(format!("Invalid broker URL: {}", e)))?;
+
+        match url.scheme() {
+            "tcp" | "ssl" | "ws" | "wss" | "mqtt" | "mqtts" => {}
+            _ => {
+                return Err(TargetError::Configuration("Unsupported broker URL scheme".to_string()));
+            }
+        }
+
+        if get(ENV_MQTT_TOPIC, MQTT_TOPIC).is_none() {
+            return Err(TargetError::Configuration("Missing MQTT topic".to_string()));
+        }
+
+        if let Some(qos_str) = get(ENV_MQTT_QOS, MQTT_QOS) {
+            let qos = qos_str
+                .parse::<u8>()
+                .map_err(|_| TargetError::Configuration("Invalid QoS value".to_string()))?;
+            if qos > 2 {
+                return Err(TargetError::Configuration("QoS must be 0, 1, or 2".to_string()));
+            }
+        }
+
+        let queue_dir = get(ENV_MQTT_QUEUE_DIR, MQTT_QUEUE_DIR).unwrap_or_default();
+        if !queue_dir.is_empty() {
+            if !std::path::Path::new(&queue_dir).is_absolute() {
+                return Err(TargetError::Configuration("MQTT queue directory must be an absolute path".to_string()));
+            }
+            if let Some(qos_str) = get(ENV_MQTT_QOS, MQTT_QOS) {
+                if qos_str == "0" {
+                    warn!("Using queue_dir with QoS 0 may result in event loss");
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
diff --git a/crates/notify/src/global.rs b/crates/notify/src/global.rs
new file mode 100644
index 00000000..ebae7b84
--- /dev/null
+++ b/crates/notify/src/global.rs
@@ -0,0 +1,58 @@
+use crate::{Event, EventArgs, NotificationError, NotificationSystem};
+use ecstore::config::Config;
+use once_cell::sync::Lazy;
+use std::sync::{Arc, OnceLock};
+
+static NOTIFICATION_SYSTEM: OnceLock<Arc<NotificationSystem>> = OnceLock::new();
+// Create a globally unique Notifier instance
+pub static GLOBAL_NOTIFIER: Lazy<Notifier> = Lazy::new(|| Notifier {});
+
+/// Initialize the global notification system with the given configuration.
+/// This function should only be called once throughout the application life cycle.
+pub async fn initialize(config: Config) -> Result<(), NotificationError> {
+    // `new` is synchronous and responsible for creating instances
+    let system = NotificationSystem::new(config);
+    // `init` is asynchronous and responsible for performing I/O-intensive initialization
+    system.init().await?;
+
+    match NOTIFICATION_SYSTEM.set(Arc::new(system)) {
+        Ok(_) => Ok(()),
+        Err(_) => Err(NotificationError::AlreadyInitialized),
+    }
+}
+
+/// Returns a handle to the global NotificationSystem instance.
+/// Return None if the system has not been initialized.
+pub fn notification_system() -> Option<Arc<NotificationSystem>> {
+    NOTIFICATION_SYSTEM.get().cloned()
+}
+
+pub struct Notifier {
+    // Notifier can hold state, but in this design we make it stateless,
+    // Rely on getting an instance of NotificationSystem from the outside.
+}
+
+impl Notifier {
+    /// Notify an event asynchronously.
+    /// This is the only entry point for all event notifications in the system.
+    pub async fn notify(&self, args: EventArgs) {
+        // Dependency injection or service positioning mode obtain NotificationSystem instance
+        let notification_sys = match notification_system() {
+            // If the notification system itself cannot be retrieved, it will be returned directly
+            Some(sys) => sys,
+            None => {
+                tracing::error!("Notification system is not initialized.");
+                return;
+            }
+        };
+
+        // Avoid generating notifications for replica creation events
+        if args.is_replication_request() {
+            return;
+        }
+
+        // Create an event and send it
+        let event = Arc::new(Event::new(args));
+        notification_sys.send_event(event).await;
+    }
+}
diff --git a/crates/notify/src/integration.rs b/crates/notify/src/integration.rs
new file mode 100644
index 00000000..7fa9cfae
--- /dev/null
+++ b/crates/notify/src/integration.rs
@@ -0,0 +1,481 @@
+use crate::arn::TargetID;
+use crate::store::{Key, Store};
+use crate::{
+    Event, EventName, StoreError, Target, error::NotificationError, notifier::EventNotifier, registry::TargetRegistry,
+    rules::BucketNotificationConfig, stream,
+};
+use ecstore::config::{Config, KVS};
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::time::{Duration, Instant};
+use tokio::sync::{RwLock, Semaphore, mpsc};
+use tracing::{debug, error, info, warn};
+
+/// Notify the system of monitoring indicators
+pub struct NotificationMetrics {
+    /// The number of events currently being processed
+    processing_events: AtomicUsize,
+    /// Number of events that have been successfully processed
+    processed_events: AtomicUsize,
+    /// Number of events that failed to handle
+    failed_events: AtomicUsize,
+    /// System startup time
+    start_time: Instant,
+}
+
+impl Default for NotificationMetrics {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl NotificationMetrics {
+    pub fn new() -> Self {
+        NotificationMetrics {
+            processing_events: AtomicUsize::new(0),
+            processed_events: AtomicUsize::new(0),
+            failed_events: AtomicUsize::new(0),
+            start_time: Instant::now(),
+        }
+    }
+
+    // Provide public methods to increase count
+    pub fn increment_processing(&self) {
+        self.processing_events.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn increment_processed(&self) {
+        self.processing_events.fetch_sub(1, Ordering::Relaxed);
+        self.processed_events.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn increment_failed(&self) {
+        self.processing_events.fetch_sub(1, Ordering::Relaxed);
+        self.failed_events.fetch_add(1, Ordering::Relaxed);
+    }
+
+    // Provide public methods to get count
+    pub fn processing_count(&self) -> usize {
+        self.processing_events.load(Ordering::Relaxed)
+    }
+
+    pub fn processed_count(&self) -> usize {
+        self.processed_events.load(Ordering::Relaxed)
+    }
+
+    pub fn failed_count(&self) -> usize {
+        self.failed_events.load(Ordering::Relaxed)
+    }
+
+    pub fn uptime(&self) -> Duration {
+        self.start_time.elapsed()
+    }
+}
+
+/// The notification system that integrates all components
+pub struct NotificationSystem {
+    /// The event notifier
+    pub notifier: Arc<EventNotifier>,
+    /// The target registry
+    pub registry: Arc<TargetRegistry>,
+    /// The current configuration
+    pub config: Arc<RwLock<Config>>,
+    /// Cancel sender for managing stream processing tasks
+    stream_cancellers: Arc<RwLock<HashMap<TargetID, mpsc::Sender<()>>>>,
+    /// Concurrent control signal quantity
+    concurrency_limiter: Arc<Semaphore>,
+    /// Monitoring indicators
+    metrics: Arc<NotificationMetrics>,
+}
+
+impl NotificationSystem {
+    /// Creates a new NotificationSystem
+    pub fn new(config: Config) -> Self {
+        NotificationSystem {
+            notifier: Arc::new(EventNotifier::new()),
+            registry: Arc::new(TargetRegistry::new()),
+            config: Arc::new(RwLock::new(config)),
+            stream_cancellers: Arc::new(RwLock::new(HashMap::new())),
+            concurrency_limiter: Arc::new(Semaphore::new(
+                std::env::var("RUSTFS_TARGET_STREAM_CONCURRENCY")
+                    .ok()
+                    .and_then(|s| s.parse().ok())
+                    .unwrap_or(20),
+            )), // Limit the maximum number of concurrent processing events to 20
+            metrics: Arc::new(NotificationMetrics::new()),
+        }
+    }
+
+    /// Initializes the notification system
+    pub async fn init(&self) -> Result<(), NotificationError> {
+        info!("Initialize notification system...");
+
+        let config = self.config.read().await;
+        debug!("Initializing notification system with config: {:?}", *config);
+        let targets: Vec<Box<dyn Target + Send + Sync>> = self.registry.create_targets_from_config(&config).await?;
+
+        info!("{} notification targets were created", targets.len());
+
+        // Initiate event stream processing for each storage enabled target
+        let mut cancellers = HashMap::new();
+        for target in &targets {
+            let target_id = target.id();
+            info!("Initializing target: {}", target.id());
+            // Initialize the target
+            if let Err(e) = target.init().await {
+                error!("Target {} Initialization failed:{}", target.id(), e);
+                continue;
+            }
+            debug!("Target {} initialized successfully,enabled:{}", target_id, target.is_enabled());
+            // Check if the target is enabled and has storage
+            if target.is_enabled() {
+                if let Some(store) = target.store() {
+                    info!("Start event stream processing for target {}", target.id());
+
+                    // The storage of the cloned target and the target itself
+                    let store_clone = store.boxed_clone();
+                    let target_box = target.clone_dyn();
+                    let target_arc = Arc::from(target_box);
+
+                    // Add a reference to the monitoring metrics
+                    let metrics = self.metrics.clone();
+                    let semaphore = self.concurrency_limiter.clone();
+
+                    // Encapsulated enhanced version of start_event_stream
+                    let cancel_tx = self.enhanced_start_event_stream(store_clone, target_arc, metrics, semaphore);
+
+                    // Start event stream processing and save cancel sender
+                    let target_id_clone = target_id.clone();
+                    cancellers.insert(target_id, cancel_tx);
+                    info!("Event stream processing for target {} is started successfully", target_id_clone);
+                } else {
+                    info!("Target {} No storage is configured, event stream processing is skipped", target_id);
+                }
+            } else {
+                info!("Target {} is not enabled, event stream processing is skipped", target_id);
+            }
+        }
+
+        // Update canceler collection
+        *self.stream_cancellers.write().await = cancellers;
+        // Initialize the bucket target
+        self.notifier.init_bucket_targets(targets).await?;
+        info!("Notification system initialized");
+        Ok(())
+    }
+
+    /// Gets a list of Targets for all currently active (initialized).
+    ///
+    /// # Return
+    /// A Vec containing all active Targets `TargetID`.
+    pub async fn get_active_targets(&self) -> Vec<TargetID> {
+        self.notifier.target_list().read().await.keys()
+    }
+
+    /// Checks if there are active subscribers for the given bucket and event name.
+    pub async fn has_subscriber(&self, bucket: &str, event_name: &EventName) -> bool {
+        self.notifier.has_subscriber(bucket, event_name).await
+    }
+
+    async fn update_config_and_reload<F>(&self, mut modifier: F) -> Result<(), NotificationError>
+    where
+        F: FnMut(&mut Config) -> bool, // The closure returns a boolean value indicating whether the configuration has been changed
+    {
+        let Some(store) = ecstore::global::new_object_layer_fn() else {
+            return Err(NotificationError::ServerNotInitialized);
+        };
+
+        let mut new_config = ecstore::config::com::read_config_without_migrate(store.clone())
+            .await
+            .map_err(|e| NotificationError::ReadConfig(e.to_string()))?;
+
+        if !modifier(&mut new_config) {
+            // If the closure indication has not changed, return in advance
+            info!("Configuration not changed, skipping save and reload.");
+            return Ok(());
+        }
+
+        if let Err(e) = ecstore::config::com::save_server_config(store, &new_config).await {
+            error!("Failed to save config: {}", e);
+            return Err(NotificationError::SaveConfig(e.to_string()));
+        }
+
+        info!("Configuration updated. Reloading system...");
+        self.reload_config(new_config).await
+    }
+
+    /// Accurately remove a Target and its related resources through TargetID.
+    ///
+    /// This process includes:
+    /// 1. Stop the event stream associated with the Target (if present).
+    /// 2. Remove the Target instance from the activity list of Notifier.
+    /// 3. Remove the configuration item of the Target from the system configuration.
+    ///
+    /// # Parameters
+    /// * `target_id` - The unique identifier of the Target to be removed.
+    ///
+    /// # return
+    /// If successful, return `Ok(())`.
+    pub async fn remove_target(&self, target_id: &TargetID, target_type: &str) -> Result<(), NotificationError> {
+        info!("Attempting to remove target: {}", target_id);
+
+        self.update_config_and_reload(|config| {
+            let mut changed = false;
+            if let Some(targets_of_type) = config.0.get_mut(target_type) {
+                if targets_of_type.remove(&target_id.name).is_some() {
+                    info!("Removed target {} from configuration", target_id);
+                    changed = true;
+                }
+                if targets_of_type.is_empty() {
+                    config.0.remove(target_type);
+                }
+            }
+            if !changed {
+                warn!("Target {} not found in configuration", target_id);
+            }
+            changed
+        })
+        .await
+    }
+
+    /// Set or update a Target configuration.
+    /// If the configuration is changed, the entire notification system will be automatically reloaded to apply the changes.
+    ///
+    /// # Arguments
+    /// * `target_type` - Target type, such as "notify_webhook" or "notify_mqtt".
+    /// * `target_name` - A unique name for a Target, such as "1".
+    /// * `kvs` - The full configuration of the Target.
+    ///
+    /// # Returns
+    /// Result<(), NotificationError>
+    /// If the target configuration is successfully set, it returns Ok(()).
+    /// If the target configuration is invalid, it returns Err(NotificationError::Configuration).
+    pub async fn set_target_config(&self, target_type: &str, target_name: &str, kvs: KVS) -> Result<(), NotificationError> {
+        info!("Setting config for target {} of type {}", target_name, target_type);
+        self.update_config_and_reload(|config| {
+            config
+                .0
+                .entry(target_type.to_string())
+                .or_default()
+                .insert(target_name.to_string(), kvs.clone());
+            true // The configuration is always modified
+        })
+        .await
+    }
+
+    /// Removes all notification configurations for a bucket.
+    pub async fn remove_bucket_notification_config(&self, bucket_name: &str) {
+        self.notifier.remove_rules_map(bucket_name).await;
+    }
+
+    /// Removes a Target configuration.
+    /// If the configuration is successfully removed, the entire notification system will be automatically reloaded.
+    ///
+    /// # Arguments
+    /// * `target_type` - Target type, such as "notify_webhook" or "notify_mqtt".
+    /// * `target_name` - A unique name for a Target, such as "1".
+    ///
+    /// # Returns
+    /// Result<(), NotificationError>
+    ///
+    /// If the target configuration is successfully removed, it returns Ok(()).
+    /// If the target configuration does not exist, it returns Ok(()) without making any changes.
+    pub async fn remove_target_config(&self, target_type: &str, target_name: &str) -> Result<(), NotificationError> {
+        info!("Removing config for target {} of type {}", target_name, target_type);
+        self.update_config_and_reload(|config| {
+            let mut changed = false;
+            if let Some(targets) = config.0.get_mut(target_type) {
+                if targets.remove(target_name).is_some() {
+                    changed = true;
+                }
+                if targets.is_empty() {
+                    config.0.remove(target_type);
+                }
+            }
+            if !changed {
+                info!("Target {} of type {} not found, no changes made.", target_name, target_type);
+            }
+            changed
+        })
+        .await
+    }
+
+    /// Enhanced event stream startup function, including monitoring and concurrency control
+    fn enhanced_start_event_stream(
+        &self,
+        store: Box<dyn Store<Event, Error = StoreError, Key = Key> + Send>,
+        target: Arc<dyn Target + Send + Sync>,
+        metrics: Arc<NotificationMetrics>,
+        semaphore: Arc<Semaphore>,
+    ) -> mpsc::Sender<()> {
+        // Event Stream Processing Using Batch Version
+        stream::start_event_stream_with_batching(store, target, metrics, semaphore)
+    }
+
+    /// Update configuration
+    async fn update_config(&self, new_config: Config) {
+        let mut config = self.config.write().await;
+        *config = new_config;
+    }
+
+    /// Reloads the configuration
+    pub async fn reload_config(&self, new_config: Config) -> Result<(), NotificationError> {
+        info!("Reload notification configuration starts");
+
+        // Stop all existing streaming services
+        let mut cancellers = self.stream_cancellers.write().await;
+        for (target_id, cancel_tx) in cancellers.drain() {
+            info!("Stop event stream processing for target {}", target_id);
+            let _ = cancel_tx.send(()).await;
+        }
+
+        // Update the config
+        self.update_config(new_config.clone()).await;
+
+        // Create a new target from configuration
+        let targets: Vec<Box<dyn Target + Send + Sync>> = self
+            .registry
+            .create_targets_from_config(&new_config)
+            .await
+            .map_err(NotificationError::Target)?;
+
+        info!("{} notification targets were created from the new configuration", targets.len());
+
+        // Start new event stream processing for each storage enabled target
+        let mut new_cancellers = HashMap::new();
+        for target in &targets {
+            let target_id = target.id();
+
+            // Initialize the target
+            if let Err(e) = target.init().await {
+                error!("Target {} Initialization failed:{}", target_id, e);
+                continue;
+            }
+            // Check if the target is enabled and has storage
+            if target.is_enabled() {
+                if let Some(store) = target.store() {
+                    info!("Start new event stream processing for target {}", target_id);
+
+                    // The storage of the cloned target and the target itself
+                    let store_clone = store.boxed_clone();
+                    let target_box = target.clone_dyn();
+                    let target_arc = Arc::from(target_box);
+
+                    // Add a reference to the monitoring metrics
+                    let metrics = self.metrics.clone();
+                    let semaphore = self.concurrency_limiter.clone();
+
+                    // Encapsulated enhanced version of start_event_stream
+                    let cancel_tx = self.enhanced_start_event_stream(store_clone, target_arc, metrics, semaphore);
+
+                    // Start event stream processing and save cancel sender
+                    // let cancel_tx = start_event_stream(store_clone, target_clone);
+                    let target_id_clone = target_id.clone();
+                    new_cancellers.insert(target_id, cancel_tx);
+                    info!("Event stream processing of target {} is restarted successfully", target_id_clone);
+                } else {
+                    info!("Target {} No storage is configured, event stream processing is skipped", target_id);
+                }
+            } else {
+                info!("Target {} disabled, event stream processing is skipped", target_id);
+            }
+        }
+
+        // Update canceler collection
+        *cancellers = new_cancellers;
+
+        // Initialize the bucket target
+        self.notifier.init_bucket_targets(targets).await?;
+        info!("Configuration reloaded end");
+        Ok(())
+    }
+
+    /// Loads the bucket notification configuration
+    pub async fn load_bucket_notification_config(
+        &self,
+        bucket_name: &str,
+        config: &BucketNotificationConfig,
+    ) -> Result<(), NotificationError> {
+        let arn_list = self.notifier.get_arn_list(&config.region).await;
+        if arn_list.is_empty() {
+            return Err(NotificationError::Configuration("No targets configured".to_string()));
+        }
+        info!("Available ARNs: {:?}", arn_list);
+        // Validate the configuration against the available ARNs
+        if let Err(e) = config.validate(&config.region, &arn_list) {
+            debug!("Bucket notification config validation region:{} failed: {}", &config.region, e);
+            if !e.to_string().contains("ARN not found") {
+                return Err(NotificationError::BucketNotification(e.to_string()));
+            } else {
+                error!("{}", e);
+            }
+        }
+
+        // let rules_map = config.to_rules_map();
+        let rules_map = config.get_rules_map();
+        self.notifier.add_rules_map(bucket_name, rules_map.clone()).await;
+        info!("Loaded notification config for bucket: {}", bucket_name);
+        Ok(())
+    }
+
+    /// Sends an event
+    pub async fn send_event(&self, event: Arc<Event>) {
+        self.notifier.send(event).await;
+    }
+
+    /// Obtain system status information
+    pub fn get_status(&self) -> HashMap<String, String> {
+        let mut status = HashMap::new();
+
+        status.insert("uptime_seconds".to_string(), self.metrics.uptime().as_secs().to_string());
+        status.insert("processing_events".to_string(), self.metrics.processing_count().to_string());
+        status.insert("processed_events".to_string(), self.metrics.processed_count().to_string());
+        status.insert("failed_events".to_string(), self.metrics.failed_count().to_string());
+
+        status
+    }
+
+    // Add a method to shut down the system
+    pub async fn shutdown(&self) {
+        info!("Turn off the notification system");
+
+        // Get the number of active targets
+        let active_targets = self.stream_cancellers.read().await.len();
+        info!("Stops {} active event stream processing tasks", active_targets);
+
+        let mut cancellers = self.stream_cancellers.write().await;
+        for (target_id, cancel_tx) in cancellers.drain() {
+            info!("Stop event stream processing for target {}", target_id);
+            let _ = cancel_tx.send(()).await;
+        }
+        // Wait for a short while to make sure the task has a chance to complete
+        tokio::time::sleep(Duration::from_millis(500)).await;
+
+        info!("Notify the system to be shut down completed");
+    }
+}
+
+impl Drop for NotificationSystem {
+    fn drop(&mut self) {
+        // Asynchronous operation cannot be used here, but logs can be recorded.
+        info!("Notify the system instance to be destroyed");
+        let status = self.get_status();
+        for (key, value) in status {
+            info!("key:{}, value:{}", key, value);
+        }
+
+        info!("Notification system status at shutdown:");
+    }
+}
+
+/// Loads configuration from a file
+pub async fn load_config_from_file(path: &str, system: &NotificationSystem) -> Result<(), NotificationError> {
+    let config_data = tokio::fs::read(path)
+        .await
+        .map_err(|e| NotificationError::Configuration(format!("Failed to read config file: {}", e)))?;
+
+    let config = Config::unmarshal(config_data.as_slice())
+        .map_err(|e| NotificationError::Configuration(format!("Failed to parse config: {}", e)))?;
+    system.reload_config(config).await
+}
diff --git a/crates/notify/src/lib.rs b/crates/notify/src/lib.rs
new file mode 100644
index 00000000..74435dee
--- /dev/null
+++ b/crates/notify/src/lib.rs
@@ -0,0 +1,71 @@
+//! RustFS Notify - A flexible and extensible event notification system for object storage.
+//!
+//! This library provides a Rust implementation of a storage bucket notification system,
+//! similar to RustFS's notification system. It supports sending events to various targets
+//! (like Webhook and MQTT) and includes features like event persistence and retry on failure.
+
+pub mod arn;
+pub mod error;
+pub mod event;
+pub mod factory;
+pub mod global;
+pub mod integration;
+pub mod notifier;
+pub mod registry;
+pub mod rules;
+pub mod store;
+pub mod stream;
+pub mod target;
+
+// Re-exports
+pub use error::{NotificationError, StoreError, TargetError};
+pub use event::{Event, EventArgs, EventLog, EventName};
+pub use global::{initialize, notification_system};
+pub use integration::NotificationSystem;
+pub use rules::BucketNotificationConfig;
+use std::io::IsTerminal;
+pub use target::Target;
+
+use tracing_subscriber::{EnvFilter, fmt, prelude::*, util::SubscriberInitExt};
+
+/// Initialize the tracing log system
+///
+/// # Example
+/// ```
+/// rustfs_notify::init_logger(rustfs_notify::LogLevel::Info);
+/// ```
+pub fn init_logger(level: LogLevel) {
+    let filter = EnvFilter::default().add_directive(level.into());
+    tracing_subscriber::registry()
+        .with(filter)
+        .with(
+            fmt::layer()
+                .with_target(true)
+                .with_target(true)
+                .with_ansi(std::io::stdout().is_terminal())
+                .with_thread_names(true)
+                .with_thread_ids(true)
+                .with_file(true)
+                .with_line_number(true),
+        )
+        .init();
+}
+
+/// Log level definition
+pub enum LogLevel {
+    Debug,
+    Info,
+    Warn,
+    Error,
+}
+
+impl From<LogLevel> for tracing_subscriber::filter::Directive {
+    fn from(level: LogLevel) -> Self {
+        match level {
+            LogLevel::Debug => "debug".parse().unwrap(),
+            LogLevel::Info => "info".parse().unwrap(),
+            LogLevel::Warn => "warn".parse().unwrap(),
+            LogLevel::Error => "error".parse().unwrap(),
+        }
+    }
+}
diff --git a/crates/notify/src/notifier.rs b/crates/notify/src/notifier.rs
new file mode 100644
index 00000000..4447c305
--- /dev/null
+++ b/crates/notify/src/notifier.rs
@@ -0,0 +1,260 @@
+use crate::arn::TargetID;
+use crate::{EventName, error::NotificationError, event::Event, rules::RulesMap, target::Target};
+use dashmap::DashMap;
+use std::{collections::HashMap, sync::Arc};
+use tokio::sync::RwLock;
+use tracing::{debug, error, info, instrument, warn};
+
+/// Manages event notification to targets based on rules
+pub struct EventNotifier {
+    target_list: Arc<RwLock<TargetList>>,
+    bucket_rules_map: Arc<DashMap<String, RulesMap>>,
+}
+
+impl Default for EventNotifier {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl EventNotifier {
+    /// Creates a new EventNotifier
+    pub fn new() -> Self {
+        EventNotifier {
+            target_list: Arc::new(RwLock::new(TargetList::new())),
+            bucket_rules_map: Arc::new(DashMap::new()),
+        }
+    }
+
+    /// Returns a reference to the target list
+    /// This method provides access to the target list for external use.
+    ///
+    pub fn target_list(&self) -> Arc<RwLock<TargetList>> {
+        Arc::clone(&self.target_list)
+    }
+
+    /// Removes all notification rules for a bucket
+    ///
+    /// # Arguments
+    /// * `bucket_name` - The name of the bucket for which to remove rules
+    ///
+    /// This method removes all rules associated with the specified bucket name.
+    /// It will log a message indicating the removal of rules.
+    pub async fn remove_rules_map(&self, bucket_name: &str) {
+        if self.bucket_rules_map.remove(bucket_name).is_some() {
+            info!("Removed all notification rules for bucket: {}", bucket_name);
+        }
+    }
+
+    /// Returns a list of ARNs for the registered targets
+    pub async fn get_arn_list(&self, region: &str) -> Vec<String> {
+        let target_list_guard = self.target_list.read().await;
+        target_list_guard
+            .keys()
+            .iter()
+            .map(|target_id| target_id.to_arn(region).to_arn_string())
+            .collect()
+    }
+
+    /// Adds a rules map for a bucket
+    pub async fn add_rules_map(&self, bucket_name: &str, rules_map: RulesMap) {
+        if rules_map.is_empty() {
+            self.bucket_rules_map.remove(bucket_name);
+        } else {
+            self.bucket_rules_map.insert(bucket_name.to_string(), rules_map);
+        }
+        info!("Added rules for bucket: {}", bucket_name);
+    }
+
+    /// Removes notification rules for a bucket
+    pub async fn remove_notification(&self, bucket_name: &str) {
+        self.bucket_rules_map.remove(bucket_name);
+        info!("Removed notification rules for bucket: {}", bucket_name);
+    }
+
+    /// Removes all targets
+    pub async fn remove_all_bucket_targets(&self) {
+        let mut target_list_guard = self.target_list.write().await;
+        // The logic for sending cancel signals via stream_cancel_senders would be removed.
+        // TargetList::clear_targets_only already handles calling target.close().
+        target_list_guard.clear_targets_only().await; // Modified clear to not re-cancel
+        info!("Removed all targets and their streams");
+    }
+
+    /// Checks if there are active subscribers for the given bucket and event name.
+    ///
+    /// # Parameters
+    /// * `bucket_name` - bucket name.
+    /// * `event_name` - Event name.
+    ///
+    /// # Return value
+    /// Return `true` if at least one matching notification rule exists.
+    pub async fn has_subscriber(&self, bucket_name: &str, event_name: &EventName) -> bool {
+        // Rules to check if the bucket exists
+        if let Some(rules_map) = self.bucket_rules_map.get(bucket_name) {
+            // A composite event (such as ObjectCreatedAll) is expanded to multiple single events.
+            // We need to check whether any of these single events have the rules configured.
+            rules_map.has_subscriber(event_name)
+        } else {
+            // If no bucket is found, no subscribers
+            false
+        }
+    }
+
+    /// Sends an event to the appropriate targets based on the bucket rules
+    #[instrument(skip(self, event))]
+    pub async fn send(&self, event: Arc<Event>) {
+        let bucket_name = &event.s3.bucket.name;
+        let object_key = &event.s3.object.key;
+        let event_name = event.event_name;
+        if let Some(rules) = self.bucket_rules_map.get(bucket_name) {
+            let target_ids = rules.match_rules(event_name, object_key);
+            if target_ids.is_empty() {
+                debug!("No matching targets for event in bucket: {}", bucket_name);
+                return;
+            }
+            let target_ids_len = target_ids.len();
+            let mut handles = vec![];
+
+            // Use scope to limit the borrow scope of target_list
+            {
+                let target_list_guard = self.target_list.read().await;
+                info!("Sending event to targets: {:?}", target_ids);
+                for target_id in target_ids {
+                    // `get` now returns Option<Arc<dyn Target + Send + Sync>>
+                    if let Some(target_arc) = target_list_guard.get(&target_id) {
+                        // Clone an Arc<Box<dyn Target>> (which is where target_list is stored) to move into an asynchronous task
+                        // target_arc is already Arc, clone it for the async task
+                        let cloned_target_for_task = target_arc.clone();
+                        let event_clone = event.clone();
+                        let target_name_for_task = cloned_target_for_task.name(); // Get the name before generating the task
+                        debug!("Preparing to send event to target: {}", target_name_for_task);
+                        // Use cloned data in closures to avoid borrowing conflicts
+                        let handle = tokio::spawn(async move {
+                            if let Err(e) = cloned_target_for_task.save(event_clone).await {
+                                error!("Failed to send event to target {}: {}", target_name_for_task, e);
+                            } else {
+                                debug!("Successfully saved event to target {}", target_name_for_task);
+                            }
+                        });
+                        handles.push(handle);
+                    } else {
+                        warn!("Target ID {:?} found in rules but not in target list.", target_id);
+                    }
+                }
+                // target_list is automatically released here
+            }
+
+            // Wait for all tasks to be completed
+            for handle in handles {
+                if let Err(e) = handle.await {
+                    error!("Task for sending/saving event failed: {}", e);
+                }
+            }
+            info!("Event processing initiated for {} targets for bucket: {}", target_ids_len, bucket_name);
+        } else {
+            debug!("No rules found for bucket: {}", bucket_name);
+        }
+    }
+
+    /// Initializes the targets for buckets
+    #[instrument(skip(self, targets_to_init))]
+    pub async fn init_bucket_targets(
+        &self,
+        targets_to_init: Vec<Box<dyn Target + Send + Sync>>,
+    ) -> Result<(), NotificationError> {
+        // Currently active, simpler logic
+        let mut target_list_guard = self.target_list.write().await; //Gets a write lock for the TargetList
+        for target_boxed in targets_to_init {
+            // Traverse the incoming Box<dyn Target >
+            debug!("init bucket target: {}", target_boxed.name());
+            // TargetList::add method expectations Arc<dyn Target + Send + Sync>
+            // Therefore, you need to convert Box<dyn Target + Send + Sync> to Arc<dyn Target + Send + Sync>
+            let target_arc: Arc<dyn Target + Send + Sync> = Arc::from(target_boxed);
+            target_list_guard.add(target_arc)?; // Add Arc<dyn Target> to the list
+        }
+        info!(
+            "Initialized {} targets, list size: {}", // Clearer logs
+            target_list_guard.len(),
+            target_list_guard.len()
+        );
+        Ok(()) // Make sure to return a Result
+    }
+}
+
+/// A thread-safe list of targets
+pub struct TargetList {
+    targets: HashMap<TargetID, Arc<dyn Target + Send + Sync>>,
+}
+
+impl Default for TargetList {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl TargetList {
+    /// Creates a new TargetList
+    pub fn new() -> Self {
+        TargetList { targets: HashMap::new() }
+    }
+
+    /// Adds a target to the list
+    pub fn add(&mut self, target: Arc<dyn Target + Send + Sync>) -> Result<(), NotificationError> {
+        let id = target.id();
+        if self.targets.contains_key(&id) {
+            // Potentially update or log a warning/error if replacing an existing target.
+            warn!("Target with ID {} already exists in TargetList. It will be overwritten.", id);
+        }
+        self.targets.insert(id, target);
+        Ok(())
+    }
+
+    /// Removes a target by ID. Note: This does not stop its associated event stream.
+    /// Stream cancellation should be handled by EventNotifier.
+    pub async fn remove_target_only(&mut self, id: &TargetID) -> Option<Arc<dyn Target + Send + Sync>> {
+        if let Some(target_arc) = self.targets.remove(id) {
+            if let Err(e) = target_arc.close().await {
+                // Target's own close logic
+                error!("Failed to close target {} during removal: {}", id, e);
+            }
+            Some(target_arc)
+        } else {
+            None
+        }
+    }
+
+    /// Clears all targets from the list. Note: This does not stop their associated event streams.
+    /// Stream cancellation should be handled by EventNotifier.
+    pub async fn clear_targets_only(&mut self) {
+        let target_ids_to_clear: Vec<TargetID> = self.targets.keys().cloned().collect();
+        for id in target_ids_to_clear {
+            if let Some(target_arc) = self.targets.remove(&id) {
+                if let Err(e) = target_arc.close().await {
+                    error!("Failed to close target {} during clear: {}", id, e);
+                }
+            }
+        }
+        self.targets.clear();
+    }
+
+    /// Returns a target by ID
+    pub fn get(&self, id: &TargetID) -> Option<Arc<dyn Target + Send + Sync>> {
+        self.targets.get(id).cloned()
+    }
+
+    /// Returns all target IDs
+    pub fn keys(&self) -> Vec<TargetID> {
+        self.targets.keys().cloned().collect()
+    }
+
+    /// Returns the number of targets
+    pub fn len(&self) -> usize {
+        self.targets.len()
+    }
+
+    // is_empty can be derived from len()
+    pub fn is_empty(&self) -> bool {
+        self.targets.is_empty()
+    }
+}
diff --git a/crates/notify/src/registry.rs b/crates/notify/src/registry.rs
new file mode 100644
index 00000000..748b5356
--- /dev/null
+++ b/crates/notify/src/registry.rs
@@ -0,0 +1,96 @@
+use crate::target::ChannelTargetType;
+use crate::{
+    error::TargetError,
+    factory::{MQTTTargetFactory, TargetFactory, WebhookTargetFactory},
+    target::Target,
+};
+use ecstore::config::{Config, ENABLE_KEY, ENABLE_OFF, ENABLE_ON, KVS};
+use std::collections::HashMap;
+use tracing::{error, info};
+
+/// Registry for managing target factories
+pub struct TargetRegistry {
+    factories: HashMap<String, Box<dyn TargetFactory>>,
+}
+
+impl Default for TargetRegistry {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl TargetRegistry {
+    /// Creates a new TargetRegistry with built-in factories
+    pub fn new() -> Self {
+        let mut registry = TargetRegistry {
+            factories: HashMap::new(),
+        };
+
+        // Register built-in factories
+        registry.register(ChannelTargetType::Webhook.as_str(), Box::new(WebhookTargetFactory));
+        registry.register(ChannelTargetType::Mqtt.as_str(), Box::new(MQTTTargetFactory));
+
+        registry
+    }
+
+    /// Registers a new factory for a target type
+    pub fn register(&mut self, target_type: &str, factory: Box<dyn TargetFactory>) {
+        self.factories.insert(target_type.to_string(), factory);
+    }
+
+    /// Creates a target from configuration
+    pub async fn create_target(
+        &self,
+        target_type: &str,
+        id: String,
+        config: &KVS,
+    ) -> Result<Box<dyn Target + Send + Sync>, TargetError> {
+        let factory = self
+            .factories
+            .get(target_type)
+            .ok_or_else(|| TargetError::Configuration(format!("Unknown target type: {}", target_type)))?;
+
+        // Validate configuration before creating target
+        factory.validate_config(&id, config)?;
+
+        // Create target
+        factory.create_target(id, config).await
+    }
+
+    /// Creates all targets from a configuration
+    pub async fn create_targets_from_config(&self, config: &Config) -> Result<Vec<Box<dyn Target + Send + Sync>>, TargetError> {
+        let mut targets: Vec<Box<dyn Target + Send + Sync>> = Vec::new();
+
+        // Iterate through configuration sections
+        for (section, subsections) in &config.0 {
+            // Only process notification sections
+            if !section.starts_with("notify_") {
+                continue;
+            }
+
+            // Extract target type from section name
+            let target_type = section.trim_start_matches("notify_");
+
+            // Iterate through subsections (each representing a target instance)
+            for (target_id, target_config) in subsections {
+                // Skip disabled targets
+                if target_config.lookup(ENABLE_KEY).unwrap_or_else(|| ENABLE_OFF.to_string()) != ENABLE_ON {
+                    continue;
+                }
+
+                // Create target
+                match self.create_target(target_type, target_id.clone(), target_config).await {
+                    Ok(target) => {
+                        info!("Created target: {}/{}", target_type, target_id);
+                        targets.push(target);
+                    }
+                    Err(e) => {
+                        error!("Failed to create target {}/{}: {}", target_type, target_id, e);
+                    }
+                }
+            }
+        }
+
+        Ok(targets)
+    }
+}
diff --git a/crates/notify/src/rules/config.rs b/crates/notify/src/rules/config.rs
new file mode 100644
index 00000000..11b684af
--- /dev/null
+++ b/crates/notify/src/rules/config.rs
@@ -0,0 +1,115 @@
+use super::rules_map::RulesMap;
+// Keep for existing structure if any, or remove if not used
+use super::xml_config::ParseConfigError as BucketNotificationConfigError;
+use crate::EventName;
+use crate::arn::TargetID;
+use crate::rules::NotificationConfiguration;
+use crate::rules::pattern_rules;
+use crate::rules::target_id_set;
+use std::collections::HashMap;
+use std::io::Read;
+
+/// Configuration for bucket notifications.
+/// This struct now holds the parsed and validated rules in the new RulesMap format.
+#[derive(Debug, Clone, Default)]
+pub struct BucketNotificationConfig {
+    pub region: String,  // Region where this config is applicable
+    pub rules: RulesMap, // The new, more detailed RulesMap
+}
+
+impl BucketNotificationConfig {
+    pub fn new(region: &str) -> Self {
+        BucketNotificationConfig {
+            region: region.to_string(),
+            rules: RulesMap::new(),
+        }
+    }
+
+    /// Adds a rule to the configuration.
+    /// This method allows adding a rule with a specific event and target ID.
+    pub fn add_rule(
+        &mut self,
+        event_names: &[EventName], // Assuming event_names is a list of event names
+        pattern: String,           // The object key pattern for the rule
+        target_id: TargetID,       // The target ID for the notification
+    ) {
+        self.rules.add_rule_config(event_names, pattern, target_id);
+    }
+
+    /// Parses notification configuration from XML.
+    /// `arn_list` is a list of valid ARN strings for validation.
+    pub fn from_xml<R: Read + std::io::BufRead>(
+        reader: R,
+        current_region: &str,
+        arn_list: &[String],
+    ) -> Result<Self, BucketNotificationConfigError> {
+        let mut parsed_config = NotificationConfiguration::from_reader(reader)?;
+
+        // Set defaults (region in ARNs if empty, xmlns) before validation
+        parsed_config.set_defaults(current_region);
+
+        // Validate the parsed configuration
+        parsed_config.validate(current_region, arn_list)?;
+
+        let mut rules_map = RulesMap::new();
+        for queue_conf in parsed_config.queue_list {
+            // The ARN in queue_conf should now have its region set if it was originally empty.
+            // Ensure TargetID can be cloned or extracted correctly.
+            let target_id = queue_conf.arn.target_id.clone();
+            let pattern_str = queue_conf.filter.filter_rule_list.pattern();
+            rules_map.add_rule_config(&queue_conf.events, pattern_str, target_id);
+        }
+
+        Ok(BucketNotificationConfig {
+            region: current_region.to_string(), // Config is for the current_region
+            rules: rules_map,
+        })
+    }
+
+    /// Validates the *current* BucketNotificationConfig.
+    /// This might be redundant if construction always implies validation.
+    /// However, Go's Config has a Validate method.
+    /// The primary validation now happens during `from_xml` via `NotificationConfiguration::validate`.
+    /// This method could re-check against an updated arn_list or region if needed.
+    pub fn validate(&self, current_region: &str, arn_list: &[String]) -> Result<(), BucketNotificationConfigError> {
+        if self.region != current_region {
+            return Err(BucketNotificationConfigError::RegionMismatch {
+                config_region: self.region.clone(),
+                current_region: current_region.to_string(),
+            });
+        }
+
+        // Iterate through the rules in self.rules and validate their TargetIDs against arn_list
+        // This requires RulesMap to expose its internal structure or provide an iterator
+        for (_event_name, pattern_rules) in self.rules.inner().iter() {
+            for (_pattern, target_id_set) in pattern_rules.inner().iter() {
+                // Assuming PatternRules has inner()
+                for target_id in target_id_set {
+                    // Construct the ARN string for this target_id and self.region
+                    let arn_to_check = target_id.to_arn(&self.region); // Assuming TargetID has to_arn
+                    if !arn_list.contains(&arn_to_check.to_arn_string()) {
+                        return Err(BucketNotificationConfigError::ArnNotFound(arn_to_check.to_arn_string()));
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    // Expose the RulesMap for the notifier
+    pub fn get_rules_map(&self) -> &RulesMap {
+        &self.rules
+    }
+
+    /// Sets the region for the configuration
+    pub fn set_region(&mut self, region: &str) {
+        self.region = region.to_string();
+    }
+}
+
+// Add a helper to PatternRules if not already present
+impl pattern_rules::PatternRules {
+    pub fn inner(&self) -> &HashMap<String, target_id_set::TargetIdSet> {
+        &self.rules
+    }
+}
diff --git a/crates/notify/src/rules/mod.rs b/crates/notify/src/rules/mod.rs
new file mode 100644
index 00000000..62d90963
--- /dev/null
+++ b/crates/notify/src/rules/mod.rs
@@ -0,0 +1,19 @@
+pub mod pattern;
+pub mod pattern_rules;
+pub mod rules_map;
+pub mod target_id_set;
+pub mod xml_config; // For XML structure definition and parsing
+
+pub mod config; // Definition and parsing for BucketNotificationConfig
+
+// Re-export key types from submodules for easy access to `crate::rules::TypeName`
+// Re-export key types from submodules for external use
+pub use config::BucketNotificationConfig;
+// Assume that BucketNotificationConfigError is also defined in config.rs
+// Or if it is still an alias for xml_config::ParseConfigError , adjust accordingly
+pub use xml_config::ParseConfigError as BucketNotificationConfigError;
+
+pub use pattern_rules::PatternRules;
+pub use rules_map::RulesMap;
+pub use target_id_set::TargetIdSet;
+pub use xml_config::{NotificationConfiguration, ParseConfigError};
diff --git a/crates/notify/src/rules/pattern.rs b/crates/notify/src/rules/pattern.rs
new file mode 100644
index 00000000..2e49d56a
--- /dev/null
+++ b/crates/notify/src/rules/pattern.rs
@@ -0,0 +1,96 @@
+use wildmatch::WildMatch;
+
+/// Create new pattern string based on prefix and suffix。
+///
+/// The rule is similar to event.NewPattern in the Go version:
+/// - If a prefix is provided and does not end with '*', '*' is appended.
+/// - If a suffix is provided and does not start with '*', then prefix '*'.
+/// - Replace "**" with "*".
+pub fn new_pattern(prefix: Option<&str>, suffix: Option<&str>) -> String {
+    let mut pattern = String::new();
+
+    // Process the prefix part
+    if let Some(p) = prefix {
+        if !p.is_empty() {
+            pattern.push_str(p);
+            if !p.ends_with('*') {
+                pattern.push('*');
+            }
+        }
+    }
+
+    // Process the suffix part
+    if let Some(s) = suffix {
+        if !s.is_empty() {
+            let mut s_to_append = s.to_string();
+            if !s.starts_with('*') {
+                s_to_append.insert(0, '*');
+            }
+
+            // If the pattern is empty (only suffixes are provided), then the pattern is the suffix
+            // Otherwise, append the suffix to the pattern
+            if pattern.is_empty() {
+                pattern = s_to_append;
+            } else {
+                pattern.push_str(&s_to_append);
+            }
+        }
+    }
+
+    // Replace "**" with "*"
+    pattern = pattern.replace("**", "*");
+
+    pattern
+}
+
+/// Simple matching object names and patterns。
+pub fn match_simple(pattern_str: &str, object_name: &str) -> bool {
+    if pattern_str == "*" {
+        // AWS S3 docs: A single asterisk (*) in the rule matches all objects.
+        return true;
+    }
+    // WildMatch considers an empty pattern to not match anything, which is usually desired.
+    // If pattern_str is empty, it means no specific filter, so it depends on interpretation.
+    // Go's wildcard.MatchSimple might treat empty pattern differently.
+    // For now, assume empty pattern means no match unless it's explicitly "*".
+    if pattern_str.is_empty() {
+        return false; // Or true if an empty pattern means "match all" in some contexts.
+        // Given Go's NewRulesMap defaults to "*", an empty pattern from Filter is unlikely to mean "match all".
+    }
+    WildMatch::new(pattern_str).matches(object_name)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_new_pattern() {
+        assert_eq!(new_pattern(Some("images/"), Some(".jpg")), "images/*.jpg");
+        assert_eq!(new_pattern(Some("images/"), None), "images/*");
+        assert_eq!(new_pattern(None, Some(".jpg")), "*.jpg");
+        assert_eq!(new_pattern(Some("foo"), Some("bar")), "foo*bar"); // foo* + *bar -> foo**bar -> foo*bar
+        assert_eq!(new_pattern(Some("foo*"), Some("bar")), "foo*bar"); // foo* + *bar -> foo**bar -> foo*bar
+        assert_eq!(new_pattern(Some("foo"), Some("*bar")), "foo*bar"); // foo* + *bar -> foo**bar -> foo*bar
+        assert_eq!(new_pattern(Some("foo*"), Some("*bar")), "foo*bar"); // foo* + *bar -> foo**bar -> foo*bar
+        assert_eq!(new_pattern(Some("*"), Some("*")), "*"); // * + * -> ** -> *
+        assert_eq!(new_pattern(Some("a"), Some("")), "a*");
+        assert_eq!(new_pattern(Some(""), Some("b")), "*b");
+        assert_eq!(new_pattern(None, None), "");
+        assert_eq!(new_pattern(Some("prefix"), Some("suffix")), "prefix*suffix");
+        assert_eq!(new_pattern(Some("prefix/"), Some("/suffix")), "prefix/*suffix"); // prefix/* + */suffix -> prefix/**/suffix -> prefix/*/suffix
+    }
+
+    #[test]
+    fn test_match_simple() {
+        assert!(match_simple("foo*", "foobar"));
+        assert!(!match_simple("foo*", "barfoo"));
+        assert!(match_simple("*.jpg", "photo.jpg"));
+        assert!(!match_simple("*.jpg", "photo.png"));
+        assert!(match_simple("*", "anything.anything"));
+        assert!(match_simple("foo*bar", "foobazbar"));
+        assert!(!match_simple("foo*bar", "foobar_baz"));
+        assert!(match_simple("a*b*c", "axbyc"));
+        assert!(!match_simple("a*b*c", "axbc"));
+    }
+}
diff --git a/crates/notify/src/rules/pattern_rules.rs b/crates/notify/src/rules/pattern_rules.rs
new file mode 100644
index 00000000..b720e0f7
--- /dev/null
+++ b/crates/notify/src/rules/pattern_rules.rs
@@ -0,0 +1,75 @@
+use super::pattern;
+use super::target_id_set::TargetIdSet;
+use crate::arn::TargetID;
+use std::collections::HashMap;
+
+/// PatternRules - Event rule that maps object name patterns to TargetID collections.
+/// `event.Rules` (map[string]TargetIDSet) in the Go code
+#[derive(Debug, Clone, Default)]
+pub struct PatternRules {
+    pub(crate) rules: HashMap<String, TargetIdSet>,
+}
+
+impl PatternRules {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Add rules: Pattern and Target ID.
+    /// If the schema already exists, add target_id to the existing TargetIdSet.
+    pub fn add(&mut self, pattern: String, target_id: TargetID) {
+        self.rules.entry(pattern).or_default().insert(target_id);
+    }
+
+    /// Checks if there are any rules that match the given object name.
+    pub fn match_simple(&self, object_name: &str) -> bool {
+        self.rules.keys().any(|p| pattern::match_simple(p, object_name))
+    }
+
+    /// Returns all TargetIDs that match the object name.
+    pub fn match_targets(&self, object_name: &str) -> TargetIdSet {
+        let mut matched_targets = TargetIdSet::new();
+        for (pattern_str, target_set) in &self.rules {
+            if pattern::match_simple(pattern_str, object_name) {
+                matched_targets.extend(target_set.iter().cloned());
+            }
+        }
+        matched_targets
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.rules.is_empty()
+    }
+
+    /// Merge another PatternRules.
+    /// Corresponding to Go's `Rules.Union`.
+    pub fn union(&self, other: &Self) -> Self {
+        let mut new_rules = self.clone();
+        for (pattern, their_targets) in &other.rules {
+            let our_targets = new_rules.rules.entry(pattern.clone()).or_default();
+            our_targets.extend(their_targets.iter().cloned());
+        }
+        new_rules
+    }
+
+    /// Calculate the difference from another PatternRules.
+    /// Corresponding to Go's `Rules.Difference`.
+    pub fn difference(&self, other: &Self) -> Self {
+        let mut result_rules = HashMap::new();
+        for (pattern, self_targets) in &self.rules {
+            match other.rules.get(pattern) {
+                Some(other_targets) => {
+                    let diff_targets: TargetIdSet = self_targets.difference(other_targets).cloned().collect();
+                    if !diff_targets.is_empty() {
+                        result_rules.insert(pattern.clone(), diff_targets);
+                    }
+                }
+                None => {
+                    // If there is no pattern in other, self_targets are all retained
+                    result_rules.insert(pattern.clone(), self_targets.clone());
+                }
+            }
+        }
+        PatternRules { rules: result_rules }
+    }
+}
diff --git a/crates/notify/src/rules/rules_map.rs b/crates/notify/src/rules/rules_map.rs
new file mode 100644
index 00000000..86ac2172
--- /dev/null
+++ b/crates/notify/src/rules/rules_map.rs
@@ -0,0 +1,174 @@
+use super::pattern_rules::PatternRules;
+use super::target_id_set::TargetIdSet;
+use crate::arn::TargetID;
+use crate::event::EventName;
+use std::collections::HashMap;
+
+/// RulesMap - Rule mapping organized by event name。
+/// `event.RulesMap` (map[Name]Rules) in the corresponding Go code
+#[derive(Debug, Clone, Default)]
+pub struct RulesMap {
+    map: HashMap<EventName, PatternRules>,
+    /// A bitmask that represents the union of all event types in this map.
+    /// Used for quick checks in `has_subscriber`.
+    total_events_mask: u64,
+}
+
+impl RulesMap {
+    /// Create a new, empty RulesMap.
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Add a rule configuration to the map.
+    ///
+    /// This method handles composite event names (such as `s3:ObjectCreated:*`), expanding them as
+    /// Multiple specific event types and add rules for each event type.
+    ///
+    /// # Parameters
+    /// * `event_names` - List of event names associated with this rule.
+    /// * `pattern` - Matching pattern for object keys. If empty, the default is `*` (match all).
+    /// * `target_id` - The target ID of the notification.
+    pub fn add_rule_config(&mut self, event_names: &[EventName], pattern: String, target_id: TargetID) {
+        let effective_pattern = if pattern.is_empty() {
+            "*".to_string() // Match all by default
+        } else {
+            pattern
+        };
+
+        for event_name_spec in event_names {
+            // Expand compound event types, for example ObjectCreatedAll -> [ObjectCreatedPut, ObjectCreatedPost, ...]
+            for expanded_event_name in event_name_spec.expand() {
+                // Make sure EventName::expand() returns Vec<EventName>
+                self.map
+                    .entry(expanded_event_name)
+                    .or_default()
+                    .add(effective_pattern.clone(), target_id.clone());
+                // Update the total_events_mask to include this event type
+                self.total_events_mask |= expanded_event_name.mask();
+            }
+        }
+    }
+
+    /// Merge another RulesMap.
+    /// `RulesMap.Add(rulesMap2 RulesMap) corresponding to Go
+    pub fn add_map(&mut self, other_map: &Self) {
+        for (event_name, other_pattern_rules) in &other_map.map {
+            let self_pattern_rules = self.map.entry(*event_name).or_default();
+            // PatternRules::union Returns the new PatternRules, we need to modify the existing ones
+            let merged_rules = self_pattern_rules.union(other_pattern_rules);
+            *self_pattern_rules = merged_rules;
+        }
+        // Directly merge two masks.
+        self.total_events_mask |= other_map.total_events_mask;
+    }
+
+    /// Remove another rule defined in the RulesMap from the current RulesMap.
+    ///
+    /// After the rule is removed, `total_events_mask` is recalculated to ensure its accuracy.
+    pub fn remove_map(&mut self, other_map: &Self) {
+        let mut events_to_remove = Vec::new();
+        for (event_name, self_pattern_rules) in &mut self.map {
+            if let Some(other_pattern_rules) = other_map.map.get(event_name) {
+                *self_pattern_rules = self_pattern_rules.difference(other_pattern_rules);
+                if self_pattern_rules.is_empty() {
+                    events_to_remove.push(*event_name);
+                }
+            }
+        }
+        for event_name in events_to_remove {
+            self.map.remove(&event_name);
+        }
+        // After removing the rule, recalculate total_events_mask.
+        self.recalculate_mask();
+    }
+
+    /// Checks whether any configured rules exist for a given event type.
+    ///
+    /// This method uses a bitmask for a quick check of O(1) complexity.
+    /// `event_name` can be a compound type, such as `ObjectCreatedAll`.
+    pub fn has_subscriber(&self, event_name: &EventName) -> bool {
+        // event_name.mask() will handle compound events correctly
+        (self.total_events_mask & event_name.mask()) != 0
+    }
+
+    /// Rules matching the given event and object keys and return all matching target IDs.
+    ///
+    /// # Notice
+    /// The `event_name` parameter should be a specific, non-compound event type.
+    /// Because this is taken from the `Event` object that actually occurs.
+    pub fn match_rules(&self, event_name: EventName, object_key: &str) -> TargetIdSet {
+        // Use bitmask to quickly determine whether there is a matching rule
+        if (self.total_events_mask & event_name.mask()) == 0 {
+            return TargetIdSet::new(); // No matching rules
+        }
+
+        // First try to directly match the event name
+        if let Some(pattern_rules) = self.map.get(&event_name) {
+            let targets = pattern_rules.match_targets(object_key);
+            if !targets.is_empty() {
+                return targets;
+            }
+        }
+        // Go's RulesMap[eventName] is directly retrieved, and if it does not exist, it is empty Rules.
+        // Rust's HashMap::get returns Option. If the event name does not exist, there is no rule.
+        // Compound events (such as ObjectCreatedAll) have been expanded as a single event when add_rule_config.
+        // Therefore, a single event name should be used when querying.
+        // If event_name itself is a single type, look it up directly.
+        // If event_name is a compound type, Go's logic is expanded when added.
+        // Here match_rules should receive events that may already be single.
+        // If the caller passes in a compound event, it should expand itself or handle this function first.
+        // Assume that event_name is already a specific event that can be used for searching.
+        self.map
+            .get(&event_name)
+            .map_or_else(TargetIdSet::new, |pr| pr.match_targets(object_key))
+    }
+
+    /// Check if RulesMap is empty.
+    pub fn is_empty(&self) -> bool {
+        self.map.is_empty()
+    }
+
+    /// Returns a clone of internal rules for use in scenarios such as BucketNotificationConfig::validate.
+    pub fn inner(&self) -> &HashMap<EventName, PatternRules> {
+        &self.map
+    }
+
+    /// A private helper function that recalculates `total_events_mask` based on the content of the current `map`.
+    /// Called after the removal operation to ensure the accuracy of the mask.
+    fn recalculate_mask(&mut self) {
+        let mut new_mask = 0u64;
+        for event_name in self.map.keys() {
+            new_mask |= event_name.mask();
+        }
+        self.total_events_mask = new_mask;
+    }
+
+    /// Remove rules and optimize performance
+    #[allow(dead_code)]
+    pub fn remove_rule(&mut self, event_name: &EventName, pattern: &str) {
+        if let Some(pattern_rules) = self.map.get_mut(event_name) {
+            pattern_rules.rules.remove(pattern);
+            if pattern_rules.is_empty() {
+                self.map.remove(event_name);
+            }
+        }
+        self.recalculate_mask(); // Delay calculation mask
+    }
+
+    /// Batch Delete Rules
+    #[allow(dead_code)]
+    pub fn remove_rules(&mut self, event_names: &[EventName]) {
+        for event_name in event_names {
+            self.map.remove(event_name);
+        }
+        self.recalculate_mask(); // Unified calculation of mask after batch processing
+    }
+
+    /// Update rules and optimize performance
+    #[allow(dead_code)]
+    pub fn update_rule(&mut self, event_name: EventName, pattern: String, target_id: TargetID) {
+        self.map.entry(event_name).or_default().add(pattern, target_id);
+        self.total_events_mask |= event_name.mask(); // Update only the relevant bitmask
+    }
+}
diff --git a/crates/notify/src/rules/target_id_set.rs b/crates/notify/src/rules/target_id_set.rs
new file mode 100644
index 00000000..4f3a7b19
--- /dev/null
+++ b/crates/notify/src/rules/target_id_set.rs
@@ -0,0 +1,15 @@
+use crate::arn::TargetID;
+use std::collections::HashSet;
+
+/// TargetIDSet - A collection representation of TargetID.
+pub type TargetIdSet = HashSet<TargetID>;
+
+/// Provides a Go-like method for TargetIdSet (can be implemented as trait if needed)
+#[allow(dead_code)]
+pub(crate) fn new_target_id_set(target_ids: Vec<TargetID>) -> TargetIdSet {
+    target_ids.into_iter().collect()
+}
+
+// HashSet has built-in clone, union, difference and other operations.
+// But the Go version of the method returns a new Set, and the HashSet method is usually iterator or modify itself.
+// If you need to exactly match Go's API style, you can add wrapper functions.
diff --git a/crates/notify/src/rules/xml_config.rs b/crates/notify/src/rules/xml_config.rs
new file mode 100644
index 00000000..ea995ca9
--- /dev/null
+++ b/crates/notify/src/rules/xml_config.rs
@@ -0,0 +1,274 @@
+use super::pattern;
+use crate::arn::{ARN, ArnError, TargetIDError};
+use crate::event::EventName;
+use serde::{Deserialize, Serialize};
+use std::collections::HashSet;
+use std::io::Read;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum ParseConfigError {
+    #[error("XML parsing error:{0}")]
+    XmlError(#[from] quick_xml::errors::serialize::DeError),
+    #[error("Invalid filter value:{0}")]
+    InvalidFilterValue(String),
+    #[error("Invalid filter name: {0}, only 'prefix' or 'suffix' is allowed")]
+    InvalidFilterName(String),
+    #[error("There can only be one 'prefix' in the filter rule")]
+    DuplicatePrefixFilter,
+    #[error("There can only be one 'suffix' in the filter rule")]
+    DuplicateSuffixFilter,
+    #[error("Missing event name")]
+    MissingEventName,
+    #[error("Duplicate event name:{0}")]
+    DuplicateEventName(String), // EventName is usually an enum, and here String is used to represent its text
+    #[error("Repeated queue configuration: ID={0:?}, ARN={1}")]
+    DuplicateQueueConfiguration(Option<String>, String),
+    #[error("Unsupported configuration types (e.g. Lambda, Topic)")]
+    UnsupportedConfiguration,
+    #[error("ARN not found:{0}")]
+    ArnNotFound(String),
+    #[error("Unknown area:{0}")]
+    UnknownRegion(String),
+    #[error("ARN parsing error:{0}")]
+    ArnParseError(#[from] ArnError),
+    #[error("TargetID parsing error:{0}")]
+    TargetIDParseError(#[from] TargetIDError),
+    #[error("IO Error:{0}")]
+    IoError(#[from] std::io::Error),
+    #[error("Region mismatch: Configure region {config_region}, current region {current_region}")]
+    RegionMismatch { config_region: String, current_region: String },
+    #[error("ARN {0} Not found in the provided list")]
+    ArnValidation(String),
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+pub struct FilterRule {
+    #[serde(rename = "Name")]
+    pub name: String,
+    #[serde(rename = "Value")]
+    pub value: String,
+}
+
+impl FilterRule {
+    fn validate(&self) -> Result<(), ParseConfigError> {
+        if self.name != "prefix" && self.name != "suffix" {
+            return Err(ParseConfigError::InvalidFilterName(self.name.clone()));
+        }
+        // ValidateFilterRuleValue from Go:
+        // no "." or ".." path segments, <= 1024 chars, valid UTF-8, no '\'.
+        for segment in self.value.split('/') {
+            if segment == "." || segment == ".." {
+                return Err(ParseConfigError::InvalidFilterValue(self.value.clone()));
+            }
+        }
+        if self.value.len() > 1024 || self.value.contains('\\') || std::str::from_utf8(self.value.as_bytes()).is_err() {
+            return Err(ParseConfigError::InvalidFilterValue(self.value.clone()));
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, Default, PartialEq, Eq)]
+pub struct FilterRuleList {
+    #[serde(rename = "FilterRule", default, skip_serializing_if = "Vec::is_empty")]
+    pub rules: Vec<FilterRule>,
+}
+
+impl FilterRuleList {
+    pub fn validate(&self) -> Result<(), ParseConfigError> {
+        let mut has_prefix = false;
+        let mut has_suffix = false;
+        for rule in &self.rules {
+            rule.validate()?;
+            if rule.name == "prefix" {
+                if has_prefix {
+                    return Err(ParseConfigError::DuplicatePrefixFilter);
+                }
+                has_prefix = true;
+            } else if rule.name == "suffix" {
+                if has_suffix {
+                    return Err(ParseConfigError::DuplicateSuffixFilter);
+                }
+                has_suffix = true;
+            }
+        }
+        Ok(())
+    }
+
+    pub fn pattern(&self) -> String {
+        let mut prefix_val: Option<&str> = None;
+        let mut suffix_val: Option<&str> = None;
+
+        for rule in &self.rules {
+            if rule.name == "prefix" {
+                prefix_val = Some(&rule.value);
+            } else if rule.name == "suffix" {
+                suffix_val = Some(&rule.value);
+            }
+        }
+        pattern::new_pattern(prefix_val, suffix_val)
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.rules.is_empty()
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, Default, PartialEq, Eq)]
+pub struct S3KeyFilter {
+    #[serde(rename = "FilterRuleList", default, skip_serializing_if = "FilterRuleList::is_empty")]
+    pub filter_rule_list: FilterRuleList,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+pub struct QueueConfig {
+    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "Queue")] // This is ARN in XML
+    pub arn: ARN,
+    #[serde(rename = "Event", default)] // XML has multiple <Event> tags
+    pub events: Vec<EventName>, // EventName needs to handle XML (de)serialization if not string
+    #[serde(rename = "Filter", default, skip_serializing_if = "s3key_filter_is_empty")]
+    pub filter: S3KeyFilter,
+}
+
+fn s3key_filter_is_empty(f: &S3KeyFilter) -> bool {
+    f.filter_rule_list.is_empty()
+}
+
+impl QueueConfig {
+    pub fn validate(&self, region: &str, arn_list: &[String]) -> Result<(), ParseConfigError> {
+        if self.events.is_empty() {
+            return Err(ParseConfigError::MissingEventName);
+        }
+        let mut event_set = HashSet::new();
+        for event in &self.events {
+            // EventName::to_string() or similar for uniqueness check
+            if !event_set.insert(event.to_string()) {
+                return Err(ParseConfigError::DuplicateEventName(event.to_string()));
+            }
+        }
+        self.filter.filter_rule_list.validate()?;
+
+        // Validate ARN (similar to Go's Queue.Validate)
+        // The Go code checks targetList.Exists(q.ARN.TargetID)
+        // Here we check against a provided arn_list
+        let _config_arn_str = self.arn.to_arn_string();
+        if !self.arn.region.is_empty() && self.arn.region != region {
+            return Err(ParseConfigError::UnknownRegion(self.arn.region.clone()));
+        }
+
+        // Construct the ARN string that would be in arn_list
+        // The arn_list contains ARNs like "arn:rustfs:sqs:REGION:ID:NAME"
+        // We need to ensure self.arn (potentially with region adjusted) is in arn_list
+        let effective_arn = ARN {
+            target_id: self.arn.target_id.clone(),
+            region: if self.arn.region.is_empty() {
+                region.to_string()
+            } else {
+                self.arn.region.clone()
+            },
+            service: self.arn.service.clone(),     // or default "sqs"
+            partition: self.arn.partition.clone(), // or default "rustfs"
+        };
+
+        if !arn_list.contains(&effective_arn.to_arn_string()) {
+            return Err(ParseConfigError::ArnNotFound(effective_arn.to_arn_string()));
+        }
+        Ok(())
+    }
+
+    /// Sets the region if it's not already set in the ARN.
+    pub fn set_region_if_empty(&mut self, region: &str) {
+        if self.arn.region.is_empty() {
+            self.arn.region = region.to_string();
+        }
+    }
+}
+
+/// Corresponding to the `lambda` structure in the Go code.
+/// Used to parse <CloudFunction> ARN from inside the <CloudFunctionConfiguration> tag.
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Default)]
+pub struct LambdaConfigDetail {
+    #[serde(rename = "CloudFunction")]
+    pub arn: String,
+    // According to AWS S3 documentation, <CloudFunctionConfiguration> usually also contains Id, Event, Filter
+    // But in order to strictly correspond to the Go `lambda` structure provided, only ARN is included here.
+    // If full support is required, additional fields can be added.
+    // For example:
+    // #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
+    // pub id: Option<String>,
+    // #[serde(rename = "Event", default, skip_serializing_if = "Vec::is_empty")]
+    // pub events: Vec<EventName>,
+    // #[serde(rename = "Filter", default, skip_serializing_if = "S3KeyFilterIsEmpty")]
+    // pub filter: S3KeyFilter,
+}
+
+/// Corresponding to the `topic` structure in the Go code.
+/// Used to parse <Topic> ARN from inside the <TopicConfiguration> tag.
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Default)]
+pub struct TopicConfigDetail {
+    #[serde(rename = "Topic")]
+    pub arn: String,
+    // Similar to LambdaConfigDetail, it can be extended to include fields such as Id, Event, Filter, etc.
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, Default, PartialEq, Eq)]
+#[serde(rename = "NotificationConfiguration")]
+pub struct NotificationConfiguration {
+    #[serde(rename = "xmlns", skip_serializing_if = "Option::is_none")]
+    pub xmlns: Option<String>,
+    #[serde(rename = "QueueConfiguration", default, skip_serializing_if = "Vec::is_empty")]
+    pub queue_list: Vec<QueueConfig>,
+    #[serde(
+        rename = "CloudFunctionConfiguration", // Tags for each lambda configuration item in XML
+        default,
+        skip_serializing_if = "Vec::is_empty"
+    )]
+    pub lambda_list: Vec<LambdaConfigDetail>, // Modify: Use a new structure
+    #[serde(
+        rename = "TopicConfiguration", // Tags for each topic configuration item in XML
+        default,
+        skip_serializing_if = "Vec::is_empty"
+    )]
+    pub topic_list: Vec<TopicConfigDetail>, // Modify: Use a new structure
+}
+
+impl NotificationConfiguration {
+    pub fn from_reader<R: Read + std::io::BufRead>(reader: R) -> Result<Self, ParseConfigError> {
+        let config: NotificationConfiguration = quick_xml::de::from_reader(reader)?;
+        Ok(config)
+    }
+
+    pub fn validate(&self, current_region: &str, arn_list: &[String]) -> Result<(), ParseConfigError> {
+        // Verification logic remains the same: if lambda_list or topic_list is not empty, it is considered an unsupported configuration
+        if !self.lambda_list.is_empty() || !self.topic_list.is_empty() {
+            return Err(ParseConfigError::UnsupportedConfiguration);
+        }
+
+        let mut unique_queues = HashSet::new();
+        for queue_config in &self.queue_list {
+            queue_config.validate(current_region, arn_list)?;
+            let queue_key = (
+                queue_config.id.clone(),
+                queue_config.arn.to_arn_string(), // Assuming that the ARN structure implements Display or ToString
+            );
+            if !unique_queues.insert(queue_key.clone()) {
+                return Err(ParseConfigError::DuplicateQueueConfiguration(queue_key.0, queue_key.1));
+            }
+        }
+        Ok(())
+    }
+
+    pub fn set_defaults(&mut self, region: &str) {
+        for queue_config in &mut self.queue_list {
+            queue_config.set_region_if_empty(region);
+        }
+        if self.xmlns.is_none() {
+            self.xmlns = Some("http://s3.amazonaws.com/doc/2006-03-01/".to_string());
+        }
+        // Note: If LambdaConfigDetail and TopicConfigDetail contain information such as regions in the future,
+        // You may also need to set the default value here. But according to the current definition, they only contain ARN strings.
+    }
+}
diff --git a/crates/notify/src/store.rs b/crates/notify/src/store.rs
new file mode 100644
index 00000000..fde4776a
--- /dev/null
+++ b/crates/notify/src/store.rs
@@ -0,0 +1,483 @@
+use crate::error::StoreError;
+use serde::{Serialize, de::DeserializeOwned};
+use snap::raw::{Decoder, Encoder};
+use std::sync::{Arc, RwLock};
+use std::{
+    collections::HashMap,
+    marker::PhantomData,
+    path::PathBuf,
+    time::{SystemTime, UNIX_EPOCH},
+};
+use tracing::{debug, warn};
+use uuid::Uuid;
+
+pub const DEFAULT_LIMIT: u64 = 100000; // Default store limit
+pub const DEFAULT_EXT: &str = ".unknown"; // Default file extension
+pub const COMPRESS_EXT: &str = ".snappy"; // Extension for compressed files
+
+/// STORE_EXTENSION - file extension of an event file in store
+pub const STORE_EXTENSION: &str = ".event";
+
+/// Represents a key for an entry in the store
+#[derive(Debug, Clone)]
+pub struct Key {
+    /// The name of the key (UUID)
+    pub name: String,
+    /// The file extension for the entry
+    pub extension: String,
+    /// The number of items in the entry (for batch storage)
+    pub item_count: usize,
+    /// Whether the entry is compressed
+    pub compress: bool,
+}
+
+impl Key {
+    /// Converts the key to a string (filename)
+    pub fn to_key_string(&self) -> String {
+        let name_part = if self.item_count > 1 {
+            format!("{}:{}", self.item_count, self.name)
+        } else {
+            self.name.clone()
+        };
+
+        let mut file_name = name_part;
+        if !self.extension.is_empty() {
+            file_name.push_str(&self.extension);
+        }
+
+        if self.compress {
+            file_name.push_str(COMPRESS_EXT);
+        }
+        file_name
+    }
+}
+
+impl std::fmt::Display for Key {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let name_part = if self.item_count > 1 {
+            format!("{}:{}", self.item_count, self.name)
+        } else {
+            self.name.clone()
+        };
+
+        let mut file_name = name_part;
+        if !self.extension.is_empty() {
+            file_name.push_str(&self.extension);
+        }
+
+        if self.compress {
+            file_name.push_str(COMPRESS_EXT);
+        }
+        write!(f, "{}", file_name)
+    }
+}
+
+/// Parses a string into a Key
+pub fn parse_key(s: &str) -> Key {
+    debug!("Parsing key: {}", s);
+
+    let mut name = s.to_string();
+    let mut extension = String::new();
+    let mut item_count = 1;
+    let mut compress = false;
+
+    // Check for compressed suffixes
+    if name.ends_with(COMPRESS_EXT) {
+        compress = true;
+        name = name[..name.len() - COMPRESS_EXT.len()].to_string();
+    }
+
+    // Number of batch items parsed
+    if let Some(colon_pos) = name.find(':') {
+        if let Ok(count) = name[..colon_pos].parse::<usize>() {
+            item_count = count;
+            name = name[colon_pos + 1..].to_string();
+        }
+    }
+
+    // Resolve extension
+    if let Some(dot_pos) = name.rfind('.') {
+        extension = name[dot_pos..].to_string();
+        name = name[..dot_pos].to_string();
+    }
+
+    debug!(
+        "Parsed key - name: {}, extension: {}, item_count: {}, compress: {}",
+        name, extension, item_count, compress
+    );
+
+    Key {
+        name,
+        extension,
+        item_count,
+        compress,
+    }
+}
+
+/// Trait for a store that can store and retrieve items of type T
+pub trait Store<T>: Send + Sync {
+    /// The error type for the store
+    type Error;
+    /// The key type for the store
+    type Key;
+
+    /// Opens the store
+    fn open(&self) -> Result<(), Self::Error>;
+
+    /// Stores a single item
+    fn put(&self, item: Arc<T>) -> Result<Self::Key, Self::Error>;
+
+    /// Stores multiple items in a single batch
+    fn put_multiple(&self, items: Vec<T>) -> Result<Self::Key, Self::Error>;
+
+    /// Retrieves a single item by key
+    fn get(&self, key: &Self::Key) -> Result<T, Self::Error>;
+
+    /// Retrieves multiple items by key
+    fn get_multiple(&self, key: &Self::Key) -> Result<Vec<T>, Self::Error>;
+
+    /// Deletes an item by key
+    fn del(&self, key: &Self::Key) -> Result<(), Self::Error>;
+
+    /// Lists all keys in the store
+    fn list(&self) -> Vec<Self::Key>;
+
+    /// Returns the number of items in the store
+    fn len(&self) -> usize;
+
+    /// Returns true if the store is empty
+    fn is_empty(&self) -> bool;
+
+    /// Clones the store into a boxed trait object
+    fn boxed_clone(&self) -> Box<dyn Store<T, Error = Self::Error, Key = Self::Key> + Send + Sync>;
+}
+
+/// A store that uses the filesystem to persist events in a queue
+pub struct QueueStore<T> {
+    entry_limit: u64,
+    directory: PathBuf,
+    file_ext: String,
+    entries: Arc<RwLock<HashMap<String, i64>>>, // key -> modtime as unix nano
+    _phantom: PhantomData<T>,
+}
+
+impl<T> Clone for QueueStore<T> {
+    fn clone(&self) -> Self {
+        QueueStore {
+            entry_limit: self.entry_limit,
+            directory: self.directory.clone(),
+            file_ext: self.file_ext.clone(),
+            entries: Arc::clone(&self.entries),
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<T: Serialize + DeserializeOwned + Send + Sync> QueueStore<T> {
+    /// Creates a new QueueStore
+    pub fn new(directory: impl Into<PathBuf>, limit: u64, ext: &str) -> Self {
+        let file_ext = if ext.is_empty() { DEFAULT_EXT } else { ext };
+
+        QueueStore {
+            directory: directory.into(),
+            entry_limit: if limit == 0 { DEFAULT_LIMIT } else { limit },
+            file_ext: file_ext.to_string(),
+            entries: Arc::new(RwLock::new(HashMap::with_capacity(limit as usize))),
+            _phantom: PhantomData,
+        }
+    }
+
+    /// Returns the full path for a key
+    fn file_path(&self, key: &Key) -> PathBuf {
+        self.directory.join(key.to_string())
+    }
+
+    /// Reads a file for the given key
+    fn read_file(&self, key: &Key) -> Result<Vec<u8>, StoreError> {
+        let path = self.file_path(key);
+        debug!("Reading file for key: {},path: {}", key.to_string(), path.display());
+        let data = std::fs::read(&path).map_err(|e| {
+            if e.kind() == std::io::ErrorKind::NotFound {
+                StoreError::NotFound
+            } else {
+                StoreError::Io(e)
+            }
+        })?;
+
+        if data.is_empty() {
+            return Err(StoreError::NotFound);
+        }
+
+        if key.compress {
+            let mut decoder = Decoder::new();
+            decoder
+                .decompress_vec(&data)
+                .map_err(|e| StoreError::Compression(e.to_string()))
+        } else {
+            Ok(data)
+        }
+    }
+
+    /// Writes data to a file for the given key
+    fn write_file(&self, key: &Key, data: &[u8]) -> Result<(), StoreError> {
+        let path = self.file_path(key);
+        // Create directory if it doesn't exist
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent).map_err(StoreError::Io)?;
+        }
+
+        let data = if key.compress {
+            let mut encoder = Encoder::new();
+            encoder
+                .compress_vec(data)
+                .map_err(|e| StoreError::Compression(e.to_string()))?
+        } else {
+            data.to_vec()
+        };
+
+        std::fs::write(&path, &data).map_err(StoreError::Io)?;
+        let modified = SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_nanos() as i64;
+        let mut entries = self
+            .entries
+            .write()
+            .map_err(|_| StoreError::Internal("Failed to acquire write lock on entries".to_string()))?;
+        entries.insert(key.to_string(), modified);
+        debug!("Wrote event to store: {}", key.to_string());
+        Ok(())
+    }
+}
+
+impl<T> Store<T> for QueueStore<T>
+where
+    T: Serialize + DeserializeOwned + Clone + Send + Sync + 'static,
+{
+    type Error = StoreError;
+    type Key = Key;
+
+    fn open(&self) -> Result<(), Self::Error> {
+        std::fs::create_dir_all(&self.directory).map_err(StoreError::Io)?;
+
+        let entries = std::fs::read_dir(&self.directory).map_err(StoreError::Io)?;
+        // Get the write lock to update the internal state
+        let mut entries_map = self
+            .entries
+            .write()
+            .map_err(|_| StoreError::Internal("Failed to acquire write lock on entries".to_string()))?;
+        for entry in entries {
+            let entry = entry.map_err(StoreError::Io)?;
+            let metadata = entry.metadata().map_err(StoreError::Io)?;
+            if metadata.is_file() {
+                let modified = metadata.modified().map_err(StoreError::Io)?;
+                let unix_nano = modified.duration_since(UNIX_EPOCH).unwrap_or_default().as_nanos() as i64;
+
+                let file_name = entry.file_name().to_string_lossy().to_string();
+                entries_map.insert(file_name, unix_nano);
+            }
+        }
+
+        debug!("Opened store at: {:?}", self.directory);
+        Ok(())
+    }
+
+    fn put(&self, item: Arc<T>) -> Result<Self::Key, Self::Error> {
+        // Check storage limits
+        {
+            let entries = self
+                .entries
+                .read()
+                .map_err(|_| StoreError::Internal("Failed to acquire read lock on entries".to_string()))?;
+
+            if entries.len() as u64 >= self.entry_limit {
+                return Err(StoreError::LimitExceeded);
+            }
+        }
+
+        let uuid = Uuid::new_v4();
+        let key = Key {
+            name: uuid.to_string(),
+            extension: self.file_ext.clone(),
+            item_count: 1,
+            compress: true,
+        };
+
+        let data = serde_json::to_vec(&item).map_err(|e| StoreError::Serialization(e.to_string()))?;
+        self.write_file(&key, &data)?;
+
+        Ok(key)
+    }
+
+    fn put_multiple(&self, items: Vec<T>) -> Result<Self::Key, Self::Error> {
+        // Check storage limits
+        {
+            let entries = self
+                .entries
+                .read()
+                .map_err(|_| StoreError::Internal("Failed to acquire read lock on entries".to_string()))?;
+
+            if entries.len() as u64 >= self.entry_limit {
+                return Err(StoreError::LimitExceeded);
+            }
+        }
+        if items.is_empty() {
+            // Or return an error, or a special key?
+            return Err(StoreError::Internal("Cannot put_multiple with empty items list".to_string()));
+        }
+        let uuid = Uuid::new_v4();
+        let key = Key {
+            name: uuid.to_string(),
+            extension: self.file_ext.clone(),
+            item_count: items.len(),
+            compress: true,
+        };
+
+        // Serialize all items into a single Vec<u8>
+        // This current approach for get_multiple/put_multiple assumes items are concatenated JSON objects.
+        // This might be problematic for deserialization if not handled carefully.
+        // A better approach for multiple items might be to store them as a JSON array `Vec<T>`.
+        // For now, sticking to current logic of concatenating.
+        let mut buffer = Vec::new();
+        for item in items {
+            // If items are Vec<Event>, and Event is large, this could be inefficient.
+            // The current get_multiple deserializes one by one.
+            let item_data = serde_json::to_vec(&item).map_err(|e| StoreError::Serialization(e.to_string()))?;
+            buffer.extend_from_slice(&item_data);
+            // If using JSON array: buffer = serde_json::to_vec(&items)?
+        }
+
+        self.write_file(&key, &buffer)?;
+
+        Ok(key)
+    }
+
+    fn get(&self, key: &Self::Key) -> Result<T, Self::Error> {
+        if key.item_count != 1 {
+            return Err(StoreError::Internal(format!(
+                "get() called on a batch key ({} items), use get_multiple()",
+                key.item_count
+            )));
+        }
+        let items = self.get_multiple(key)?;
+        items.into_iter().next().ok_or(StoreError::NotFound)
+    }
+
+    fn get_multiple(&self, key: &Self::Key) -> Result<Vec<T>, Self::Error> {
+        debug!("Reading items from store for key: {}", key.to_string());
+        let data = self.read_file(key)?;
+        if data.is_empty() {
+            return Err(StoreError::Deserialization("Cannot deserialize empty data".to_string()));
+        }
+        let mut items = Vec::with_capacity(key.item_count);
+
+        // let mut deserializer = serde_json::Deserializer::from_slice(&data);
+        // while let Ok(item) = serde::Deserialize::deserialize(&mut deserializer) {
+        //     items.push(item);
+        // }
+
+        // This deserialization logic assumes multiple JSON objects are simply concatenated in the file.
+        // This is fragile. It's better to store a JSON array `[item1, item2, ...]`
+        // or use a streaming deserializer that can handle multiple top-level objects if that's the format.
+        // For now, assuming serde_json::Deserializer::from_slice can handle this if input is well-formed.
+        let mut deserializer = serde_json::Deserializer::from_slice(&data).into_iter::<T>();
+
+        for _ in 0..key.item_count {
+            match deserializer.next() {
+                Some(Ok(item)) => items.push(item),
+                Some(Err(e)) => {
+                    return Err(StoreError::Deserialization(format!("Failed to deserialize item in batch: {}", e)));
+                }
+                None => {
+                    // Reached end of stream sooner than item_count
+                    if items.len() < key.item_count && !items.is_empty() {
+                        // Partial read
+                        warn!(
+                            "Expected {} items for key {}, but only found {}. Possible data corruption or incorrect item_count.",
+                            key.item_count,
+                            key.to_string(),
+                            items.len()
+                        );
+                        // Depending on strictness, this could be an error.
+                    } else if items.is_empty() {
+                        // No items at all, but file existed
+                        return Err(StoreError::Deserialization(format!(
+                            "No items deserialized for key {} though file existed.",
+                            key
+                        )));
+                    }
+                    break;
+                }
+            }
+        }
+
+        if items.is_empty() && key.item_count > 0 {
+            return Err(StoreError::Deserialization("No items found".to_string()));
+        }
+
+        Ok(items)
+    }
+
+    fn del(&self, key: &Self::Key) -> Result<(), Self::Error> {
+        let path = self.file_path(key);
+        std::fs::remove_file(&path).map_err(|e| {
+            if e.kind() == std::io::ErrorKind::NotFound {
+                // If file not found, still try to remove from entries map in case of inconsistency
+                warn!(
+                    "File not found for key {} during del, but proceeding to remove from entries map.",
+                    key.to_string()
+                );
+                StoreError::NotFound
+            } else {
+                StoreError::Io(e)
+            }
+        })?;
+
+        // Get the write lock to update the internal state
+        let mut entries = self
+            .entries
+            .write()
+            .map_err(|_| StoreError::Internal("Failed to acquire write lock on entries".to_string()))?;
+
+        if entries.remove(&key.to_string()).is_none() {
+            // Key was not in the map, could be an inconsistency or already deleted.
+            // This is not necessarily an error if the file deletion succeeded or was NotFound.
+            debug!("Key {} not found in entries map during del, might have been already removed.", key);
+        }
+        debug!("Deleted event from store: {}", key.to_string());
+        Ok(())
+    }
+
+    fn list(&self) -> Vec<Self::Key> {
+        // Get the read lock to read the internal state
+        let entries = match self.entries.read() {
+            Ok(entries) => entries,
+            Err(_) => {
+                debug!("Failed to acquire read lock on entries for listing");
+                return Vec::new();
+            }
+        };
+
+        let mut entries_vec: Vec<_> = entries.iter().collect();
+        // Sort by modtime (value in HashMap) to process oldest first
+        entries_vec.sort_by(|a, b| a.1.cmp(b.1)); // Oldest first
+
+        entries_vec.into_iter().map(|(k, _)| parse_key(k)).collect()
+    }
+
+    fn len(&self) -> usize {
+        // Get the read lock to read the internal state
+        match self.entries.read() {
+            Ok(entries) => entries.len(),
+            Err(_) => {
+                debug!("Failed to acquire read lock on entries for len");
+                0
+            }
+        }
+    }
+
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    fn boxed_clone(&self) -> Box<dyn Store<T, Error = Self::Error, Key = Self::Key> + Send + Sync> {
+        Box::new(self.clone()) as Box<dyn Store<T, Error = Self::Error, Key = Self::Key> + Send + Sync>
+    }
+}
diff --git a/crates/notify/src/stream.rs b/crates/notify/src/stream.rs
new file mode 100644
index 00000000..f02001ce
--- /dev/null
+++ b/crates/notify/src/stream.rs
@@ -0,0 +1,295 @@
+use crate::{
+    Event, StoreError,
+    error::TargetError,
+    integration::NotificationMetrics,
+    store::{Key, Store},
+    target::Target,
+};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tokio::sync::{Semaphore, mpsc};
+use tokio::time::sleep;
+use tracing::{debug, error, info, warn};
+
+/// Streams events from the store to the target
+pub async fn stream_events(
+    store: &mut (dyn Store<Event, Error = StoreError, Key = Key> + Send),
+    target: &dyn Target,
+    mut cancel_rx: mpsc::Receiver<()>,
+) {
+    info!("Starting event stream for target: {}", target.name());
+
+    // Retry configuration
+    const MAX_RETRIES: usize = 5;
+    const RETRY_DELAY: Duration = Duration::from_secs(5);
+
+    loop {
+        // Check for cancellation signal
+        if cancel_rx.try_recv().is_ok() {
+            info!("Cancellation received for target: {}", target.name());
+            return;
+        }
+
+        // Get list of events in the store
+        let keys = store.list();
+        if keys.is_empty() {
+            // No events, wait before checking again
+            sleep(Duration::from_secs(1)).await;
+            continue;
+        }
+
+        // Process each event
+        for key in keys {
+            // Check for cancellation before processing each event
+            if cancel_rx.try_recv().is_ok() {
+                info!("Cancellation received during processing for target: {}", target.name());
+                return;
+            }
+
+            let mut retry_count = 0;
+            let mut success = false;
+
+            // Retry logic
+            while retry_count < MAX_RETRIES && !success {
+                match target.send_from_store(key.clone()).await {
+                    Ok(_) => {
+                        info!("Successfully sent event for target: {}", target.name());
+                        success = true;
+                    }
+                    Err(e) => {
+                        // Handle specific errors
+                        match &e {
+                            TargetError::NotConnected => {
+                                warn!("Target {} not connected, retrying...", target.name());
+                                retry_count += 1;
+                                sleep(RETRY_DELAY).await;
+                            }
+                            TargetError::Timeout(_) => {
+                                warn!("Timeout for target {}, retrying...", target.name());
+                                retry_count += 1;
+                                sleep(Duration::from_secs((retry_count * 5) as u64)).await; // Exponential backoff
+                            }
+                            _ => {
+                                // Permanent error, skip this event
+                                error!("Permanent error for target {}: {}", target.name(), e);
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Remove event from store if successfully sent
+            if retry_count >= MAX_RETRIES && !success {
+                warn!("Max retries exceeded for event {}, target: {}, skipping", key.to_string(), target.name());
+            }
+        }
+
+        // Small delay before next iteration
+        sleep(Duration::from_millis(100)).await;
+    }
+}
+
+/// Starts the event streaming process for a target
+pub fn start_event_stream(
+    mut store: Box<dyn Store<Event, Error = StoreError, Key = Key> + Send>,
+    target: Arc<dyn Target + Send + Sync>,
+) -> mpsc::Sender<()> {
+    let (cancel_tx, cancel_rx) = mpsc::channel(1);
+
+    tokio::spawn(async move {
+        stream_events(&mut *store, &*target, cancel_rx).await;
+        info!("Event stream stopped for target: {}", target.name());
+    });
+
+    cancel_tx
+}
+
+/// Start event stream with batch processing
+pub fn start_event_stream_with_batching(
+    mut store: Box<dyn Store<Event, Error = StoreError, Key = Key> + Send>,
+    target: Arc<dyn Target + Send + Sync>,
+    metrics: Arc<NotificationMetrics>,
+    semaphore: Arc<Semaphore>,
+) -> mpsc::Sender<()> {
+    let (cancel_tx, cancel_rx) = mpsc::channel(1);
+    debug!("Starting event stream with batching for target: {}", target.name());
+    tokio::spawn(async move {
+        stream_events_with_batching(&mut *store, &*target, cancel_rx, metrics, semaphore).await;
+        info!("Event stream stopped for target: {}", target.name());
+    });
+
+    cancel_tx
+}
+
+/// Event stream processing with batch processing
+pub async fn stream_events_with_batching(
+    store: &mut (dyn Store<Event, Error = StoreError, Key = Key> + Send),
+    target: &dyn Target,
+    mut cancel_rx: mpsc::Receiver<()>,
+    metrics: Arc<NotificationMetrics>,
+    semaphore: Arc<Semaphore>,
+) {
+    info!("Starting event stream with batching for target: {}", target.name());
+
+    // Configuration parameters
+    const DEFAULT_BATCH_SIZE: usize = 1;
+    let batch_size = std::env::var("RUSTFS_EVENT_BATCH_SIZE")
+        .ok()
+        .and_then(|s| s.parse::<usize>().ok())
+        .unwrap_or(DEFAULT_BATCH_SIZE);
+    const BATCH_TIMEOUT: Duration = Duration::from_secs(5);
+    const MAX_RETRIES: usize = 5;
+    const BASE_RETRY_DELAY: Duration = Duration::from_secs(2);
+
+    let mut batch = Vec::with_capacity(batch_size);
+    let mut batch_keys = Vec::with_capacity(batch_size);
+    let mut last_flush = Instant::now();
+
+    loop {
+        // Check the cancel signal
+        if cancel_rx.try_recv().is_ok() {
+            info!("Cancellation received for target: {}", target.name());
+            return;
+        }
+
+        // Get a list of events in storage
+        let keys = store.list();
+        debug!("Found {} keys in store for target: {}", keys.len(), target.name());
+        if keys.is_empty() {
+            // If there is data in the batch and timeout, refresh the batch
+            if !batch.is_empty() && last_flush.elapsed() >= BATCH_TIMEOUT {
+                process_batch(&mut batch, &mut batch_keys, target, MAX_RETRIES, BASE_RETRY_DELAY, &metrics, &semaphore).await;
+                last_flush = Instant::now();
+            }
+
+            // No event, wait before checking
+            tokio::time::sleep(Duration::from_millis(500)).await;
+            continue;
+        }
+
+        // Handle each event
+        for key in keys {
+            // Check the cancel signal again
+            if cancel_rx.try_recv().is_ok() {
+                info!("Cancellation received during processing for target: {}", target.name());
+
+                // Processing collected batches before exiting
+                if !batch.is_empty() {
+                    process_batch(&mut batch, &mut batch_keys, target, MAX_RETRIES, BASE_RETRY_DELAY, &metrics, &semaphore).await;
+                }
+                return;
+            }
+
+            // Try to get events from storage
+            match store.get(&key) {
+                Ok(event) => {
+                    // Add to batch
+                    batch.push(event);
+                    batch_keys.push(key);
+                    metrics.increment_processing();
+
+                    // If the batch is full or enough time has passed since the last refresh, the batch will be processed
+                    if batch.len() >= batch_size || last_flush.elapsed() >= BATCH_TIMEOUT {
+                        process_batch(&mut batch, &mut batch_keys, target, MAX_RETRIES, BASE_RETRY_DELAY, &metrics, &semaphore)
+                            .await;
+                        last_flush = Instant::now();
+                    }
+                }
+                Err(e) => {
+                    error!("Failed to target: {}, get event {} from store: {}", target.name(), key.to_string(), e);
+                    // Consider deleting unreadable events to prevent infinite loops from trying to read
+                    match store.del(&key) {
+                        Ok(_) => {
+                            info!("Deleted corrupted event {} from store", key.to_string());
+                        }
+                        Err(del_err) => {
+                            error!("Failed to delete corrupted event {}: {}", key.to_string(), del_err);
+                        }
+                    }
+
+                    metrics.increment_failed();
+                }
+            }
+        }
+
+        // A small delay will be conducted to check the next round
+        tokio::time::sleep(Duration::from_millis(100)).await;
+    }
+}
+
+/// Processing event batches
+async fn process_batch(
+    batch: &mut Vec<Event>,
+    batch_keys: &mut Vec<Key>,
+    target: &dyn Target,
+    max_retries: usize,
+    base_delay: Duration,
+    metrics: &Arc<NotificationMetrics>,
+    semaphore: &Arc<Semaphore>,
+) {
+    debug!("Processing batch of {} events for target: {}", batch.len(), target.name());
+    if batch.is_empty() {
+        return;
+    }
+
+    // Obtain semaphore permission to limit concurrency
+    let permit = match semaphore.clone().acquire_owned().await {
+        Ok(permit) => permit,
+        Err(e) => {
+            error!("Failed to acquire semaphore permit: {}", e);
+            return;
+        }
+    };
+
+    // Handle every event in the batch
+    for (_event, key) in batch.iter().zip(batch_keys.iter()) {
+        let mut retry_count = 0;
+        let mut success = false;
+
+        // Retry logic
+        while retry_count < max_retries && !success {
+            match target.send_from_store(key.clone()).await {
+                Ok(_) => {
+                    info!("Successfully sent event for target: {}, Key: {}", target.name(), key.to_string());
+                    success = true;
+                    metrics.increment_processed();
+                }
+                Err(e) => {
+                    // Different retry strategies are adopted according to the error type
+                    match &e {
+                        TargetError::NotConnected => {
+                            warn!("Target {} not connected, retrying...", target.name());
+                            retry_count += 1;
+                            tokio::time::sleep(base_delay * (1 << retry_count)).await; // Exponential backoff
+                        }
+                        TargetError::Timeout(_) => {
+                            warn!("Timeout for target {}, retrying...", target.name());
+                            retry_count += 1;
+                            tokio::time::sleep(base_delay * (1 << retry_count)).await;
+                        }
+                        _ => {
+                            // Permanent error, skip this event
+                            error!("Permanent error for target {}: {}", target.name(), e);
+                            metrics.increment_failed();
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Handle the situation where the maximum number of retry exhaustion is exhausted
+        if retry_count >= max_retries && !success {
+            warn!("Max retries exceeded for event {}, target: {}, skipping", key.to_string(), target.name());
+            metrics.increment_failed();
+        }
+    }
+
+    // Clear processed batches
+    batch.clear();
+    batch_keys.clear();
+
+    // Release semaphore permission (via drop)
+    drop(permit);
+}
diff --git a/crates/notify/src/target/mod.rs b/crates/notify/src/target/mod.rs
new file mode 100644
index 00000000..b4004280
--- /dev/null
+++ b/crates/notify/src/target/mod.rs
@@ -0,0 +1,97 @@
+use crate::arn::TargetID;
+use crate::store::{Key, Store};
+use crate::{Event, StoreError, TargetError};
+use async_trait::async_trait;
+use std::sync::Arc;
+
+pub mod mqtt;
+pub mod webhook;
+
+/// Trait for notification targets
+#[async_trait]
+pub trait Target: Send + Sync + 'static {
+    /// Returns the ID of the target
+    fn id(&self) -> TargetID;
+
+    /// Returns the name of the target
+    fn name(&self) -> String {
+        self.id().to_string()
+    }
+
+    /// Checks if the target is active and reachable
+    async fn is_active(&self) -> Result<bool, TargetError>;
+
+    /// Saves an event (either sends it immediately or stores it for later)
+    async fn save(&self, event: Arc<Event>) -> Result<(), TargetError>;
+
+    /// Sends an event from the store
+    async fn send_from_store(&self, key: Key) -> Result<(), TargetError>;
+
+    /// Closes the target and releases resources
+    async fn close(&self) -> Result<(), TargetError>;
+
+    /// Returns the store associated with the target (if any)
+    fn store(&self) -> Option<&(dyn Store<Event, Error = StoreError, Key = Key> + Send + Sync)>;
+
+    /// Returns the type of the target
+    fn clone_dyn(&self) -> Box<dyn Target + Send + Sync>;
+
+    /// Initialize the target, such as establishing a connection, etc.
+    async fn init(&self) -> Result<(), TargetError> {
+        // The default implementation is empty
+        Ok(())
+    }
+
+    /// Check if the target is enabled
+    fn is_enabled(&self) -> bool;
+}
+
+/// The `ChannelTargetType` enum represents the different types of channel Target
+/// used in the notification system.
+///
+/// It includes:
+/// - `Webhook`: Represents a webhook target for sending notifications via HTTP requests.
+/// - `Kafka`: Represents a Kafka target for sending notifications to a Kafka topic.
+/// - `Mqtt`: Represents an MQTT target for sending notifications via MQTT protocol.
+///
+/// Each variant has an associated string representation that can be used for serialization
+/// or logging purposes.
+/// The `as_str` method returns the string representation of the target type,
+/// and the `Display` implementation allows for easy formatting of the target type as a string.
+///
+/// example usage:
+/// ```rust
+/// use rustfs_notify::target::ChannelTargetType;
+///
+/// let target_type = ChannelTargetType::Webhook;
+/// assert_eq!(target_type.as_str(), "webhook");
+/// println!("Target type: {}", target_type);
+/// ```
+///
+/// example output:
+/// Target type: webhook
+pub enum ChannelTargetType {
+    Webhook,
+    Kafka,
+    Mqtt,
+}
+
+impl ChannelTargetType {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            ChannelTargetType::Webhook => "webhook",
+            ChannelTargetType::Kafka => "kafka",
+            ChannelTargetType::Mqtt => "mqtt",
+        }
+    }
+}
+
+impl std::fmt::Display for ChannelTargetType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ChannelTargetType::Webhook => write!(f, "webhook"),
+            ChannelTargetType::Kafka => write!(f, "kafka"),
+            ChannelTargetType::Mqtt => write!(f, "mqtt"),
+        }
+    }
+}
diff --git a/crates/notify/src/target/mqtt.rs b/crates/notify/src/target/mqtt.rs
new file mode 100644
index 00000000..f7b589ba
--- /dev/null
+++ b/crates/notify/src/target/mqtt.rs
@@ -0,0 +1,630 @@
+use crate::store::{Key, STORE_EXTENSION};
+use crate::target::ChannelTargetType;
+use crate::{
+    StoreError, Target,
+    arn::TargetID,
+    error::TargetError,
+    event::{Event, EventLog},
+    store::Store,
+};
+use async_trait::async_trait;
+use rumqttc::{AsyncClient, EventLoop, MqttOptions, Outgoing, Packet, QoS};
+use rumqttc::{ConnectionError, mqttbytes::Error as MqttBytesError};
+use std::sync::Arc;
+use std::{
+    path::PathBuf,
+    sync::atomic::{AtomicBool, Ordering},
+    time::Duration,
+};
+use tokio::sync::{Mutex, OnceCell, mpsc};
+use tracing::{debug, error, info, instrument, trace, warn};
+use url::Url;
+use urlencoding;
+
+const DEFAULT_CONNECTION_TIMEOUT: Duration = Duration::from_secs(15);
+const EVENT_LOOP_POLL_TIMEOUT: Duration = Duration::from_secs(10); // For initial connection check in task
+
+/// Arguments for configuring an MQTT target
+#[derive(Debug, Clone)]
+pub struct MQTTArgs {
+    /// Whether the target is enabled
+    pub enable: bool,
+    /// The broker URL
+    pub broker: Url,
+    /// The topic to publish to
+    pub topic: String,
+    /// The quality of service level
+    pub qos: QoS,
+    /// The username for the broker
+    pub username: String,
+    /// The password for the broker
+    pub password: String,
+    /// The maximum interval for reconnection attempts (Note: rumqttc has internal strategy)
+    pub max_reconnect_interval: Duration,
+    /// The keep alive interval
+    pub keep_alive: Duration,
+    /// The directory to store events in case of failure
+    pub queue_dir: String,
+    /// The maximum number of events to store
+    pub queue_limit: u64,
+}
+
+impl MQTTArgs {
+    pub fn validate(&self) -> Result<(), TargetError> {
+        if !self.enable {
+            return Ok(());
+        }
+
+        match self.broker.scheme() {
+            "ws" | "wss" | "tcp" | "ssl" | "tls" | "tcps" | "mqtt" | "mqtts" => {}
+            _ => {
+                return Err(TargetError::Configuration("unknown protocol in broker address".to_string()));
+            }
+        }
+
+        if !self.queue_dir.is_empty() {
+            let path = std::path::Path::new(&self.queue_dir);
+            if !path.is_absolute() {
+                return Err(TargetError::Configuration("mqtt queueDir path should be absolute".to_string()));
+            }
+
+            if self.qos == QoS::AtMostOnce {
+                return Err(TargetError::Configuration(
+                    "QoS should be AtLeastOnce (1) or ExactlyOnce (2) if queueDir is set".to_string(),
+                ));
+            }
+        }
+        Ok(())
+    }
+}
+
+struct BgTaskManager {
+    init_cell: OnceCell<tokio::task::JoinHandle<()>>,
+    cancel_tx: mpsc::Sender<()>,
+    initial_cancel_rx: Mutex<Option<mpsc::Receiver<()>>>,
+}
+
+/// A target that sends events to an MQTT broker
+pub struct MQTTTarget {
+    id: TargetID,
+    args: MQTTArgs,
+    client: Arc<Mutex<Option<AsyncClient>>>,
+    store: Option<Box<dyn Store<Event, Error = StoreError, Key = Key> + Send + Sync>>,
+    connected: Arc<AtomicBool>,
+    bg_task_manager: Arc<BgTaskManager>,
+}
+
+impl MQTTTarget {
+    /// Creates a new MQTTTarget
+    #[instrument(skip(args), fields(target_id_as_string = %id))]
+    pub fn new(id: String, args: MQTTArgs) -> Result<Self, TargetError> {
+        args.validate()?;
+        let target_id = TargetID::new(id.clone(), ChannelTargetType::Mqtt.as_str().to_string());
+        let queue_store = if !args.queue_dir.is_empty() {
+            let base_path = PathBuf::from(&args.queue_dir);
+            let unique_dir_name =
+                format!("rustfs-{}-{}-{}", ChannelTargetType::Mqtt.as_str(), target_id.name, target_id.id).replace(":", "_");
+            // Ensure the directory name is valid for filesystem
+            let specific_queue_path = base_path.join(unique_dir_name);
+            debug!(target_id = %target_id, path = %specific_queue_path.display(), "Initializing queue store for MQTT target");
+            let store = crate::store::QueueStore::<Event>::new(specific_queue_path, args.queue_limit, STORE_EXTENSION);
+            if let Err(e) = store.open() {
+                error!(
+                    target_id = %target_id,
+                    error = %e,
+                    "Failed to open store for MQTT target"
+                );
+                return Err(TargetError::Storage(format!("{}", e)));
+            }
+            Some(Box::new(store) as Box<dyn Store<Event, Error = StoreError, Key = Key> + Send + Sync>)
+        } else {
+            None
+        };
+
+        let (cancel_tx, cancel_rx) = mpsc::channel(1);
+        let bg_task_manager = Arc::new(BgTaskManager {
+            init_cell: OnceCell::new(),
+            cancel_tx,
+            initial_cancel_rx: Mutex::new(Some(cancel_rx)),
+        });
+
+        info!(target_id = %target_id, "MQTT target created");
+        Ok(MQTTTarget {
+            id: target_id,
+            args,
+            client: Arc::new(Mutex::new(None)),
+            store: queue_store,
+            connected: Arc::new(AtomicBool::new(false)),
+            bg_task_manager,
+        })
+    }
+
+    #[instrument(skip(self), fields(target_id = %self.id))]
+    async fn init(&self) -> Result<(), TargetError> {
+        if self.connected.load(Ordering::SeqCst) {
+            debug!(target_id = %self.id, "Already connected.");
+            return Ok(());
+        }
+
+        let bg_task_manager = Arc::clone(&self.bg_task_manager);
+        let client_arc = Arc::clone(&self.client);
+        let connected_arc = Arc::clone(&self.connected);
+        let target_id_clone = self.id.clone();
+        let args_clone = self.args.clone();
+
+        let _ = bg_task_manager
+            .init_cell
+            .get_or_try_init(|| async {
+                debug!(target_id = %target_id_clone, "Initializing MQTT background task.");
+                let host = args_clone.broker.host_str().unwrap_or("localhost");
+                let port = args_clone.broker.port().unwrap_or(1883);
+                let mut mqtt_options = MqttOptions::new(format!("rustfs_notify_{}", uuid::Uuid::new_v4()), host, port);
+                mqtt_options
+                    .set_keep_alive(args_clone.keep_alive)
+                    .set_max_packet_size(100 * 1024 * 1024, 100 * 1024 * 1024); // 100MB
+
+                if !args_clone.username.is_empty() {
+                    mqtt_options.set_credentials(args_clone.username.clone(), args_clone.password.clone());
+                }
+
+                let (new_client, eventloop) = AsyncClient::new(mqtt_options, 10);
+
+                if let Err(e) = new_client.subscribe(&args_clone.topic, args_clone.qos).await {
+                    error!(target_id = %target_id_clone, error = %e, "Failed to subscribe to MQTT topic during init");
+                    return Err(TargetError::Network(format!("MQTT subscribe failed: {}", e)));
+                }
+
+                let mut rx_guard = bg_task_manager.initial_cancel_rx.lock().await;
+                let cancel_rx = rx_guard.take().ok_or_else(|| {
+                    error!(target_id = %target_id_clone, "MQTT cancel receiver already taken for task.");
+                    TargetError::Configuration("MQTT cancel receiver already taken for task".to_string())
+                })?;
+                drop(rx_guard);
+
+                *client_arc.lock().await = Some(new_client.clone());
+
+                info!(target_id = %target_id_clone, "Spawning MQTT event loop task.");
+                let task_handle =
+                    tokio::spawn(run_mqtt_event_loop(eventloop, connected_arc.clone(), target_id_clone.clone(), cancel_rx));
+                Ok(task_handle)
+            })
+            .await
+            .map_err(|e: TargetError| {
+                error!(target_id = %self.id, error = %e, "Failed to initialize MQTT background task");
+                e
+            })?;
+        debug!(target_id = %self.id, "MQTT background task initialized successfully.");
+
+        match tokio::time::timeout(DEFAULT_CONNECTION_TIMEOUT, async {
+            while !self.connected.load(Ordering::SeqCst) {
+                if let Some(handle) = self.bg_task_manager.init_cell.get() {
+                    if handle.is_finished() && !self.connected.load(Ordering::SeqCst) {
+                        error!(target_id = %self.id, "MQTT background task exited prematurely before connection was established.");
+                        return Err(TargetError::Network("MQTT background task exited prematurely".to_string()));
+                    }
+                }
+                tokio::time::sleep(Duration::from_millis(100)).await;
+            }
+            debug!(target_id = %self.id, "MQTT target connected successfully.");
+            Ok(())
+        }).await {
+            Ok(Ok(_)) => {
+                info!(target_id = %self.id, "MQTT target initialized and connected.");
+                Ok(())
+            }
+            Ok(Err(e)) => Err(e),
+            Err(_) => {
+                error!(target_id = %self.id, "Timeout waiting for MQTT connection after task spawn.");
+                Err(TargetError::Network(
+                    "Timeout waiting for MQTT connection".to_string(),
+                ))
+            }
+        }
+    }
+
+    #[instrument(skip(self, event), fields(target_id = %self.id))]
+    async fn send(&self, event: &Event) -> Result<(), TargetError> {
+        let client_guard = self.client.lock().await;
+        let client = client_guard
+            .as_ref()
+            .ok_or_else(|| TargetError::Configuration("MQTT client not initialized".to_string()))?;
+
+        let object_name = urlencoding::decode(&event.s3.object.key)
+            .map_err(|e| TargetError::Encoding(format!("Failed to decode object key: {}", e)))?;
+
+        let key = format!("{}/{}", event.s3.bucket.name, object_name);
+
+        let log = EventLog {
+            event_name: event.event_name,
+            key,
+            records: vec![event.clone()],
+        };
+
+        let data =
+            serde_json::to_vec(&log).map_err(|e| TargetError::Serialization(format!("Failed to serialize event: {}", e)))?;
+
+        // Vec<u8> Convert to String, only for printing logs
+        let data_string = String::from_utf8(data.clone())
+            .map_err(|e| TargetError::Encoding(format!("Failed to convert event data to UTF-8: {}", e)))?;
+        debug!("Sending event to mqtt target: {}, event log: {}", self.id, data_string);
+
+        client
+            .publish(&self.args.topic, self.args.qos, false, data)
+            .await
+            .map_err(|e| {
+                if e.to_string().contains("Connection") || e.to_string().contains("Timeout") {
+                    self.connected.store(false, Ordering::SeqCst);
+                    warn!(target_id = %self.id, error = %e, "Publish failed due to connection issue, marking as not connected.");
+                    TargetError::NotConnected
+                } else {
+                    TargetError::Request(format!("Failed to publish message: {}", e))
+                }
+            })?;
+
+        debug!(target_id = %self.id, topic = %self.args.topic, "Event published to MQTT topic");
+        Ok(())
+    }
+
+    pub fn clone_target(&self) -> Box<dyn Target + Send + Sync> {
+        Box::new(MQTTTarget {
+            id: self.id.clone(),
+            args: self.args.clone(),
+            client: self.client.clone(),
+            store: self.store.as_ref().map(|s| s.boxed_clone()),
+            connected: self.connected.clone(),
+            bg_task_manager: self.bg_task_manager.clone(),
+        })
+    }
+}
+
+async fn run_mqtt_event_loop(
+    mut eventloop: EventLoop,
+    connected_status: Arc<AtomicBool>,
+    target_id: TargetID,
+    mut cancel_rx: mpsc::Receiver<()>,
+) {
+    info!(target_id = %target_id, "MQTT event loop task started.");
+    let mut initial_connection_established = false;
+
+    loop {
+        tokio::select! {
+            biased;
+            _ = cancel_rx.recv() => {
+                info!(target_id = %target_id, "MQTT event loop task received cancellation signal. Shutting down.");
+                break;
+            }
+            polled_event_result = async {
+                if !initial_connection_established || !connected_status.load(Ordering::SeqCst) {
+                    match tokio::time::timeout(EVENT_LOOP_POLL_TIMEOUT, eventloop.poll()).await {
+                        Ok(Ok(event)) => Ok(event),
+                        Ok(Err(e)) => Err(e),
+                        Err(_) => {
+                            debug!(target_id = %target_id, "MQTT poll timed out (EVENT_LOOP_POLL_TIMEOUT) while not connected or status pending.");
+                            Err(rumqttc::ConnectionError::NetworkTimeout)
+                        }
+                    }
+                } else {
+                    eventloop.poll().await
+                }
+            } => {
+                match polled_event_result {
+                    Ok(notification) => {
+                        trace!(target_id = %target_id, event = ?notification, "Received MQTT event");
+                        match notification {
+                            rumqttc::Event::Incoming(Packet::ConnAck(_conn_ack)) => {
+                                info!(target_id = %target_id, "MQTT connected (ConnAck).");
+                                connected_status.store(true, Ordering::SeqCst);
+                                initial_connection_established = true;
+                            }
+                            rumqttc::Event::Incoming(Packet::Publish(publish)) => {
+                                debug!(target_id = %target_id, topic = %publish.topic, payload_len = publish.payload.len(), "Received message on subscribed topic.");
+                            }
+                            rumqttc::Event::Incoming(Packet::Disconnect) => {
+                                info!(target_id = %target_id, "Received Disconnect packet from broker. MQTT connection lost.");
+                                connected_status.store(false, Ordering::SeqCst);
+                            }
+                            rumqttc::Event::Incoming(Packet::PingResp) => {
+                                trace!(target_id = %target_id, "Received PingResp from broker. Connection is alive.");
+                            }
+                            rumqttc::Event::Incoming(Packet::SubAck(suback)) => {
+                                trace!(target_id = %target_id, "Received SubAck for pkid: {}", suback.pkid);
+                            }
+                            rumqttc::Event::Incoming(Packet::PubAck(puback)) => {
+                                trace!(target_id = %target_id, "Received PubAck for pkid: {}", puback.pkid);
+                            }
+                            // Process other incoming packet types as needed (PubRec, PubRel, PubComp, UnsubAck)
+                            rumqttc::Event::Outgoing(Outgoing::Disconnect) => {
+                                info!(target_id = %target_id, "MQTT outgoing disconnect initiated by client.");
+                                connected_status.store(false, Ordering::SeqCst);
+                            }
+                            rumqttc::Event::Outgoing(Outgoing::PingReq) => {
+                                trace!(target_id = %target_id, "Client sent PingReq to broker.");
+                            }
+                            // Other Outgoing events (Subscribe, Unsubscribe, Publish) usually do not need to handle connection status here,
+                            // Because they are actions initiated by the client.
+                            _ => {
+                                // Log other unspecified MQTT events that are not handled, which helps debug
+                                trace!(target_id = %target_id, "Unhandled or generic MQTT event: {:?}", notification);
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        connected_status.store(false, Ordering::SeqCst);
+                        error!(target_id = %target_id, error = %e, "Error from MQTT event loop poll");
+
+                        if matches!(e, rumqttc::ConnectionError::NetworkTimeout) && (!initial_connection_established || !connected_status.load(Ordering::SeqCst)) {
+                           warn!(target_id = %target_id, "Timeout during initial poll or pending state, will retry.");
+                           continue;
+                        }
+
+                        if matches!(e,
+                            ConnectionError::Io(_) |
+                            ConnectionError::NetworkTimeout |
+                            ConnectionError::ConnectionRefused(_) |
+                            ConnectionError::Tls(_)
+                        ) {
+                           warn!(target_id = %target_id, error = %e, "MQTT connection error. Relying on rumqttc for reconnection if applicable.");
+                        }
+                        // Here you can decide whether to break loops based on the error type.
+                        // For example, for some unrecoverable errors.
+                        if is_fatal_mqtt_error(&e) {
+                            error!(target_id = %target_id, error = %e, "Fatal MQTT error, terminating event loop.");
+                            break;
+                        }
+                       // rumqttc's eventloop.poll() may return Err and terminate after some errors,
+                        // Or it will handle reconnection internally. The continue here will make select! wait again.
+                        // If the error is temporary and rumqttc is handling reconnection, poll() should eventually succeed or return a different error again.
+                        // Sleep briefly to avoid busy cycles in case of rapid failure.
+                        tokio::time::sleep(Duration::from_secs(1)).await;
+                    }
+                }
+            }
+        }
+    }
+    connected_status.store(false, Ordering::SeqCst);
+    info!(target_id = %target_id, "MQTT event loop task finished.");
+}
+
+/// Check whether the given MQTT connection error should be considered a fatal error,
+/// For fatal errors, the event loop should terminate.
+fn is_fatal_mqtt_error(err: &ConnectionError) -> bool {
+    match err {
+        // If the client request has been processed all (for example, AsyncClient is dropped), the event loop can end.
+        ConnectionError::RequestsDone => true,
+
+        // Check for the underlying MQTT status error
+        ConnectionError::MqttState(state_err) => {
+            // The type of state_err is &rumqttc::StateError
+            match state_err {
+                // If StateError is caused by deserialization issues, check the underlying MqttBytesError
+                rumqttc::StateError::Deserialization(mqtt_bytes_err) => { // The type of mqtt_bytes_err is &rumqttc::mqttbytes::Error
+                    matches!(
+                        mqtt_bytes_err,
+                        MqttBytesError::InvalidProtocol // Invalid agreement
+                        | MqttBytesError::InvalidProtocolLevel(_) // Invalid protocol level
+                        | MqttBytesError::IncorrectPacketFormat // Package format is incorrect
+                        | MqttBytesError::InvalidPacketType(_) // Invalid package type
+                        | MqttBytesError::MalformedPacket // Package format error
+                        | MqttBytesError::PayloadTooLong // Too long load
+                        | MqttBytesError::PayloadSizeLimitExceeded(_) // Load size limit exceeded
+                        | MqttBytesError::TopicNotUtf8 // Topic Non-UTF-8 (Serious Agreement Violation)
+                    )
+                }
+                // Others that are fatal StateError variants
+                rumqttc::StateError::InvalidState          // The internal state machine is in invalid state
+                | rumqttc::StateError::WrongPacket         // Agreement Violation: Unexpected Data Packet Received
+                | rumqttc::StateError::Unsolicited(_)      // Agreement Violation: Unsolicited ACK Received
+                | rumqttc::StateError::OutgoingPacketTooLarge { .. } // Try to send too large packets
+                | rumqttc::StateError::EmptySubscription   // Agreement violation (if this stage occurs)
+                => true,
+
+                // Other StateErrors (such as Io, AwaitPingResp, CollisionTimeout) are not considered deadly here.
+                // They may be processed internally by rumqttc or upgraded to other ConnectionError types.
+                _ => false,
+            }
+        }
+
+        // Other types of ConnectionErrors (such as Io, Tls, NetworkTimeout, ConnectionRefused, NotConnAck, etc.)
+        // It is usually considered temporary, or the reconnect logic inside rumqttc will be processed.
+        _ => false,
+    }
+}
+
+#[async_trait]
+impl Target for MQTTTarget {
+    fn id(&self) -> TargetID {
+        self.id.clone()
+    }
+
+    #[instrument(skip(self), fields(target_id = %self.id))]
+    async fn is_active(&self) -> Result<bool, TargetError> {
+        debug!(target_id = %self.id, "Checking if MQTT target is active.");
+        if self.client.lock().await.is_none() && !self.connected.load(Ordering::SeqCst) {
+            // Check if the background task is running and has not panicked
+            if let Some(handle) = self.bg_task_manager.init_cell.get() {
+                if handle.is_finished() {
+                    error!(target_id = %self.id, "MQTT background task has finished, possibly due to an error. Target is not active.");
+                    return Err(TargetError::Network("MQTT background task terminated".to_string()));
+                }
+            }
+            debug!(target_id = %self.id, "MQTT client not yet initialized or task not running/connected.");
+            return Err(TargetError::Configuration(
+                "MQTT client not available or not initialized/connected".to_string(),
+            ));
+        }
+
+        if self.connected.load(Ordering::SeqCst) {
+            debug!(target_id = %self.id, "MQTT target is active (connected flag is true).");
+            Ok(true)
+        } else {
+            debug!(target_id = %self.id, "MQTT target is not connected (connected flag is false).");
+            Err(TargetError::NotConnected)
+        }
+    }
+
+    #[instrument(skip(self, event), fields(target_id = %self.id))]
+    async fn save(&self, event: Arc<Event>) -> Result<(), TargetError> {
+        if let Some(store) = &self.store {
+            debug!(target_id = %self.id, "Event saved to store start");
+            // If store is configured, ONLY put the event into the store.
+            // Do NOT send it directly here.
+            match store.put(event.clone()) {
+                Ok(_) => {
+                    debug!(target_id = %self.id, "Event saved to store for MQTT target successfully.");
+                    Ok(())
+                }
+                Err(e) => {
+                    error!(target_id = %self.id, error = %e, "Failed to save event to store");
+                    return Err(TargetError::Storage(format!("Failed to save event to store: {}", e)));
+                }
+            }
+        } else {
+            if !self.is_enabled() {
+                return Err(TargetError::Disabled);
+            }
+
+            if !self.connected.load(Ordering::SeqCst) {
+                warn!(target_id = %self.id, "Attempting to send directly but not connected; trying to init.");
+                // Call the struct's init method, not the trait's default
+                match MQTTTarget::init(self).await {
+                    Ok(_) => debug!(target_id = %self.id, "MQTT target initialized successfully."),
+                    Err(e) => {
+                        error!(target_id = %self.id, error = %e, "Failed to initialize MQTT target.");
+                        return Err(TargetError::NotConnected);
+                    }
+                }
+                if !self.connected.load(Ordering::SeqCst) {
+                    error!(target_id = %self.id, "Cannot save (send directly) as target is not active after init attempt.");
+                    return Err(TargetError::NotConnected);
+                }
+            }
+            self.send(&event).await
+        }
+    }
+
+    #[instrument(skip(self), fields(target_id = %self.id))]
+    async fn send_from_store(&self, key: Key) -> Result<(), TargetError> {
+        debug!(target_id = %self.id, ?key, "Attempting to send event from store with key.");
+
+        if !self.is_enabled() {
+            return Err(TargetError::Disabled);
+        }
+
+        if !self.connected.load(Ordering::SeqCst) {
+            warn!(target_id = %self.id, "Not connected; trying to init before sending from store.");
+            match MQTTTarget::init(self).await {
+                Ok(_) => debug!(target_id = %self.id, "MQTT target initialized successfully."),
+                Err(e) => {
+                    error!(target_id = %self.id, error = %e, "Failed to initialize MQTT target.");
+                    return Err(TargetError::NotConnected);
+                }
+            }
+            if !self.connected.load(Ordering::SeqCst) {
+                error!(target_id = %self.id, "Cannot send from store as target is not active after init attempt.");
+                return Err(TargetError::NotConnected);
+            }
+        }
+
+        let store = self
+            .store
+            .as_ref()
+            .ok_or_else(|| TargetError::Configuration("No store configured".to_string()))?;
+
+        let event = match store.get(&key) {
+            Ok(event) => {
+                debug!(target_id = %self.id, ?key, "Retrieved event from store for sending.");
+                event
+            }
+            Err(StoreError::NotFound) => {
+                // Assuming NotFound takes the key
+                debug!(target_id = %self.id, ?key, "Event not found in store for sending.");
+                return Ok(());
+            }
+            Err(e) => {
+                error!(
+                    target_id = %self.id,
+                    error = %e,
+                    "Failed to get event from store"
+                );
+                return Err(TargetError::Storage(format!("Failed to get event from store: {}", e)));
+            }
+        };
+
+        debug!(target_id = %self.id, ?key, "Sending event from store.");
+        if let Err(e) = self.send(&event).await {
+            if matches!(e, TargetError::NotConnected) {
+                warn!(target_id = %self.id, "Failed to send event from store: Not connected. Event remains in store.");
+                return Err(TargetError::NotConnected);
+            }
+            error!(target_id = %self.id, error = %e, "Failed to send event from store with an unexpected error.");
+            return Err(e);
+        }
+        debug!(target_id = %self.id, ?key, "Event sent from store successfully. deleting from store. ");
+
+        match store.del(&key) {
+            Ok(_) => {
+                debug!(target_id = %self.id, ?key, "Event deleted from store after successful send.")
+            }
+            Err(StoreError::NotFound) => {
+                debug!(target_id = %self.id, ?key, "Event already deleted from store.");
+            }
+            Err(e) => {
+                error!(target_id = %self.id, error = %e, "Failed to delete event from store after send.");
+                return Err(TargetError::Storage(format!("Failed to delete event from store: {}", e)));
+            }
+        }
+
+        debug!(target_id = %self.id, ?key, "Event deleted from store.");
+        Ok(())
+    }
+
+    async fn close(&self) -> Result<(), TargetError> {
+        info!(target_id = %self.id, "Attempting to close MQTT target.");
+
+        if let Err(e) = self.bg_task_manager.cancel_tx.send(()).await {
+            warn!(target_id = %self.id, error = %e, "Failed to send cancel signal to MQTT background task. It might have already exited.");
+        }
+
+        // Wait for the task to finish if it was initialized
+        if let Some(_task_handle) = self.bg_task_manager.init_cell.get() {
+            debug!(target_id = %self.id, "Waiting for MQTT background task to complete...");
+            // It's tricky to await here if close is called from a sync context or Drop
+            // For async close, this is fine. Consider a timeout.
+            // let _ = tokio::time::timeout(Duration::from_secs(5), task_handle.await).await;
+            // If task_handle.await is directly used, ensure it's not awaited multiple times if close can be called multiple times.
+            // For now, we rely on the signal and the task's self-termination.
+        }
+
+        if let Some(client_instance) = self.client.lock().await.take() {
+            info!(target_id = %self.id, "Disconnecting MQTT client.");
+            if let Err(e) = client_instance.disconnect().await {
+                warn!(target_id = %self.id, error = %e, "Error during MQTT client disconnect.");
+            }
+        }
+
+        self.connected.store(false, Ordering::SeqCst);
+        info!(target_id = %self.id, "MQTT target close method finished.");
+        Ok(())
+    }
+
+    fn store(&self) -> Option<&(dyn Store<Event, Error = StoreError, Key = Key> + Send + Sync)> {
+        self.store.as_deref()
+    }
+
+    fn clone_dyn(&self) -> Box<dyn Target + Send + Sync> {
+        self.clone_target()
+    }
+
+    async fn init(&self) -> Result<(), TargetError> {
+        if !self.is_enabled() {
+            debug!(target_id = %self.id, "Target is disabled, skipping init.");
+            return Ok(());
+        }
+        // Call the internal init logic
+        MQTTTarget::init(self).await
+    }
+
+    fn is_enabled(&self) -> bool {
+        self.args.enable
+    }
+}
diff --git a/crates/notify/src/target/webhook.rs b/crates/notify/src/target/webhook.rs
new file mode 100644
index 00000000..91316026
--- /dev/null
+++ b/crates/notify/src/target/webhook.rs
@@ -0,0 +1,398 @@
+use crate::store::STORE_EXTENSION;
+use crate::target::ChannelTargetType;
+use crate::{
+    StoreError, Target,
+    arn::TargetID,
+    error::TargetError,
+    event::{Event, EventLog},
+    store::{Key, Store},
+};
+use async_trait::async_trait;
+use reqwest::{Client, StatusCode, Url};
+use std::{
+    path::PathBuf,
+    sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+    },
+    time::Duration,
+};
+use tokio::net::lookup_host;
+use tokio::sync::mpsc;
+use tracing::{debug, error, info, instrument};
+use urlencoding;
+
+/// Arguments for configuring a Webhook target
+#[derive(Debug, Clone)]
+pub struct WebhookArgs {
+    /// Whether the target is enabled
+    pub enable: bool,
+    /// The endpoint URL to send events to
+    pub endpoint: Url,
+    /// The authorization token for the endpoint
+    pub auth_token: String,
+    /// The directory to store events in case of failure
+    pub queue_dir: String,
+    /// The maximum number of events to store
+    pub queue_limit: u64,
+    /// The client certificate for TLS (PEM format)
+    pub client_cert: String,
+    /// The client key for TLS (PEM format)
+    pub client_key: String,
+}
+
+// WebhookArgs 的验证方法
+impl WebhookArgs {
+    pub fn validate(&self) -> Result<(), TargetError> {
+        if !self.enable {
+            return Ok(());
+        }
+
+        if self.endpoint.as_str().is_empty() {
+            return Err(TargetError::Configuration("endpoint empty".to_string()));
+        }
+
+        if !self.queue_dir.is_empty() {
+            let path = std::path::Path::new(&self.queue_dir);
+            if !path.is_absolute() {
+                return Err(TargetError::Configuration("webhook queueDir path should be absolute".to_string()));
+            }
+        }
+
+        if !self.client_cert.is_empty() && self.client_key.is_empty()
+            || self.client_cert.is_empty() && !self.client_key.is_empty()
+        {
+            return Err(TargetError::Configuration("cert and key must be specified as a pair".to_string()));
+        }
+
+        Ok(())
+    }
+}
+
+/// A target that sends events to a webhook
+pub struct WebhookTarget {
+    id: TargetID,
+    args: WebhookArgs,
+    http_client: Arc<Client>,
+    // Add Send + Sync constraints to ensure thread safety
+    store: Option<Box<dyn Store<Event, Error = StoreError, Key = Key> + Send + Sync>>,
+    initialized: AtomicBool,
+    addr: String,
+    cancel_sender: mpsc::Sender<()>,
+}
+
+impl WebhookTarget {
+    /// Clones the WebhookTarget, creating a new instance with the same configuration
+    pub fn clone_box(&self) -> Box<dyn Target + Send + Sync> {
+        Box::new(WebhookTarget {
+            id: self.id.clone(),
+            args: self.args.clone(),
+            http_client: Arc::clone(&self.http_client),
+            store: self.store.as_ref().map(|s| s.boxed_clone()),
+            initialized: AtomicBool::new(self.initialized.load(Ordering::SeqCst)),
+            addr: self.addr.clone(),
+            cancel_sender: self.cancel_sender.clone(),
+        })
+    }
+
+    /// Creates a new WebhookTarget
+    #[instrument(skip(args), fields(target_id = %id))]
+    pub fn new(id: String, args: WebhookArgs) -> Result<Self, TargetError> {
+        // First verify the parameters
+        args.validate()?;
+        // Create a TargetID
+        let target_id = TargetID::new(id, ChannelTargetType::Webhook.as_str().to_string());
+        // Build HTTP client
+        let mut client_builder = Client::builder()
+            .timeout(Duration::from_secs(30))
+            .user_agent(rustfs_utils::sys::get_user_agent(rustfs_utils::sys::ServiceType::Basis));
+
+        // Supplementary certificate processing logic
+        if !args.client_cert.is_empty() && !args.client_key.is_empty() {
+            // Add client certificate
+            let cert = std::fs::read(&args.client_cert)
+                .map_err(|e| TargetError::Configuration(format!("Failed to read client cert: {}", e)))?;
+            let key = std::fs::read(&args.client_key)
+                .map_err(|e| TargetError::Configuration(format!("Failed to read client key: {}", e)))?;
+
+            let identity = reqwest::Identity::from_pem(&[cert, key].concat())
+                .map_err(|e| TargetError::Configuration(format!("Failed to create identity: {}", e)))?;
+            client_builder = client_builder.identity(identity);
+        }
+
+        let http_client = Arc::new(
+            client_builder
+                .build()
+                .map_err(|e| TargetError::Configuration(format!("Failed to build HTTP client: {}", e)))?,
+        );
+
+        // Build storage
+        let queue_store = if !args.queue_dir.is_empty() {
+            let queue_dir = PathBuf::from(&args.queue_dir).join(format!(
+                "rustfs-{}-{}-{}",
+                ChannelTargetType::Webhook.as_str(),
+                target_id.name,
+                target_id.id
+            ));
+            let store = super::super::store::QueueStore::<Event>::new(queue_dir, args.queue_limit, STORE_EXTENSION);
+
+            if let Err(e) = store.open() {
+                error!("Failed to open store for Webhook target {}: {}", target_id.id, e);
+                return Err(TargetError::Storage(format!("{}", e)));
+            }
+
+            // Make sure that the Store trait implemented by QueueStore matches the expected error type
+            Some(Box::new(store) as Box<dyn Store<Event, Error = StoreError, Key = Key> + Send + Sync>)
+        } else {
+            None
+        };
+
+        // resolved address
+        let addr = {
+            let host = args.endpoint.host_str().unwrap_or("localhost");
+            let port = args
+                .endpoint
+                .port()
+                .unwrap_or_else(|| if args.endpoint.scheme() == "https" { 443 } else { 80 });
+            format!("{}:{}", host, port)
+        };
+
+        // Create a cancel channel
+        let (cancel_sender, _) = mpsc::channel(1);
+        info!(target_id = %target_id.id, "Webhook target created");
+        Ok(WebhookTarget {
+            id: target_id,
+            args,
+            http_client,
+            store: queue_store,
+            initialized: AtomicBool::new(false),
+            addr,
+            cancel_sender,
+        })
+    }
+
+    async fn init(&self) -> Result<(), TargetError> {
+        // 使用 CAS 操作确保线程安全初始化
+        if !self.initialized.load(Ordering::SeqCst) {
+            // 检查连接
+            match self.is_active().await {
+                Ok(true) => {
+                    info!("Webhook target {} is active", self.id);
+                }
+                Ok(false) => {
+                    return Err(TargetError::NotConnected);
+                }
+                Err(e) => {
+                    error!("Failed to check if Webhook target {} is active: {}", self.id, e);
+                    return Err(e);
+                }
+            }
+            self.initialized.store(true, Ordering::SeqCst);
+            info!("Webhook target {} initialized", self.id);
+        }
+        Ok(())
+    }
+
+    async fn send(&self, event: &Event) -> Result<(), TargetError> {
+        info!("Webhook Sending event to webhook target: {}", self.id);
+        let object_name = urlencoding::decode(&event.s3.object.key)
+            .map_err(|e| TargetError::Encoding(format!("Failed to decode object key: {}", e)))?;
+
+        let key = format!("{}/{}", event.s3.bucket.name, object_name);
+
+        let log = EventLog {
+            event_name: event.event_name,
+            key,
+            records: vec![event.clone()],
+        };
+
+        let data =
+            serde_json::to_vec(&log).map_err(|e| TargetError::Serialization(format!("Failed to serialize event: {}", e)))?;
+
+        // Vec<u8> 转换为 String
+        let data_string = String::from_utf8(data.clone())
+            .map_err(|e| TargetError::Encoding(format!("Failed to convert event data to UTF-8: {}", e)))?;
+        debug!("Sending event to webhook target: {}, event log: {}", self.id, data_string);
+
+        // 构建请求
+        let mut req_builder = self
+            .http_client
+            .post(self.args.endpoint.as_str())
+            .header("Content-Type", "application/json");
+
+        if !self.args.auth_token.is_empty() {
+            // Split auth_token string to check if the authentication type is included
+            let tokens: Vec<&str> = self.args.auth_token.split_whitespace().collect();
+            match tokens.len() {
+                2 => {
+                    // Already include authentication type and token, such as "Bearer token123"
+                    req_builder = req_builder.header("Authorization", &self.args.auth_token);
+                }
+                1 => {
+                    // Only tokens, need to add "Bearer" prefix
+                    req_builder = req_builder.header("Authorization", format!("Bearer {}", self.args.auth_token));
+                }
+                _ => {
+                    // Empty string or other situations, no authentication header is added
+                }
+            }
+        }
+
+        // Send a request
+        let resp = req_builder.body(data).send().await.map_err(|e| {
+            if e.is_timeout() || e.is_connect() {
+                TargetError::NotConnected
+            } else {
+                TargetError::Request(format!("Failed to send request: {}", e))
+            }
+        })?;
+
+        let status = resp.status();
+        if status.is_success() {
+            debug!("Event sent to webhook target: {}", self.id);
+            Ok(())
+        } else if status == StatusCode::FORBIDDEN {
+            Err(TargetError::Authentication(format!(
+                "{} returned '{}', please check if your auth token is correctly set",
+                self.args.endpoint, status
+            )))
+        } else {
+            Err(TargetError::Request(format!(
+                "{} returned '{}', please check your endpoint configuration",
+                self.args.endpoint, status
+            )))
+        }
+    }
+}
+
+#[async_trait]
+impl Target for WebhookTarget {
+    fn id(&self) -> TargetID {
+        self.id.clone()
+    }
+
+    // Make sure Future is Send
+    async fn is_active(&self) -> Result<bool, TargetError> {
+        let socket_addr = lookup_host(&self.addr)
+            .await
+            .map_err(|e| TargetError::Network(format!("Failed to resolve host: {}", e)))?
+            .next()
+            .ok_or_else(|| TargetError::Network("No address found".to_string()))?;
+        debug!("is_active socket addr: {},target id:{}", socket_addr, self.id.id);
+        match tokio::time::timeout(Duration::from_secs(5), tokio::net::TcpStream::connect(socket_addr)).await {
+            Ok(Ok(_)) => {
+                debug!("Connection to {} is active", self.addr);
+                Ok(true)
+            }
+            Ok(Err(e)) => {
+                debug!("Connection to {} failed: {}", self.addr, e);
+                if e.kind() == std::io::ErrorKind::ConnectionRefused {
+                    Err(TargetError::NotConnected)
+                } else {
+                    Err(TargetError::Network(format!("Connection failed: {}", e)))
+                }
+            }
+            Err(_) => Err(TargetError::Timeout("Connection timed out".to_string())),
+        }
+    }
+
+    async fn save(&self, event: Arc<Event>) -> Result<(), TargetError> {
+        if let Some(store) = &self.store {
+            // Call the store method directly, no longer need to acquire the lock
+            store
+                .put(event)
+                .map_err(|e| TargetError::Storage(format!("Failed to save event to store: {}", e)))?;
+            debug!("Event saved to store for target: {}", self.id);
+            Ok(())
+        } else {
+            match self.init().await {
+                Ok(_) => (),
+                Err(e) => {
+                    error!("Failed to initialize Webhook target {}: {}", self.id.id, e);
+                    return Err(TargetError::NotConnected);
+                }
+            }
+            self.send(&event).await
+        }
+    }
+
+    async fn send_from_store(&self, key: Key) -> Result<(), TargetError> {
+        debug!("Sending event from store for target: {}", self.id);
+        match self.init().await {
+            Ok(_) => {
+                debug!("Event sent to store for target: {}", self.name());
+            }
+            Err(e) => {
+                error!("Failed to initialize Webhook target {}: {}", self.id.id, e);
+                return Err(TargetError::NotConnected);
+            }
+        }
+
+        let store = self
+            .store
+            .as_ref()
+            .ok_or_else(|| TargetError::Configuration("No store configured".to_string()))?;
+
+        // Get events directly from the store, no longer need to acquire locks
+        let event = match store.get(&key) {
+            Ok(event) => event,
+            Err(StoreError::NotFound) => return Ok(()),
+            Err(e) => {
+                return Err(TargetError::Storage(format!("Failed to get event from store: {}", e)));
+            }
+        };
+
+        if let Err(e) = self.send(&event).await {
+            if let TargetError::NotConnected = e {
+                return Err(TargetError::NotConnected);
+            }
+            return Err(e);
+        }
+
+        // Use the immutable reference of the store to delete the event content corresponding to the key
+        debug!("Deleting event from store for target: {}, key:{}, start", self.id, key.to_string());
+        match store.del(&key) {
+            Ok(_) => debug!("Event deleted from store for target: {}, key:{}, end", self.id, key.to_string()),
+            Err(e) => {
+                error!("Failed to delete event from store: {}", e);
+                return Err(TargetError::Storage(format!("Failed to delete event from store: {}", e)));
+            }
+        }
+
+        debug!("Event sent from store and deleted for target: {}", self.id);
+        Ok(())
+    }
+
+    async fn close(&self) -> Result<(), TargetError> {
+        // Send cancel signal to background tasks
+        let _ = self.cancel_sender.try_send(());
+        info!("Webhook target closed: {}", self.id);
+        Ok(())
+    }
+
+    fn store(&self) -> Option<&(dyn Store<Event, Error = StoreError, Key = Key> + Send + Sync)> {
+        // Returns the reference to the internal store
+        self.store.as_deref()
+    }
+
+    fn clone_dyn(&self) -> Box<dyn Target + Send + Sync> {
+        self.clone_box()
+    }
+
+    // The existing init method can meet the needs well, but we need to make sure it complies with the Target trait
+    // We can use the existing init method, but adjust the return value to match the trait requirement
+    async fn init(&self) -> Result<(), TargetError> {
+        // If the target is disabled, return to success directly
+        if !self.is_enabled() {
+            debug!("Webhook target {} is disabled, skipping initialization", self.id);
+            return Ok(());
+        }
+
+        // Use existing initialization logic
+        WebhookTarget::init(self).await
+    }
+
+    fn is_enabled(&self) -> bool {
+        self.args.enable
+    }
+}
diff --git a/crates/obs/Cargo.toml b/crates/obs/Cargo.toml
index 5a040c87..be4e7675 100644
--- a/crates/obs/Cargo.toml
+++ b/crates/obs/Cargo.toml
@@ -17,10 +17,11 @@ webhook = ["dep:reqwest"]
 kafka = ["dep:rdkafka"]
 
 [dependencies]
-rustfs-config = { workspace = true }
+rustfs-config = { workspace = true, features = ["constants"] }
 async-trait = { workspace = true }
 chrono = { workspace = true }
 flexi_logger = { workspace = true, features = ["trc", "kv"] }
+lazy_static = { workspace = true }
 nu-ansi-term = { workspace = true }
 nvml-wrapper = { workspace = true, optional = true }
 opentelemetry = { workspace = true }
diff --git a/crates/obs/examples/config.toml b/crates/obs/examples/config.toml
index b649f806..3a398bc3 100644
--- a/crates/obs/examples/config.toml
+++ b/crates/obs/examples/config.toml
@@ -3,11 +3,12 @@ endpoint = "http://localhost:4317" # Default is "http://localhost:4317" if not s
 use_stdout = false # Output with stdout, true output, false no output
 sample_ratio = 1
 meter_interval = 30
-service_name = "rustfs_obs"
+service_name = "rustfs"
 service_version = "0.1.0"
 environments = "develop"
 logger_level = "debug"
-local_logging_enabled = true
+local_logging_enabled = true # Default is false if not specified
+
 
 #[[sinks]]
 #type = "Kafka"
diff --git a/crates/obs/src/lib.rs b/crates/obs/src/lib.rs
index 68d2e272..58013ae2 100644
--- a/crates/obs/src/lib.rs
+++ b/crates/obs/src/lib.rs
@@ -34,6 +34,7 @@ mod config;
 mod entry;
 mod global;
 mod logger;
+mod metrics;
 mod sinks;
 mod system;
 mod telemetry;
diff --git a/crates/obs/src/metrics/audit.rs b/crates/obs/src/metrics/audit.rs
new file mode 100644
index 00000000..5bc3ee39
--- /dev/null
+++ b/crates/obs/src/metrics/audit.rs
@@ -0,0 +1,32 @@
+/// audit related metric descriptors
+///
+/// This module contains the metric descriptors for the audit subsystem.
+use crate::metrics::{MetricDescriptor, MetricName, new_counter_md, new_gauge_md, subsystems};
+
+const TARGET_ID: &str = "target_id";
+
+lazy_static::lazy_static! {
+    pub static ref AUDIT_FAILED_MESSAGES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::AuditFailedMessages,
+            "Total number of messages that failed to send since start",
+            &[TARGET_ID],
+            subsystems::AUDIT
+        );
+
+    pub static ref AUDIT_TARGET_QUEUE_LENGTH_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::AuditTargetQueueLength,
+            "Number of unsent messages in queue for target",
+            &[TARGET_ID],
+            subsystems::AUDIT
+        );
+
+    pub static ref AUDIT_TOTAL_MESSAGES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::AuditTotalMessages,
+            "Total number of messages sent since start",
+            &[TARGET_ID],
+            subsystems::AUDIT
+        );
+}
diff --git a/crates/obs/src/metrics/bucket.rs b/crates/obs/src/metrics/bucket.rs
new file mode 100644
index 00000000..d008e89b
--- /dev/null
+++ b/crates/obs/src/metrics/bucket.rs
@@ -0,0 +1,68 @@
+/// bucket level s3 metric descriptor
+use crate::metrics::{MetricDescriptor, MetricName, new_counter_md, new_gauge_md, new_histogram_md, subsystems};
+
+lazy_static::lazy_static! {
+    pub static ref BUCKET_API_TRAFFIC_SENT_BYTES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ApiTrafficSentBytes,
+            "Total number of bytes received for a bucket",
+            &["bucket", "type"],
+            subsystems::BUCKET_API
+        );
+
+    pub static ref BUCKET_API_TRAFFIC_RECV_BYTES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ApiTrafficRecvBytes,
+            "Total number of bytes sent for a bucket",
+            &["bucket", "type"],
+            subsystems::BUCKET_API
+        );
+
+    pub static ref BUCKET_API_REQUESTS_IN_FLIGHT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ApiRequestsInFlightTotal,
+            "Total number of requests currently in flight for a bucket",
+            &["bucket", "name", "type"],
+            subsystems::BUCKET_API
+        );
+
+    pub static ref BUCKET_API_REQUESTS_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ApiRequestsTotal,
+            "Total number of requests for a bucket",
+            &["bucket", "name", "type"],
+            subsystems::BUCKET_API
+        );
+
+    pub static ref BUCKET_API_REQUESTS_CANCELED_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ApiRequestsCanceledTotal,
+            "Total number of requests canceled by the client for a bucket",
+            &["bucket", "name", "type"],
+            subsystems::BUCKET_API
+        );
+
+    pub static ref BUCKET_API_REQUESTS_4XX_ERRORS_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ApiRequests4xxErrorsTotal,
+            "Total number of requests with 4xx errors for a bucket",
+            &["bucket", "name", "type"],
+            subsystems::BUCKET_API
+        );
+
+    pub static ref BUCKET_API_REQUESTS_5XX_ERRORS_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ApiRequests5xxErrorsTotal,
+            "Total number of requests with 5xx errors for a bucket",
+            &["bucket", "name", "type"],
+            subsystems::BUCKET_API
+        );
+
+    pub static ref BUCKET_API_REQUESTS_TTFB_SECONDS_DISTRIBUTION_MD: MetricDescriptor =
+        new_histogram_md(
+            MetricName::ApiRequestsTTFBSecondsDistribution,
+            "Distribution of time to first byte across API calls for a bucket",
+            &["bucket", "name", "le", "type"],
+            subsystems::BUCKET_API
+        );
+}
diff --git a/crates/obs/src/metrics/bucket_replication.rs b/crates/obs/src/metrics/bucket_replication.rs
new file mode 100644
index 00000000..53872ebc
--- /dev/null
+++ b/crates/obs/src/metrics/bucket_replication.rs
@@ -0,0 +1,168 @@
+/// Bucket copy metric descriptor
+use crate::metrics::{MetricDescriptor, MetricName, new_counter_md, new_gauge_md, subsystems};
+
+/// Bucket level replication metric descriptor
+pub const BUCKET_L: &str = "bucket";
+/// Replication operation
+pub const OPERATION_L: &str = "operation";
+/// Replication target ARN
+pub const TARGET_ARN_L: &str = "targetArn";
+/// Replication range
+pub const RANGE_L: &str = "range";
+
+lazy_static::lazy_static! {
+    pub static ref BUCKET_REPL_LAST_HR_FAILED_BYTES_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::LastHourFailedBytes,
+            "Total number of bytes failed at least once to replicate in the last hour on a bucket",
+            &[BUCKET_L],
+            subsystems::BUCKET_REPLICATION
+        );
+
+    pub static ref BUCKET_REPL_LAST_HR_FAILED_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::LastHourFailedCount,
+            "Total number of objects which failed replication in the last hour on a bucket",
+            &[BUCKET_L],
+            subsystems::BUCKET_REPLICATION
+        );
+
+    pub static ref BUCKET_REPL_LAST_MIN_FAILED_BYTES_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::LastMinFailedBytes,
+            "Total number of bytes failed at least once to replicate in the last full minute on a bucket",
+            &[BUCKET_L],
+            subsystems::BUCKET_REPLICATION
+        );
+
+    pub static ref BUCKET_REPL_LAST_MIN_FAILED_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::LastMinFailedCount,
+            "Total number of objects which failed replication in the last full minute on a bucket",
+            &[BUCKET_L],
+            subsystems::BUCKET_REPLICATION
+        );
+
+    pub static ref BUCKET_REPL_LATENCY_MS_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::LatencyMilliSec,
+            "Replication latency on a bucket in milliseconds",
+            &[BUCKET_L, OPERATION_L, RANGE_L, TARGET_ARN_L],
+            subsystems::BUCKET_REPLICATION
+        );
+
+    pub static ref BUCKET_REPL_PROXIED_DELETE_TAGGING_REQUESTS_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ProxiedDeleteTaggingRequestsTotal,
+            "Number of DELETE tagging requests proxied to replication target",
+            &[BUCKET_L],
+            subsystems::BUCKET_REPLICATION
+        );
+
+    pub static ref BUCKET_REPL_PROXIED_GET_REQUESTS_FAILURES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ProxiedGetRequestsFailures,
+            "Number of failures in GET requests proxied to replication target",
+            &[BUCKET_L],
+            subsystems::BUCKET_REPLICATION
+        );
+
+    pub static ref BUCKET_REPL_PROXIED_GET_REQUESTS_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ProxiedGetRequestsTotal,
+            "Number of GET requests proxied to replication target",
+            &[BUCKET_L],
+            subsystems::BUCKET_REPLICATION
+        );
+
+    // TODO - add a metric for the number of PUT requests proxied to replication target
+    pub static ref BUCKET_REPL_PROXIED_GET_TAGGING_REQUESTS_FAILURES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ProxiedGetTaggingRequestFailures,
+            "Number of failures in GET tagging requests proxied to replication target",
+            &[BUCKET_L],
+            subsystems::BUCKET_REPLICATION
+        );
+
+    pub static ref BUCKET_REPL_PROXIED_GET_TAGGING_REQUESTS_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ProxiedGetTaggingRequestsTotal,
+            "Number of GET tagging requests proxied to replication target",
+            &[BUCKET_L],
+            subsystems::BUCKET_REPLICATION
+        );
+
+    pub static ref BUCKET_REPL_PROXIED_HEAD_REQUESTS_FAILURES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ProxiedHeadRequestsFailures,
+            "Number of failures in HEAD requests proxied to replication target",
+            &[BUCKET_L],
+            subsystems::BUCKET_REPLICATION
+        );
+
+    pub static ref BUCKET_REPL_PROXIED_HEAD_REQUESTS_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ProxiedHeadRequestsTotal,
+            "Number of HEAD requests proxied to replication target",
+            &[BUCKET_L],
+            subsystems::BUCKET_REPLICATION
+        );
+
+    // TODO - add a metric for the number of PUT requests proxied to replication target
+    pub static ref BUCKET_REPL_PROXIED_PUT_TAGGING_REQUESTS_FAILURES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ProxiedPutTaggingRequestFailures,
+            "Number of failures in PUT tagging requests proxied to replication target",
+            &[BUCKET_L],
+            subsystems::BUCKET_REPLICATION
+        );
+
+    pub static ref BUCKET_REPL_PROXIED_PUT_TAGGING_REQUESTS_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ProxiedPutTaggingRequestsTotal,
+            "Number of PUT tagging requests proxied to replication target",
+            &[BUCKET_L],
+            subsystems::BUCKET_REPLICATION
+        );
+
+    pub static ref BUCKET_REPL_SENT_BYTES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::SentBytes,
+            "Total number of bytes replicated to the target",
+            &[BUCKET_L],
+            subsystems::BUCKET_REPLICATION
+        );
+
+    pub static ref BUCKET_REPL_SENT_COUNT_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::SentCount,
+            "Total number of objects replicated to the target",
+            &[BUCKET_L],
+            subsystems::BUCKET_REPLICATION
+        );
+
+    pub static ref BUCKET_REPL_TOTAL_FAILED_BYTES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::TotalFailedBytes,
+            "Total number of bytes failed at least once to replicate since server start",
+            &[BUCKET_L],
+            subsystems::BUCKET_REPLICATION
+        );
+
+    pub static ref BUCKET_REPL_TOTAL_FAILED_COUNT_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::TotalFailedCount,
+            "Total number of objects which failed replication since server start",
+            &[BUCKET_L],
+            subsystems::BUCKET_REPLICATION
+        );
+
+    // TODO - add a metric for the number of DELETE requests proxied to replication target
+    pub static ref BUCKET_REPL_PROXIED_DELETE_TAGGING_REQUESTS_FAILURES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ProxiedDeleteTaggingRequestFailures,
+            "Number of failures in DELETE tagging requests proxied to replication target",
+            &[BUCKET_L],
+            subsystems::BUCKET_REPLICATION
+        );
+}
diff --git a/crates/obs/src/metrics/cluster_config.rs b/crates/obs/src/metrics/cluster_config.rs
new file mode 100644
index 00000000..b9bc8ea7
--- /dev/null
+++ b/crates/obs/src/metrics/cluster_config.rs
@@ -0,0 +1,20 @@
+/// Metric descriptors related to cluster configuration
+use crate::metrics::{MetricDescriptor, MetricName, new_gauge_md, subsystems};
+
+lazy_static::lazy_static! {
+    pub static ref CONFIG_RRS_PARITY_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ConfigRRSParity,
+            "Reduced redundancy storage class parity",
+            &[],
+            subsystems::CLUSTER_CONFIG
+        );
+
+    pub static ref CONFIG_STANDARD_PARITY_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ConfigStandardParity,
+            "Standard storage class parity",
+            &[],
+            subsystems::CLUSTER_CONFIG
+        );
+}
diff --git a/crates/obs/src/metrics/cluster_erasure_set.rs b/crates/obs/src/metrics/cluster_erasure_set.rs
new file mode 100644
index 00000000..9f129cf7
--- /dev/null
+++ b/crates/obs/src/metrics/cluster_erasure_set.rs
@@ -0,0 +1,97 @@
+/// Erasure code set related metric descriptors
+use crate::metrics::{MetricDescriptor, MetricName, new_gauge_md, subsystems};
+
+/// The label for the pool ID
+pub const POOL_ID_L: &str = "pool_id";
+/// The label for the pool ID
+pub const SET_ID_L: &str = "set_id";
+
+lazy_static::lazy_static! {
+    pub static ref ERASURE_SET_OVERALL_WRITE_QUORUM_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ErasureSetOverallWriteQuorum,
+            "Overall write quorum across pools and sets",
+            &[],
+            subsystems::CLUSTER_ERASURE_SET
+        );
+
+    pub static ref ERASURE_SET_OVERALL_HEALTH_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ErasureSetOverallHealth,
+            "Overall health across pools and sets (1=healthy, 0=unhealthy)",
+            &[],
+            subsystems::CLUSTER_ERASURE_SET
+        );
+
+    pub static ref ERASURE_SET_READ_QUORUM_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ErasureSetReadQuorum,
+            "Read quorum for the erasure set in a pool",
+            &[POOL_ID_L, SET_ID_L],
+            subsystems::CLUSTER_ERASURE_SET
+        );
+
+    pub static ref ERASURE_SET_WRITE_QUORUM_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ErasureSetWriteQuorum,
+            "Write quorum for the erasure set in a pool",
+            &[POOL_ID_L, SET_ID_L],
+            subsystems::CLUSTER_ERASURE_SET
+        );
+
+    pub static ref ERASURE_SET_ONLINE_DRIVES_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ErasureSetOnlineDrivesCount,
+            "Count of online drives in the erasure set in a pool",
+            &[POOL_ID_L, SET_ID_L],
+            subsystems::CLUSTER_ERASURE_SET
+        );
+
+    pub static ref ERASURE_SET_HEALING_DRIVES_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ErasureSetHealingDrivesCount,
+            "Count of healing drives in the erasure set in a pool",
+            &[POOL_ID_L, SET_ID_L],
+            subsystems::CLUSTER_ERASURE_SET
+        );
+
+    pub static ref ERASURE_SET_HEALTH_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ErasureSetHealth,
+            "Health of the erasure set in a pool (1=healthy, 0=unhealthy)",
+            &[POOL_ID_L, SET_ID_L],
+            subsystems::CLUSTER_ERASURE_SET
+        );
+
+    pub static ref ERASURE_SET_READ_TOLERANCE_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ErasureSetReadTolerance,
+            "No of drive failures that can be tolerated without disrupting read operations",
+            &[POOL_ID_L, SET_ID_L],
+            subsystems::CLUSTER_ERASURE_SET
+        );
+
+    pub static ref ERASURE_SET_WRITE_TOLERANCE_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ErasureSetWriteTolerance,
+            "No of drive failures that can be tolerated without disrupting write operations",
+            &[POOL_ID_L, SET_ID_L],
+            subsystems::CLUSTER_ERASURE_SET
+        );
+
+    pub static ref ERASURE_SET_READ_HEALTH_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ErasureSetReadHealth,
+            "Health of the erasure set in a pool for read operations (1=healthy, 0=unhealthy)",
+            &[POOL_ID_L, SET_ID_L],
+            subsystems::CLUSTER_ERASURE_SET
+        );
+
+    pub static ref ERASURE_SET_WRITE_HEALTH_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ErasureSetWriteHealth,
+            "Health of the erasure set in a pool for write operations (1=healthy, 0=unhealthy)",
+            &[POOL_ID_L, SET_ID_L],
+            subsystems::CLUSTER_ERASURE_SET
+        );
+}
diff --git a/crates/obs/src/metrics/cluster_health.rs b/crates/obs/src/metrics/cluster_health.rs
new file mode 100644
index 00000000..96417601
--- /dev/null
+++ b/crates/obs/src/metrics/cluster_health.rs
@@ -0,0 +1,28 @@
+/// Cluster health-related metric descriptors
+use crate::metrics::{MetricDescriptor, MetricName, new_gauge_md, subsystems};
+
+lazy_static::lazy_static! {
+    pub static ref HEALTH_DRIVES_OFFLINE_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::HealthDrivesOfflineCount,
+            "Count of offline drives in the cluster",
+            &[],
+            subsystems::CLUSTER_HEALTH
+        );
+
+    pub static ref HEALTH_DRIVES_ONLINE_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::HealthDrivesOnlineCount,
+            "Count of online drives in the cluster",
+            &[],
+            subsystems::CLUSTER_HEALTH
+        );
+
+    pub static ref HEALTH_DRIVES_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::HealthDrivesCount,
+            "Count of all drives in the cluster",
+            &[],
+            subsystems::CLUSTER_HEALTH
+        );
+}
diff --git a/crates/obs/src/metrics/cluster_iam.rs b/crates/obs/src/metrics/cluster_iam.rs
new file mode 100644
index 00000000..29a15cf8
--- /dev/null
+++ b/crates/obs/src/metrics/cluster_iam.rs
@@ -0,0 +1,84 @@
+/// IAM related metric descriptors
+use crate::metrics::{MetricDescriptor, MetricName, new_counter_md, subsystems};
+
+lazy_static::lazy_static! {
+    pub static ref LAST_SYNC_DURATION_MILLIS_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::LastSyncDurationMillis,
+            "Last successful IAM data sync duration in milliseconds",
+            &[],
+            subsystems::CLUSTER_IAM
+        );
+
+    pub static ref PLUGIN_AUTHN_SERVICE_FAILED_REQUESTS_MINUTE_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::PluginAuthnServiceFailedRequestsMinute,
+            "When plugin authentication is configured, returns failed requests count in the last full minute",
+            &[],
+            subsystems::CLUSTER_IAM
+        );
+
+    pub static ref PLUGIN_AUTHN_SERVICE_LAST_FAIL_SECONDS_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::PluginAuthnServiceLastFailSeconds,
+            "When plugin authentication is configured, returns time (in seconds) since the last failed request to the service",
+            &[],
+            subsystems::CLUSTER_IAM
+        );
+
+    pub static ref PLUGIN_AUTHN_SERVICE_LAST_SUCC_SECONDS_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::PluginAuthnServiceLastSuccSeconds,
+            "When plugin authentication is configured, returns time (in seconds) since the last successful request to the service",
+            &[],
+            subsystems::CLUSTER_IAM
+        );
+
+    pub static ref PLUGIN_AUTHN_SERVICE_SUCC_AVG_RTT_MS_MINUTE_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::PluginAuthnServiceSuccAvgRttMsMinute,
+            "When plugin authentication is configured, returns average round-trip-time of successful requests in the last full minute",
+            &[],
+            subsystems::CLUSTER_IAM
+        );
+
+    pub static ref PLUGIN_AUTHN_SERVICE_SUCC_MAX_RTT_MS_MINUTE_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::PluginAuthnServiceSuccMaxRttMsMinute,
+            "When plugin authentication is configured, returns maximum round-trip-time of successful requests in the last full minute",
+            &[],
+            subsystems::CLUSTER_IAM
+        );
+
+    pub static ref PLUGIN_AUTHN_SERVICE_TOTAL_REQUESTS_MINUTE_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::PluginAuthnServiceTotalRequestsMinute,
+            "When plugin authentication is configured, returns total requests count in the last full minute",
+            &[],
+            subsystems::CLUSTER_IAM
+        );
+
+    pub static ref SINCE_LAST_SYNC_MILLIS_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::SinceLastSyncMillis,
+            "Time (in milliseconds) since last successful IAM data sync.",
+            &[],
+            subsystems::CLUSTER_IAM
+        );
+
+    pub static ref SYNC_FAILURES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::SyncFailures,
+            "Number of failed IAM data syncs since server start.",
+            &[],
+            subsystems::CLUSTER_IAM
+        );
+
+    pub static ref SYNC_SUCCESSES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::SyncSuccesses,
+            "Number of successful IAM data syncs since server start.",
+            &[],
+            subsystems::CLUSTER_IAM
+        );
+}
diff --git a/crates/obs/src/metrics/cluster_notification.rs b/crates/obs/src/metrics/cluster_notification.rs
new file mode 100644
index 00000000..9db517c1
--- /dev/null
+++ b/crates/obs/src/metrics/cluster_notification.rs
@@ -0,0 +1,36 @@
+/// Notify the relevant metric descriptor
+use crate::metrics::{MetricDescriptor, MetricName, new_counter_md, subsystems};
+
+lazy_static::lazy_static! {
+    pub static ref NOTIFICATION_CURRENT_SEND_IN_PROGRESS_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::NotificationCurrentSendInProgress,
+            "Number of concurrent async Send calls active to all targets",
+            &[],
+            subsystems::NOTIFICATION
+        );
+
+    pub static ref NOTIFICATION_EVENTS_ERRORS_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::NotificationEventsErrorsTotal,
+            "Events that were failed to be sent to the targets",
+            &[],
+            subsystems::NOTIFICATION
+        );
+
+    pub static ref NOTIFICATION_EVENTS_SENT_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::NotificationEventsSentTotal,
+            "Total number of events sent to the targets",
+            &[],
+            subsystems::NOTIFICATION
+        );
+
+    pub static ref NOTIFICATION_EVENTS_SKIPPED_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::NotificationEventsSkippedTotal,
+            "Events that were skipped to be sent to the targets due to the in-memory queue being full",
+            &[],
+            subsystems::NOTIFICATION
+        );
+}
diff --git a/crates/obs/src/metrics/cluster_usage.rs b/crates/obs/src/metrics/cluster_usage.rs
new file mode 100644
index 00000000..351e23d5
--- /dev/null
+++ b/crates/obs/src/metrics/cluster_usage.rs
@@ -0,0 +1,131 @@
+/// Descriptors of metrics related to cluster object and bucket usage
+use crate::metrics::{MetricDescriptor, MetricName, new_gauge_md, subsystems};
+
+/// Bucket labels
+pub const BUCKET_LABEL: &str = "bucket";
+/// Range labels
+pub const RANGE_LABEL: &str = "range";
+
+lazy_static::lazy_static! {
+    pub static ref USAGE_SINCE_LAST_UPDATE_SECONDS_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::UsageSinceLastUpdateSeconds,
+            "Time since last update of usage metrics in seconds",
+            &[],
+            subsystems::CLUSTER_USAGE_OBJECTS
+        );
+
+    pub static ref USAGE_TOTAL_BYTES_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::UsageTotalBytes,
+            "Total cluster usage in bytes",
+            &[],
+            subsystems::CLUSTER_USAGE_OBJECTS
+        );
+
+    pub static ref USAGE_OBJECTS_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::UsageObjectsCount,
+            "Total cluster objects count",
+            &[],
+            subsystems::CLUSTER_USAGE_OBJECTS
+        );
+
+    pub static ref USAGE_VERSIONS_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::UsageVersionsCount,
+            "Total cluster object versions (including delete markers) count",
+            &[],
+            subsystems::CLUSTER_USAGE_OBJECTS
+        );
+
+    pub static ref USAGE_DELETE_MARKERS_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::UsageDeleteMarkersCount,
+            "Total cluster delete markers count",
+            &[],
+            subsystems::CLUSTER_USAGE_OBJECTS
+        );
+
+    pub static ref USAGE_BUCKETS_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::UsageBucketsCount,
+            "Total cluster buckets count",
+            &[],
+            subsystems::CLUSTER_USAGE_OBJECTS
+        );
+
+    pub static ref USAGE_OBJECTS_DISTRIBUTION_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::UsageSizeDistribution,
+            "Cluster object size distribution",
+            &[RANGE_LABEL],
+            subsystems::CLUSTER_USAGE_OBJECTS
+        );
+
+    pub static ref USAGE_VERSIONS_DISTRIBUTION_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::UsageVersionCountDistribution,
+            "Cluster object version count distribution",
+            &[RANGE_LABEL],
+            subsystems::CLUSTER_USAGE_OBJECTS
+        );
+}
+
+lazy_static::lazy_static! {
+    pub static ref USAGE_BUCKET_TOTAL_BYTES_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::UsageBucketTotalBytes,
+            "Total bucket size in bytes",
+            &[BUCKET_LABEL],
+            subsystems::CLUSTER_USAGE_BUCKETS
+        );
+
+    pub static ref USAGE_BUCKET_OBJECTS_TOTAL_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::UsageBucketObjectsCount,
+            "Total objects count in bucket",
+            &[BUCKET_LABEL],
+            subsystems::CLUSTER_USAGE_BUCKETS
+        );
+
+    pub static ref USAGE_BUCKET_VERSIONS_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::UsageBucketVersionsCount,
+            "Total object versions (including delete markers) count in bucket",
+            &[BUCKET_LABEL],
+            subsystems::CLUSTER_USAGE_BUCKETS
+        );
+
+    pub static ref USAGE_BUCKET_DELETE_MARKERS_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::UsageBucketDeleteMarkersCount,
+            "Total delete markers count in bucket",
+            &[BUCKET_LABEL],
+            subsystems::CLUSTER_USAGE_BUCKETS
+        );
+
+    pub static ref USAGE_BUCKET_QUOTA_TOTAL_BYTES_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::UsageBucketQuotaTotalBytes,
+            "Total bucket quota in bytes",
+            &[BUCKET_LABEL],
+            subsystems::CLUSTER_USAGE_BUCKETS
+        );
+
+    pub static ref USAGE_BUCKET_OBJECT_SIZE_DISTRIBUTION_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::UsageBucketObjectSizeDistribution,
+            "Bucket object size distribution",
+            &[RANGE_LABEL, BUCKET_LABEL],
+            subsystems::CLUSTER_USAGE_BUCKETS
+        );
+
+    pub static ref USAGE_BUCKET_OBJECT_VERSION_COUNT_DISTRIBUTION_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::UsageBucketObjectVersionCountDistribution,
+            "Bucket object version count distribution",
+            &[RANGE_LABEL, BUCKET_LABEL],
+            subsystems::CLUSTER_USAGE_BUCKETS
+        );
+}
diff --git a/crates/obs/src/metrics/entry/descriptor.rs b/crates/obs/src/metrics/entry/descriptor.rs
new file mode 100644
index 00000000..30d1cdc0
--- /dev/null
+++ b/crates/obs/src/metrics/entry/descriptor.rs
@@ -0,0 +1,67 @@
+use crate::metrics::{MetricName, MetricNamespace, MetricSubsystem, MetricType};
+use std::collections::HashSet;
+
+/// MetricDescriptor - Metric descriptors
+#[allow(dead_code)]
+#[derive(Debug, Clone)]
+pub struct MetricDescriptor {
+    pub name: MetricName,
+    pub metric_type: MetricType,
+    pub help: String,
+    pub variable_labels: Vec<String>,
+    pub namespace: MetricNamespace,
+    pub subsystem: MetricSubsystem,
+
+    // Internal management values
+    label_set: Option<HashSet<String>>,
+}
+
+impl MetricDescriptor {
+    /// Create a new metric descriptor
+    pub fn new(
+        name: MetricName,
+        metric_type: MetricType,
+        help: String,
+        variable_labels: Vec<String>,
+        namespace: MetricNamespace,
+        subsystem: impl Into<MetricSubsystem>, // Modify the parameter type
+    ) -> Self {
+        Self {
+            name,
+            metric_type,
+            help,
+            variable_labels,
+            namespace,
+            subsystem: subsystem.into(),
+            label_set: None,
+        }
+    }
+
+    /// Get the full metric name, including the prefix and formatting path
+    #[allow(dead_code)]
+    pub fn get_full_metric_name(&self) -> String {
+        let prefix = self.metric_type.as_prom();
+        let namespace = self.namespace.as_str();
+        let formatted_subsystem = self.subsystem.as_str();
+
+        format!("{}{}_{}_{}", prefix, namespace, formatted_subsystem, self.name.as_str())
+    }
+
+    /// check whether the label is in the label set
+    #[allow(dead_code)]
+    pub fn has_label(&mut self, label: &str) -> bool {
+        self.get_label_set().contains(label)
+    }
+
+    /// Gets a collection of tags and creates them if they don't exist
+    pub fn get_label_set(&mut self) -> &HashSet<String> {
+        if self.label_set.is_none() {
+            let mut set = HashSet::with_capacity(self.variable_labels.len());
+            for label in &self.variable_labels {
+                set.insert(label.clone());
+            }
+            self.label_set = Some(set);
+        }
+        self.label_set.as_ref().unwrap()
+    }
+}
diff --git a/crates/obs/src/metrics/entry/metric_name.rs b/crates/obs/src/metrics/entry/metric_name.rs
new file mode 100644
index 00000000..0da80692
--- /dev/null
+++ b/crates/obs/src/metrics/entry/metric_name.rs
@@ -0,0 +1,666 @@
+/// The metric name is the individual name of the metric
+#[allow(dead_code)]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum MetricName {
+    // The generic metric name
+    AuthTotal,
+    CanceledTotal,
+    ErrorsTotal,
+    HeaderTotal,
+    HealTotal,
+    HitsTotal,
+    InflightTotal,
+    InvalidTotal,
+    LimitTotal,
+    MissedTotal,
+    WaitingTotal,
+    IncomingTotal,
+    ObjectTotal,
+    VersionTotal,
+    DeleteMarkerTotal,
+    OfflineTotal,
+    OnlineTotal,
+    OpenTotal,
+    ReadTotal,
+    TimestampTotal,
+    WriteTotal,
+    Total,
+    FreeInodes,
+
+    // Failure statistical metrics
+    LastMinFailedCount,
+    LastMinFailedBytes,
+    LastHourFailedCount,
+    LastHourFailedBytes,
+    TotalFailedCount,
+    TotalFailedBytes,
+
+    // Worker metrics
+    CurrActiveWorkers,
+    AvgActiveWorkers,
+    MaxActiveWorkers,
+    RecentBacklogCount,
+    CurrInQueueCount,
+    CurrInQueueBytes,
+    ReceivedCount,
+    SentCount,
+    CurrTransferRate,
+    AvgTransferRate,
+    MaxTransferRate,
+    CredentialErrors,
+
+    // Link latency metrics
+    CurrLinkLatency,
+    AvgLinkLatency,
+    MaxLinkLatency,
+
+    // Link status metrics
+    LinkOnline,
+    LinkOfflineDuration,
+    LinkDowntimeTotalDuration,
+
+    // Queue metrics
+    AvgInQueueCount,
+    AvgInQueueBytes,
+    MaxInQueueCount,
+    MaxInQueueBytes,
+
+    // Proxy request metrics
+    ProxiedGetRequestsTotal,
+    ProxiedHeadRequestsTotal,
+    ProxiedPutTaggingRequestsTotal,
+    ProxiedGetTaggingRequestsTotal,
+    ProxiedDeleteTaggingRequestsTotal,
+    ProxiedGetRequestsFailures,
+    ProxiedHeadRequestsFailures,
+    ProxiedPutTaggingRequestFailures,
+    ProxiedGetTaggingRequestFailures,
+    ProxiedDeleteTaggingRequestFailures,
+
+    // Byte-related metrics
+    FreeBytes,
+    ReadBytes,
+    RcharBytes,
+    ReceivedBytes,
+    LatencyMilliSec,
+    SentBytes,
+    TotalBytes,
+    UsedBytes,
+    WriteBytes,
+    WcharBytes,
+
+    // Latency metrics
+    LatencyMicroSec,
+    LatencyNanoSec,
+
+    // Information metrics
+    CommitInfo,
+    UsageInfo,
+    VersionInfo,
+
+    // Distribution metrics
+    SizeDistribution,
+    VersionDistribution,
+    TtfbDistribution,
+    TtlbDistribution,
+
+    // Time metrics
+    LastActivityTime,
+    StartTime,
+    UpTime,
+    Memory,
+    Vmemory,
+    Cpu,
+
+    // Expiration and conversion metrics
+    ExpiryMissedTasks,
+    ExpiryMissedFreeVersions,
+    ExpiryMissedTierJournalTasks,
+    ExpiryNumWorkers,
+    TransitionMissedTasks,
+    TransitionedBytes,
+    TransitionedObjects,
+    TransitionedVersions,
+
+    //Tier request metrics
+    TierRequestsSuccess,
+    TierRequestsFailure,
+
+    // KMS metrics
+    KmsOnline,
+    KmsRequestsSuccess,
+    KmsRequestsError,
+    KmsRequestsFail,
+    KmsUptime,
+
+    // Webhook metrics
+    WebhookOnline,
+
+    // API 拒绝指标
+    ApiRejectedAuthTotal,
+    ApiRejectedHeaderTotal,
+    ApiRejectedTimestampTotal,
+    ApiRejectedInvalidTotal,
+
+    //API request metrics
+    ApiRequestsWaitingTotal,
+    ApiRequestsIncomingTotal,
+    ApiRequestsInFlightTotal,
+    ApiRequestsTotal,
+    ApiRequestsErrorsTotal,
+    ApiRequests5xxErrorsTotal,
+    ApiRequests4xxErrorsTotal,
+    ApiRequestsCanceledTotal,
+
+    // API distribution metrics
+    ApiRequestsTTFBSecondsDistribution,
+
+    // API traffic metrics
+    ApiTrafficSentBytes,
+    ApiTrafficRecvBytes,
+
+    // Audit metrics
+    AuditFailedMessages,
+    AuditTargetQueueLength,
+    AuditTotalMessages,
+
+    // Metrics related to cluster configurations
+    ConfigRRSParity,
+    ConfigStandardParity,
+
+    // Erasure coding set related metrics
+    ErasureSetOverallWriteQuorum,
+    ErasureSetOverallHealth,
+    ErasureSetReadQuorum,
+    ErasureSetWriteQuorum,
+    ErasureSetOnlineDrivesCount,
+    ErasureSetHealingDrivesCount,
+    ErasureSetHealth,
+    ErasureSetReadTolerance,
+    ErasureSetWriteTolerance,
+    ErasureSetReadHealth,
+    ErasureSetWriteHealth,
+
+    // Cluster health-related metrics
+    HealthDrivesOfflineCount,
+    HealthDrivesOnlineCount,
+    HealthDrivesCount,
+
+    // IAM-related metrics
+    LastSyncDurationMillis,
+    PluginAuthnServiceFailedRequestsMinute,
+    PluginAuthnServiceLastFailSeconds,
+    PluginAuthnServiceLastSuccSeconds,
+    PluginAuthnServiceSuccAvgRttMsMinute,
+    PluginAuthnServiceSuccMaxRttMsMinute,
+    PluginAuthnServiceTotalRequestsMinute,
+    SinceLastSyncMillis,
+    SyncFailures,
+    SyncSuccesses,
+
+    // Notify relevant metrics
+    NotificationCurrentSendInProgress,
+    NotificationEventsErrorsTotal,
+    NotificationEventsSentTotal,
+    NotificationEventsSkippedTotal,
+
+    // Metrics related to the usage of cluster objects
+    UsageSinceLastUpdateSeconds,
+    UsageTotalBytes,
+    UsageObjectsCount,
+    UsageVersionsCount,
+    UsageDeleteMarkersCount,
+    UsageBucketsCount,
+    UsageSizeDistribution,
+    UsageVersionCountDistribution,
+
+    // Metrics related to bucket usage
+    UsageBucketQuotaTotalBytes,
+    UsageBucketTotalBytes,
+    UsageBucketObjectsCount,
+    UsageBucketVersionsCount,
+    UsageBucketDeleteMarkersCount,
+    UsageBucketObjectSizeDistribution,
+    UsageBucketObjectVersionCountDistribution,
+
+    // ILM-related metrics
+    IlmExpiryPendingTasks,
+    IlmTransitionActiveTasks,
+    IlmTransitionPendingTasks,
+    IlmTransitionMissedImmediateTasks,
+    IlmVersionsScanned,
+
+    // Webhook logs
+    WebhookQueueLength,
+    WebhookTotalMessages,
+    WebhookFailedMessages,
+
+    // Copy the relevant metrics
+    ReplicationAverageActiveWorkers,
+    ReplicationAverageQueuedBytes,
+    ReplicationAverageQueuedCount,
+    ReplicationAverageDataTransferRate,
+    ReplicationCurrentActiveWorkers,
+    ReplicationCurrentDataTransferRate,
+    ReplicationLastMinuteQueuedBytes,
+    ReplicationLastMinuteQueuedCount,
+    ReplicationMaxActiveWorkers,
+    ReplicationMaxQueuedBytes,
+    ReplicationMaxQueuedCount,
+    ReplicationMaxDataTransferRate,
+    ReplicationRecentBacklogCount,
+
+    // Scanner-related metrics
+    ScannerBucketScansFinished,
+    ScannerBucketScansStarted,
+    ScannerDirectoriesScanned,
+    ScannerObjectsScanned,
+    ScannerVersionsScanned,
+    ScannerLastActivitySeconds,
+
+    // CPU system-related metrics
+    SysCPUAvgIdle,
+    SysCPUAvgIOWait,
+    SysCPULoad,
+    SysCPULoadPerc,
+    SysCPUNice,
+    SysCPUSteal,
+    SysCPUSystem,
+    SysCPUUser,
+
+    // Drive-related metrics
+    DriveUsedBytes,
+    DriveFreeBytes,
+    DriveTotalBytes,
+    DriveUsedInodes,
+    DriveFreeInodes,
+    DriveTotalInodes,
+    DriveTimeoutErrorsTotal,
+    DriveIOErrorsTotal,
+    DriveAvailabilityErrorsTotal,
+    DriveWaitingIO,
+    DriveAPILatencyMicros,
+    DriveHealth,
+
+    DriveOfflineCount,
+    DriveOnlineCount,
+    DriveCount,
+
+    // iostat related metrics
+    DriveReadsPerSec,
+    DriveReadsKBPerSec,
+    DriveReadsAwait,
+    DriveWritesPerSec,
+    DriveWritesKBPerSec,
+    DriveWritesAwait,
+    DrivePercUtil,
+
+    // Memory-related metrics
+    MemTotal,
+    MemUsed,
+    MemUsedPerc,
+    MemFree,
+    MemBuffers,
+    MemCache,
+    MemShared,
+    MemAvailable,
+
+    // Network-related metrics
+    InternodeErrorsTotal,
+    InternodeDialErrorsTotal,
+    InternodeDialAvgTimeNanos,
+    InternodeSentBytesTotal,
+    InternodeRecvBytesTotal,
+
+    // Process-related metrics
+    ProcessLocksReadTotal,
+    ProcessLocksWriteTotal,
+    ProcessCPUTotalSeconds,
+    ProcessGoRoutineTotal,
+    ProcessIORCharBytes,
+    ProcessIOReadBytes,
+    ProcessIOWCharBytes,
+    ProcessIOWriteBytes,
+    ProcessStartTimeSeconds,
+    ProcessUptimeSeconds,
+    ProcessFileDescriptorLimitTotal,
+    ProcessFileDescriptorOpenTotal,
+    ProcessSyscallReadTotal,
+    ProcessSyscallWriteTotal,
+    ProcessResidentMemoryBytes,
+    ProcessVirtualMemoryBytes,
+    ProcessVirtualMemoryMaxBytes,
+
+    // Custom metrics
+    Custom(String),
+}
+
+impl MetricName {
+    #[allow(dead_code)]
+    pub fn as_str(&self) -> String {
+        match self {
+            Self::AuthTotal => "auth_total".to_string(),
+            Self::CanceledTotal => "canceled_total".to_string(),
+            Self::ErrorsTotal => "errors_total".to_string(),
+            Self::HeaderTotal => "header_total".to_string(),
+            Self::HealTotal => "heal_total".to_string(),
+            Self::HitsTotal => "hits_total".to_string(),
+            Self::InflightTotal => "inflight_total".to_string(),
+            Self::InvalidTotal => "invalid_total".to_string(),
+            Self::LimitTotal => "limit_total".to_string(),
+            Self::MissedTotal => "missed_total".to_string(),
+            Self::WaitingTotal => "waiting_total".to_string(),
+            Self::IncomingTotal => "incoming_total".to_string(),
+            Self::ObjectTotal => "object_total".to_string(),
+            Self::VersionTotal => "version_total".to_string(),
+            Self::DeleteMarkerTotal => "deletemarker_total".to_string(),
+            Self::OfflineTotal => "offline_total".to_string(),
+            Self::OnlineTotal => "online_total".to_string(),
+            Self::OpenTotal => "open_total".to_string(),
+            Self::ReadTotal => "read_total".to_string(),
+            Self::TimestampTotal => "timestamp_total".to_string(),
+            Self::WriteTotal => "write_total".to_string(),
+            Self::Total => "total".to_string(),
+            Self::FreeInodes => "free_inodes".to_string(),
+
+            Self::LastMinFailedCount => "last_minute_failed_count".to_string(),
+            Self::LastMinFailedBytes => "last_minute_failed_bytes".to_string(),
+            Self::LastHourFailedCount => "last_hour_failed_count".to_string(),
+            Self::LastHourFailedBytes => "last_hour_failed_bytes".to_string(),
+            Self::TotalFailedCount => "total_failed_count".to_string(),
+            Self::TotalFailedBytes => "total_failed_bytes".to_string(),
+
+            Self::CurrActiveWorkers => "current_active_workers".to_string(),
+            Self::AvgActiveWorkers => "average_active_workers".to_string(),
+            Self::MaxActiveWorkers => "max_active_workers".to_string(),
+            Self::RecentBacklogCount => "recent_backlog_count".to_string(),
+            Self::CurrInQueueCount => "last_minute_queued_count".to_string(),
+            Self::CurrInQueueBytes => "last_minute_queued_bytes".to_string(),
+            Self::ReceivedCount => "received_count".to_string(),
+            Self::SentCount => "sent_count".to_string(),
+            Self::CurrTransferRate => "current_transfer_rate".to_string(),
+            Self::AvgTransferRate => "average_transfer_rate".to_string(),
+            Self::MaxTransferRate => "max_transfer_rate".to_string(),
+            Self::CredentialErrors => "credential_errors".to_string(),
+
+            Self::CurrLinkLatency => "current_link_latency_ms".to_string(),
+            Self::AvgLinkLatency => "average_link_latency_ms".to_string(),
+            Self::MaxLinkLatency => "max_link_latency_ms".to_string(),
+
+            Self::LinkOnline => "link_online".to_string(),
+            Self::LinkOfflineDuration => "link_offline_duration_seconds".to_string(),
+            Self::LinkDowntimeTotalDuration => "link_downtime_duration_seconds".to_string(),
+
+            Self::AvgInQueueCount => "average_queued_count".to_string(),
+            Self::AvgInQueueBytes => "average_queued_bytes".to_string(),
+            Self::MaxInQueueCount => "max_queued_count".to_string(),
+            Self::MaxInQueueBytes => "max_queued_bytes".to_string(),
+
+            Self::ProxiedGetRequestsTotal => "proxied_get_requests_total".to_string(),
+            Self::ProxiedHeadRequestsTotal => "proxied_head_requests_total".to_string(),
+            Self::ProxiedPutTaggingRequestsTotal => "proxied_put_tagging_requests_total".to_string(),
+            Self::ProxiedGetTaggingRequestsTotal => "proxied_get_tagging_requests_total".to_string(),
+            Self::ProxiedDeleteTaggingRequestsTotal => "proxied_delete_tagging_requests_total".to_string(),
+            Self::ProxiedGetRequestsFailures => "proxied_get_requests_failures".to_string(),
+            Self::ProxiedHeadRequestsFailures => "proxied_head_requests_failures".to_string(),
+            Self::ProxiedPutTaggingRequestFailures => "proxied_put_tagging_requests_failures".to_string(),
+            Self::ProxiedGetTaggingRequestFailures => "proxied_get_tagging_requests_failures".to_string(),
+            Self::ProxiedDeleteTaggingRequestFailures => "proxied_delete_tagging_requests_failures".to_string(),
+
+            Self::FreeBytes => "free_bytes".to_string(),
+            Self::ReadBytes => "read_bytes".to_string(),
+            Self::RcharBytes => "rchar_bytes".to_string(),
+            Self::ReceivedBytes => "received_bytes".to_string(),
+            Self::LatencyMilliSec => "latency_ms".to_string(),
+            Self::SentBytes => "sent_bytes".to_string(),
+            Self::TotalBytes => "total_bytes".to_string(),
+            Self::UsedBytes => "used_bytes".to_string(),
+            Self::WriteBytes => "write_bytes".to_string(),
+            Self::WcharBytes => "wchar_bytes".to_string(),
+
+            Self::LatencyMicroSec => "latency_us".to_string(),
+            Self::LatencyNanoSec => "latency_ns".to_string(),
+
+            Self::CommitInfo => "commit_info".to_string(),
+            Self::UsageInfo => "usage_info".to_string(),
+            Self::VersionInfo => "version_info".to_string(),
+
+            Self::SizeDistribution => "size_distribution".to_string(),
+            Self::VersionDistribution => "version_distribution".to_string(),
+            Self::TtfbDistribution => "seconds_distribution".to_string(),
+            Self::TtlbDistribution => "ttlb_seconds_distribution".to_string(),
+
+            Self::LastActivityTime => "last_activity_nano_seconds".to_string(),
+            Self::StartTime => "starttime_seconds".to_string(),
+            Self::UpTime => "uptime_seconds".to_string(),
+            Self::Memory => "resident_memory_bytes".to_string(),
+            Self::Vmemory => "virtual_memory_bytes".to_string(),
+            Self::Cpu => "cpu_total_seconds".to_string(),
+
+            Self::ExpiryMissedTasks => "expiry_missed_tasks".to_string(),
+            Self::ExpiryMissedFreeVersions => "expiry_missed_freeversions".to_string(),
+            Self::ExpiryMissedTierJournalTasks => "expiry_missed_tierjournal_tasks".to_string(),
+            Self::ExpiryNumWorkers => "expiry_num_workers".to_string(),
+            Self::TransitionMissedTasks => "transition_missed_immediate_tasks".to_string(),
+
+            Self::TransitionedBytes => "transitioned_bytes".to_string(),
+            Self::TransitionedObjects => "transitioned_objects".to_string(),
+            Self::TransitionedVersions => "transitioned_versions".to_string(),
+
+            Self::TierRequestsSuccess => "requests_success".to_string(),
+            Self::TierRequestsFailure => "requests_failure".to_string(),
+
+            Self::KmsOnline => "online".to_string(),
+            Self::KmsRequestsSuccess => "request_success".to_string(),
+            Self::KmsRequestsError => "request_error".to_string(),
+            Self::KmsRequestsFail => "request_failure".to_string(),
+            Self::KmsUptime => "uptime".to_string(),
+
+            Self::WebhookOnline => "online".to_string(),
+
+            Self::ApiRejectedAuthTotal => "rejected_auth_total".to_string(),
+            Self::ApiRejectedHeaderTotal => "rejected_header_total".to_string(),
+            Self::ApiRejectedTimestampTotal => "rejected_timestamp_total".to_string(),
+            Self::ApiRejectedInvalidTotal => "rejected_invalid_total".to_string(),
+
+            Self::ApiRequestsWaitingTotal => "waiting_total".to_string(),
+            Self::ApiRequestsIncomingTotal => "incoming_total".to_string(),
+            Self::ApiRequestsInFlightTotal => "inflight_total".to_string(),
+            Self::ApiRequestsTotal => "total".to_string(),
+            Self::ApiRequestsErrorsTotal => "errors_total".to_string(),
+            Self::ApiRequests5xxErrorsTotal => "5xx_errors_total".to_string(),
+            Self::ApiRequests4xxErrorsTotal => "4xx_errors_total".to_string(),
+            Self::ApiRequestsCanceledTotal => "canceled_total".to_string(),
+
+            Self::ApiRequestsTTFBSecondsDistribution => "ttfb_seconds_distribution".to_string(),
+
+            Self::ApiTrafficSentBytes => "traffic_sent_bytes".to_string(),
+            Self::ApiTrafficRecvBytes => "traffic_received_bytes".to_string(),
+
+            Self::AuditFailedMessages => "failed_messages".to_string(),
+            Self::AuditTargetQueueLength => "target_queue_length".to_string(),
+            Self::AuditTotalMessages => "total_messages".to_string(),
+
+            // metrics related to cluster configurations
+            Self::ConfigRRSParity => "rrs_parity".to_string(),
+            Self::ConfigStandardParity => "standard_parity".to_string(),
+
+            // Erasure coding set related metrics
+            Self::ErasureSetOverallWriteQuorum => "overall_write_quorum".to_string(),
+            Self::ErasureSetOverallHealth => "overall_health".to_string(),
+            Self::ErasureSetReadQuorum => "read_quorum".to_string(),
+            Self::ErasureSetWriteQuorum => "write_quorum".to_string(),
+            Self::ErasureSetOnlineDrivesCount => "online_drives_count".to_string(),
+            Self::ErasureSetHealingDrivesCount => "healing_drives_count".to_string(),
+            Self::ErasureSetHealth => "health".to_string(),
+            Self::ErasureSetReadTolerance => "read_tolerance".to_string(),
+            Self::ErasureSetWriteTolerance => "write_tolerance".to_string(),
+            Self::ErasureSetReadHealth => "read_health".to_string(),
+            Self::ErasureSetWriteHealth => "write_health".to_string(),
+
+            // Cluster health-related metrics
+            Self::HealthDrivesOfflineCount => "drives_offline_count".to_string(),
+            Self::HealthDrivesOnlineCount => "drives_online_count".to_string(),
+            Self::HealthDrivesCount => "drives_count".to_string(),
+
+            // IAM-related metrics
+            Self::LastSyncDurationMillis => "last_sync_duration_millis".to_string(),
+            Self::PluginAuthnServiceFailedRequestsMinute => "plugin_authn_service_failed_requests_minute".to_string(),
+            Self::PluginAuthnServiceLastFailSeconds => "plugin_authn_service_last_fail_seconds".to_string(),
+            Self::PluginAuthnServiceLastSuccSeconds => "plugin_authn_service_last_succ_seconds".to_string(),
+            Self::PluginAuthnServiceSuccAvgRttMsMinute => "plugin_authn_service_succ_avg_rtt_ms_minute".to_string(),
+            Self::PluginAuthnServiceSuccMaxRttMsMinute => "plugin_authn_service_succ_max_rtt_ms_minute".to_string(),
+            Self::PluginAuthnServiceTotalRequestsMinute => "plugin_authn_service_total_requests_minute".to_string(),
+            Self::SinceLastSyncMillis => "since_last_sync_millis".to_string(),
+            Self::SyncFailures => "sync_failures".to_string(),
+            Self::SyncSuccesses => "sync_successes".to_string(),
+
+            // Notify relevant metrics
+            Self::NotificationCurrentSendInProgress => "current_send_in_progress".to_string(),
+            Self::NotificationEventsErrorsTotal => "events_errors_total".to_string(),
+            Self::NotificationEventsSentTotal => "events_sent_total".to_string(),
+            Self::NotificationEventsSkippedTotal => "events_skipped_total".to_string(),
+
+            // Metrics related to the usage of cluster objects
+            Self::UsageSinceLastUpdateSeconds => "since_last_update_seconds".to_string(),
+            Self::UsageTotalBytes => "total_bytes".to_string(),
+            Self::UsageObjectsCount => "count".to_string(),
+            Self::UsageVersionsCount => "versions_count".to_string(),
+            Self::UsageDeleteMarkersCount => "delete_markers_count".to_string(),
+            Self::UsageBucketsCount => "buckets_count".to_string(),
+            Self::UsageSizeDistribution => "size_distribution".to_string(),
+            Self::UsageVersionCountDistribution => "version_count_distribution".to_string(),
+
+            // Metrics related to bucket usage
+            Self::UsageBucketQuotaTotalBytes => "quota_total_bytes".to_string(),
+            Self::UsageBucketTotalBytes => "total_bytes".to_string(),
+            Self::UsageBucketObjectsCount => "objects_count".to_string(),
+            Self::UsageBucketVersionsCount => "versions_count".to_string(),
+            Self::UsageBucketDeleteMarkersCount => "delete_markers_count".to_string(),
+            Self::UsageBucketObjectSizeDistribution => "object_size_distribution".to_string(),
+            Self::UsageBucketObjectVersionCountDistribution => "object_version_count_distribution".to_string(),
+
+            // ILM-related metrics
+            Self::IlmExpiryPendingTasks => "expiry_pending_tasks".to_string(),
+            Self::IlmTransitionActiveTasks => "transition_active_tasks".to_string(),
+            Self::IlmTransitionPendingTasks => "transition_pending_tasks".to_string(),
+            Self::IlmTransitionMissedImmediateTasks => "transition_missed_immediate_tasks".to_string(),
+            Self::IlmVersionsScanned => "versions_scanned".to_string(),
+
+            // Webhook logs
+            Self::WebhookQueueLength => "queue_length".to_string(),
+            Self::WebhookTotalMessages => "total_messages".to_string(),
+            Self::WebhookFailedMessages => "failed_messages".to_string(),
+
+            // Copy the relevant metrics
+            Self::ReplicationAverageActiveWorkers => "average_active_workers".to_string(),
+            Self::ReplicationAverageQueuedBytes => "average_queued_bytes".to_string(),
+            Self::ReplicationAverageQueuedCount => "average_queued_count".to_string(),
+            Self::ReplicationAverageDataTransferRate => "average_data_transfer_rate".to_string(),
+            Self::ReplicationCurrentActiveWorkers => "current_active_workers".to_string(),
+            Self::ReplicationCurrentDataTransferRate => "current_data_transfer_rate".to_string(),
+            Self::ReplicationLastMinuteQueuedBytes => "last_minute_queued_bytes".to_string(),
+            Self::ReplicationLastMinuteQueuedCount => "last_minute_queued_count".to_string(),
+            Self::ReplicationMaxActiveWorkers => "max_active_workers".to_string(),
+            Self::ReplicationMaxQueuedBytes => "max_queued_bytes".to_string(),
+            Self::ReplicationMaxQueuedCount => "max_queued_count".to_string(),
+            Self::ReplicationMaxDataTransferRate => "max_data_transfer_rate".to_string(),
+            Self::ReplicationRecentBacklogCount => "recent_backlog_count".to_string(),
+
+            // Scanner-related metrics
+            Self::ScannerBucketScansFinished => "bucket_scans_finished".to_string(),
+            Self::ScannerBucketScansStarted => "bucket_scans_started".to_string(),
+            Self::ScannerDirectoriesScanned => "directories_scanned".to_string(),
+            Self::ScannerObjectsScanned => "objects_scanned".to_string(),
+            Self::ScannerVersionsScanned => "versions_scanned".to_string(),
+            Self::ScannerLastActivitySeconds => "last_activity_seconds".to_string(),
+
+            // CPU system-related metrics
+            Self::SysCPUAvgIdle => "avg_idle".to_string(),
+            Self::SysCPUAvgIOWait => "avg_iowait".to_string(),
+            Self::SysCPULoad => "load".to_string(),
+            Self::SysCPULoadPerc => "load_perc".to_string(),
+            Self::SysCPUNice => "nice".to_string(),
+            Self::SysCPUSteal => "steal".to_string(),
+            Self::SysCPUSystem => "system".to_string(),
+            Self::SysCPUUser => "user".to_string(),
+
+            // Drive-related metrics
+            Self::DriveUsedBytes => "used_bytes".to_string(),
+            Self::DriveFreeBytes => "free_bytes".to_string(),
+            Self::DriveTotalBytes => "total_bytes".to_string(),
+            Self::DriveUsedInodes => "used_inodes".to_string(),
+            Self::DriveFreeInodes => "free_inodes".to_string(),
+            Self::DriveTotalInodes => "total_inodes".to_string(),
+            Self::DriveTimeoutErrorsTotal => "timeout_errors_total".to_string(),
+            Self::DriveIOErrorsTotal => "io_errors_total".to_string(),
+            Self::DriveAvailabilityErrorsTotal => "availability_errors_total".to_string(),
+            Self::DriveWaitingIO => "waiting_io".to_string(),
+            Self::DriveAPILatencyMicros => "api_latency_micros".to_string(),
+            Self::DriveHealth => "health".to_string(),
+
+            Self::DriveOfflineCount => "offline_count".to_string(),
+            Self::DriveOnlineCount => "online_count".to_string(),
+            Self::DriveCount => "count".to_string(),
+
+            // iostat related metrics
+            Self::DriveReadsPerSec => "reads_per_sec".to_string(),
+            Self::DriveReadsKBPerSec => "reads_kb_per_sec".to_string(),
+            Self::DriveReadsAwait => "reads_await".to_string(),
+            Self::DriveWritesPerSec => "writes_per_sec".to_string(),
+            Self::DriveWritesKBPerSec => "writes_kb_per_sec".to_string(),
+            Self::DriveWritesAwait => "writes_await".to_string(),
+            Self::DrivePercUtil => "perc_util".to_string(),
+
+            // Memory-related metrics
+            Self::MemTotal => "total".to_string(),
+            Self::MemUsed => "used".to_string(),
+            Self::MemUsedPerc => "used_perc".to_string(),
+            Self::MemFree => "free".to_string(),
+            Self::MemBuffers => "buffers".to_string(),
+            Self::MemCache => "cache".to_string(),
+            Self::MemShared => "shared".to_string(),
+            Self::MemAvailable => "available".to_string(),
+
+            // Network-related metrics
+            Self::InternodeErrorsTotal => "errors_total".to_string(),
+            Self::InternodeDialErrorsTotal => "dial_errors_total".to_string(),
+            Self::InternodeDialAvgTimeNanos => "dial_avg_time_nanos".to_string(),
+            Self::InternodeSentBytesTotal => "sent_bytes_total".to_string(),
+            Self::InternodeRecvBytesTotal => "recv_bytes_total".to_string(),
+
+            // Process-related metrics
+            Self::ProcessLocksReadTotal => "locks_read_total".to_string(),
+            Self::ProcessLocksWriteTotal => "locks_write_total".to_string(),
+            Self::ProcessCPUTotalSeconds => "cpu_total_seconds".to_string(),
+            Self::ProcessGoRoutineTotal => "go_routine_total".to_string(),
+            Self::ProcessIORCharBytes => "io_rchar_bytes".to_string(),
+            Self::ProcessIOReadBytes => "io_read_bytes".to_string(),
+            Self::ProcessIOWCharBytes => "io_wchar_bytes".to_string(),
+            Self::ProcessIOWriteBytes => "io_write_bytes".to_string(),
+            Self::ProcessStartTimeSeconds => "start_time_seconds".to_string(),
+            Self::ProcessUptimeSeconds => "uptime_seconds".to_string(),
+            Self::ProcessFileDescriptorLimitTotal => "file_descriptor_limit_total".to_string(),
+            Self::ProcessFileDescriptorOpenTotal => "file_descriptor_open_total".to_string(),
+            Self::ProcessSyscallReadTotal => "syscall_read_total".to_string(),
+            Self::ProcessSyscallWriteTotal => "syscall_write_total".to_string(),
+            Self::ProcessResidentMemoryBytes => "resident_memory_bytes".to_string(),
+            Self::ProcessVirtualMemoryBytes => "virtual_memory_bytes".to_string(),
+            Self::ProcessVirtualMemoryMaxBytes => "virtual_memory_max_bytes".to_string(),
+
+            Self::Custom(name) => name.clone(),
+        }
+    }
+}
+
+impl From<String> for MetricName {
+    fn from(s: String) -> Self {
+        Self::Custom(s)
+    }
+}
+
+impl From<&str> for MetricName {
+    fn from(s: &str) -> Self {
+        Self::Custom(s.to_string())
+    }
+}
diff --git a/crates/obs/src/metrics/entry/metric_type.rs b/crates/obs/src/metrics/entry/metric_type.rs
new file mode 100644
index 00000000..d9a4a949
--- /dev/null
+++ b/crates/obs/src/metrics/entry/metric_type.rs
@@ -0,0 +1,31 @@
+/// MetricType - Indicates the type of indicator
+#[allow(dead_code)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MetricType {
+    Counter,
+    Gauge,
+    Histogram,
+}
+
+impl MetricType {
+    /// convert the metric type to a string representation
+    #[allow(dead_code)]
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::Counter => "counter",
+            Self::Gauge => "gauge",
+            Self::Histogram => "histogram",
+        }
+    }
+
+    /// Convert the metric type to the Prometheus value type
+    /// In a Rust implementation, this might return the corresponding Prometheus Rust client type
+    #[allow(dead_code)]
+    pub fn as_prom(&self) -> &'static str {
+        match self {
+            Self::Counter => "counter.",
+            Self::Gauge => "gauge.",
+            Self::Histogram => "histogram.", // Histograms still use the counter value in Prometheus
+        }
+    }
+}
diff --git a/crates/obs/src/metrics/entry/mod.rs b/crates/obs/src/metrics/entry/mod.rs
new file mode 100644
index 00000000..93743553
--- /dev/null
+++ b/crates/obs/src/metrics/entry/mod.rs
@@ -0,0 +1,115 @@
+use crate::metrics::{MetricDescriptor, MetricName, MetricNamespace, MetricSubsystem, MetricType};
+
+pub(crate) mod descriptor;
+pub(crate) mod metric_name;
+pub(crate) mod metric_type;
+pub(crate) mod namespace;
+mod path_utils;
+pub(crate) mod subsystem;
+
+/// Create a new counter metric descriptor
+pub fn new_counter_md(
+    name: impl Into<MetricName>,
+    help: impl Into<String>,
+    labels: &[&str],
+    subsystem: impl Into<MetricSubsystem>,
+) -> MetricDescriptor {
+    MetricDescriptor::new(
+        name.into(),
+        MetricType::Counter,
+        help.into(),
+        labels.iter().map(|&s| s.to_string()).collect(),
+        MetricNamespace::RustFS,
+        subsystem,
+    )
+}
+
+/// create a new dashboard metric descriptor
+pub fn new_gauge_md(
+    name: impl Into<MetricName>,
+    help: impl Into<String>,
+    labels: &[&str],
+    subsystem: impl Into<MetricSubsystem>,
+) -> MetricDescriptor {
+    MetricDescriptor::new(
+        name.into(),
+        MetricType::Gauge,
+        help.into(),
+        labels.iter().map(|&s| s.to_string()).collect(),
+        MetricNamespace::RustFS,
+        subsystem,
+    )
+}
+
+/// create a new histogram indicator descriptor
+#[allow(dead_code)]
+pub fn new_histogram_md(
+    name: impl Into<MetricName>,
+    help: impl Into<String>,
+    labels: &[&str],
+    subsystem: impl Into<MetricSubsystem>,
+) -> MetricDescriptor {
+    MetricDescriptor::new(
+        name.into(),
+        MetricType::Histogram,
+        help.into(),
+        labels.iter().map(|&s| s.to_string()).collect(),
+        MetricNamespace::RustFS,
+        subsystem,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::metrics::subsystems;
+
+    #[test]
+    fn test_new_histogram_md() {
+        // create a histogram indicator descriptor
+        let histogram_md = new_histogram_md(
+            MetricName::TtfbDistribution,
+            "test the response time distribution",
+            &["api", "method", "le"],
+            subsystems::API_REQUESTS,
+        );
+
+        // verify that the metric type is correct
+        assert_eq!(histogram_md.metric_type, MetricType::Histogram);
+
+        // verify that the metric name is correct
+        assert_eq!(histogram_md.name.as_str(), "seconds_distribution");
+
+        // verify that the help information is correct
+        assert_eq!(histogram_md.help, "test the response time distribution");
+
+        // Verify that the label is correct
+        assert_eq!(histogram_md.variable_labels.len(), 3);
+        assert!(histogram_md.variable_labels.contains(&"api".to_string()));
+        assert!(histogram_md.variable_labels.contains(&"method".to_string()));
+        assert!(histogram_md.variable_labels.contains(&"le".to_string()));
+
+        // Verify that the namespace is correct
+        assert_eq!(histogram_md.namespace, MetricNamespace::RustFS);
+
+        // Verify that the subsystem is correct
+        assert_eq!(histogram_md.subsystem, MetricSubsystem::ApiRequests);
+
+        // Verify that the full metric name generated is formatted correctly
+        assert_eq!(histogram_md.get_full_metric_name(), "histogram.rustfs_api_requests_seconds_distribution");
+
+        // Tests use custom subsystems
+        let custom_histogram_md = new_histogram_md(
+            "custom_latency_distribution",
+            "custom latency distribution",
+            &["endpoint", "le"],
+            MetricSubsystem::new("/custom/path-metrics"),
+        );
+
+        // Verify the custom name and subsystem
+        assert_eq!(
+            custom_histogram_md.get_full_metric_name(),
+            "histogram.rustfs_custom_path_metrics_custom_latency_distribution"
+        );
+    }
+}
diff --git a/crates/obs/src/metrics/entry/namespace.rs b/crates/obs/src/metrics/entry/namespace.rs
new file mode 100644
index 00000000..0f4db118
--- /dev/null
+++ b/crates/obs/src/metrics/entry/namespace.rs
@@ -0,0 +1,14 @@
+/// The metric namespace, which represents the top-level grouping of the metric
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum MetricNamespace {
+    RustFS,
+}
+
+impl MetricNamespace {
+    #[allow(dead_code)]
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::RustFS => "rustfs",
+        }
+    }
+}
diff --git a/crates/obs/src/metrics/entry/path_utils.rs b/crates/obs/src/metrics/entry/path_utils.rs
new file mode 100644
index 00000000..1275a826
--- /dev/null
+++ b/crates/obs/src/metrics/entry/path_utils.rs
@@ -0,0 +1,19 @@
+/// Format the path to the metric name format
+/// Replace '/' and '-' with '_'
+#[allow(dead_code)]
+pub fn format_path_to_metric_name(path: &str) -> String {
+    path.trim_start_matches('/').replace(['/', '-'], "_")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_format_path_to_metric_name() {
+        assert_eq!(format_path_to_metric_name("/api/requests"), "api_requests");
+        assert_eq!(format_path_to_metric_name("/system/network/internode"), "system_network_internode");
+        assert_eq!(format_path_to_metric_name("/bucket-api"), "bucket_api");
+        assert_eq!(format_path_to_metric_name("cluster/health"), "cluster_health");
+    }
+}
diff --git a/crates/obs/src/metrics/entry/subsystem.rs b/crates/obs/src/metrics/entry/subsystem.rs
new file mode 100644
index 00000000..eeaad997
--- /dev/null
+++ b/crates/obs/src/metrics/entry/subsystem.rs
@@ -0,0 +1,232 @@
+use crate::metrics::entry::path_utils::format_path_to_metric_name;
+
+/// The metrics subsystem is a subgroup of metrics within a namespace
+/// The metrics subsystem, which represents a subgroup of metrics within a namespace
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum MetricSubsystem {
+    // API related subsystems
+    ApiRequests,
+
+    // bucket related subsystems
+    BucketApi,
+    BucketReplication,
+
+    // system related subsystems
+    SystemNetworkInternode,
+    SystemDrive,
+    SystemMemory,
+    SystemCpu,
+    SystemProcess,
+
+    // debug related subsystems
+    DebugGo,
+
+    // cluster related subsystems
+    ClusterHealth,
+    ClusterUsageObjects,
+    ClusterUsageBuckets,
+    ClusterErasureSet,
+    ClusterIam,
+    ClusterConfig,
+
+    // other service related subsystems
+    Ilm,
+    Audit,
+    LoggerWebhook,
+    Replication,
+    Notification,
+    Scanner,
+
+    // Custom paths
+    Custom(String),
+}
+
+impl MetricSubsystem {
+    /// Gets the original path string
+    pub fn path(&self) -> &str {
+        match self {
+            // api related subsystems
+            Self::ApiRequests => "/api/requests",
+
+            // bucket related subsystems
+            Self::BucketApi => "/bucket/api",
+            Self::BucketReplication => "/bucket/replication",
+
+            // system related subsystems
+            Self::SystemNetworkInternode => "/system/network/internode",
+            Self::SystemDrive => "/system/drive",
+            Self::SystemMemory => "/system/memory",
+            Self::SystemCpu => "/system/cpu",
+            Self::SystemProcess => "/system/process",
+
+            // debug related subsystems
+            Self::DebugGo => "/debug/go",
+
+            // cluster related subsystems
+            Self::ClusterHealth => "/cluster/health",
+            Self::ClusterUsageObjects => "/cluster/usage/objects",
+            Self::ClusterUsageBuckets => "/cluster/usage/buckets",
+            Self::ClusterErasureSet => "/cluster/erasure-set",
+            Self::ClusterIam => "/cluster/iam",
+            Self::ClusterConfig => "/cluster/config",
+
+            // other service related subsystems
+            Self::Ilm => "/ilm",
+            Self::Audit => "/audit",
+            Self::LoggerWebhook => "/logger/webhook",
+            Self::Replication => "/replication",
+            Self::Notification => "/notification",
+            Self::Scanner => "/scanner",
+
+            // Custom paths
+            Self::Custom(path) => path,
+        }
+    }
+
+    /// Get the formatted metric name format string
+    #[allow(dead_code)]
+    pub fn as_str(&self) -> String {
+        format_path_to_metric_name(self.path())
+    }
+
+    /// Create a subsystem enumeration from a path string
+    pub fn from_path(path: &str) -> Self {
+        match path {
+            // API-related subsystems
+            "/api/requests" => Self::ApiRequests,
+
+            // Bucket-related subsystems
+            "/bucket/api" => Self::BucketApi,
+            "/bucket/replication" => Self::BucketReplication,
+
+            // System-related subsystems
+            "/system/network/internode" => Self::SystemNetworkInternode,
+            "/system/drive" => Self::SystemDrive,
+            "/system/memory" => Self::SystemMemory,
+            "/system/cpu" => Self::SystemCpu,
+            "/system/process" => Self::SystemProcess,
+
+            // Debug related subsystems
+            "/debug/go" => Self::DebugGo,
+
+            // 集群相关子系统
+            "/cluster/health" => Self::ClusterHealth,
+            "/cluster/usage/objects" => Self::ClusterUsageObjects,
+            "/cluster/usage/buckets" => Self::ClusterUsageBuckets,
+            "/cluster/erasure-set" => Self::ClusterErasureSet,
+            "/cluster/iam" => Self::ClusterIam,
+            "/cluster/config" => Self::ClusterConfig,
+
+            // 其他服务相关子系统
+            "/ilm" => Self::Ilm,
+            "/audit" => Self::Audit,
+            "/logger/webhook" => Self::LoggerWebhook,
+            "/replication" => Self::Replication,
+            "/notification" => Self::Notification,
+            "/scanner" => Self::Scanner,
+
+            // 其他路径作为自定义处理
+            _ => Self::Custom(path.to_string()),
+        }
+    }
+
+    /// A convenient way to create custom subsystems directly
+    #[allow(dead_code)]
+    pub fn new(path: impl Into<String>) -> Self {
+        Self::Custom(path.into())
+    }
+}
+
+/// Implementations that facilitate conversion to and from strings
+impl From<&str> for MetricSubsystem {
+    fn from(s: &str) -> Self {
+        Self::from_path(s)
+    }
+}
+
+impl From<String> for MetricSubsystem {
+    fn from(s: String) -> Self {
+        Self::from_path(&s)
+    }
+}
+
+impl std::fmt::Display for MetricSubsystem {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.path())
+    }
+}
+
+#[allow(dead_code)]
+pub mod subsystems {
+    use super::MetricSubsystem;
+
+    // cluster base path constant
+    pub const CLUSTER_BASE_PATH: &str = "/cluster";
+
+    // Quick access to constants for each subsystem
+    pub const API_REQUESTS: MetricSubsystem = MetricSubsystem::ApiRequests;
+    pub const BUCKET_API: MetricSubsystem = MetricSubsystem::BucketApi;
+    pub const BUCKET_REPLICATION: MetricSubsystem = MetricSubsystem::BucketReplication;
+    pub const SYSTEM_NETWORK_INTERNODE: MetricSubsystem = MetricSubsystem::SystemNetworkInternode;
+    pub const SYSTEM_DRIVE: MetricSubsystem = MetricSubsystem::SystemDrive;
+    pub const SYSTEM_MEMORY: MetricSubsystem = MetricSubsystem::SystemMemory;
+    pub const SYSTEM_CPU: MetricSubsystem = MetricSubsystem::SystemCpu;
+    pub const SYSTEM_PROCESS: MetricSubsystem = MetricSubsystem::SystemProcess;
+    pub const DEBUG_GO: MetricSubsystem = MetricSubsystem::DebugGo;
+    pub const CLUSTER_HEALTH: MetricSubsystem = MetricSubsystem::ClusterHealth;
+    pub const CLUSTER_USAGE_OBJECTS: MetricSubsystem = MetricSubsystem::ClusterUsageObjects;
+    pub const CLUSTER_USAGE_BUCKETS: MetricSubsystem = MetricSubsystem::ClusterUsageBuckets;
+    pub const CLUSTER_ERASURE_SET: MetricSubsystem = MetricSubsystem::ClusterErasureSet;
+    pub const CLUSTER_IAM: MetricSubsystem = MetricSubsystem::ClusterIam;
+    pub const CLUSTER_CONFIG: MetricSubsystem = MetricSubsystem::ClusterConfig;
+    pub const ILM: MetricSubsystem = MetricSubsystem::Ilm;
+    pub const AUDIT: MetricSubsystem = MetricSubsystem::Audit;
+    pub const LOGGER_WEBHOOK: MetricSubsystem = MetricSubsystem::LoggerWebhook;
+    pub const REPLICATION: MetricSubsystem = MetricSubsystem::Replication;
+    pub const NOTIFICATION: MetricSubsystem = MetricSubsystem::Notification;
+    pub const SCANNER: MetricSubsystem = MetricSubsystem::Scanner;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::metrics::MetricType;
+    use crate::metrics::{MetricDescriptor, MetricName, MetricNamespace};
+
+    #[test]
+    fn test_metric_subsystem_formatting() {
+        assert_eq!(MetricSubsystem::ApiRequests.as_str(), "api_requests");
+        assert_eq!(MetricSubsystem::SystemNetworkInternode.as_str(), "system_network_internode");
+        assert_eq!(MetricSubsystem::BucketApi.as_str(), "bucket_api");
+        assert_eq!(MetricSubsystem::ClusterHealth.as_str(), "cluster_health");
+
+        // Test custom paths
+        let custom = MetricSubsystem::new("/custom/path-test");
+        assert_eq!(custom.as_str(), "custom_path_test");
+    }
+
+    #[test]
+    fn test_metric_descriptor_name_generation() {
+        let md = MetricDescriptor::new(
+            MetricName::ApiRequestsTotal,
+            MetricType::Counter,
+            "Test help".to_string(),
+            vec!["label1".to_string(), "label2".to_string()],
+            MetricNamespace::RustFS,
+            MetricSubsystem::ApiRequests,
+        );
+
+        assert_eq!(md.get_full_metric_name(), "counter.rustfs_api_requests_total");
+
+        let custom_md = MetricDescriptor::new(
+            MetricName::Custom("test_metric".to_string()),
+            MetricType::Gauge,
+            "Test help".to_string(),
+            vec!["label1".to_string()],
+            MetricNamespace::RustFS,
+            MetricSubsystem::new("/custom/path-with-dash"),
+        );
+
+        assert_eq!(custom_md.get_full_metric_name(), "gauge.rustfs_custom_path_with_dash_test_metric");
+    }
+}
diff --git a/crates/obs/src/metrics/ilm.rs b/crates/obs/src/metrics/ilm.rs
new file mode 100644
index 00000000..d9a5b9a9
--- /dev/null
+++ b/crates/obs/src/metrics/ilm.rs
@@ -0,0 +1,44 @@
+/// ILM-related metric descriptors
+use crate::metrics::{MetricDescriptor, MetricName, new_counter_md, new_gauge_md, subsystems};
+
+lazy_static::lazy_static! {
+    pub static ref ILM_EXPIRY_PENDING_TASKS_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::IlmExpiryPendingTasks,
+            "Number of pending ILM expiry tasks in the queue",
+            &[],
+            subsystems::ILM
+        );
+
+    pub static ref ILM_TRANSITION_ACTIVE_TASKS_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::IlmTransitionActiveTasks,
+            "Number of active ILM transition tasks",
+            &[],
+            subsystems::ILM
+        );
+
+    pub static ref ILM_TRANSITION_PENDING_TASKS_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::IlmTransitionPendingTasks,
+            "Number of pending ILM transition tasks in the queue",
+            &[],
+            subsystems::ILM
+        );
+
+    pub static ref ILM_TRANSITION_MISSED_IMMEDIATE_TASKS_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::IlmTransitionMissedImmediateTasks,
+            "Number of missed immediate ILM transition tasks",
+            &[],
+            subsystems::ILM
+        );
+
+    pub static ref ILM_VERSIONS_SCANNED_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::IlmVersionsScanned,
+            "Total number of object versions checked for ILM actions since server start",
+            &[],
+            subsystems::ILM
+        );
+}
diff --git a/crates/obs/src/metrics/logger_webhook.rs b/crates/obs/src/metrics/logger_webhook.rs
new file mode 100644
index 00000000..985642a6
--- /dev/null
+++ b/crates/obs/src/metrics/logger_webhook.rs
@@ -0,0 +1,37 @@
+/// A descriptor for metrics related to webhook logs
+use crate::metrics::{MetricDescriptor, MetricName, new_counter_md, new_gauge_md, subsystems};
+
+/// Define label constants for webhook metrics
+/// name label
+pub const NAME_LABEL: &str = "name";
+/// endpoint label
+pub const ENDPOINT_LABEL: &str = "endpoint";
+
+lazy_static::lazy_static! {
+    // The label used by all webhook metrics
+    static ref ALL_WEBHOOK_LABELS: [&'static str; 2] = [NAME_LABEL, ENDPOINT_LABEL];
+
+    pub static ref WEBHOOK_FAILED_MESSAGES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::WebhookFailedMessages,
+            "Number of messages that failed to send",
+            &ALL_WEBHOOK_LABELS[..],
+            subsystems::LOGGER_WEBHOOK
+        );
+
+    pub static ref WEBHOOK_QUEUE_LENGTH_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::WebhookQueueLength,
+            "Webhook queue length",
+            &ALL_WEBHOOK_LABELS[..],
+            subsystems::LOGGER_WEBHOOK
+        );
+
+    pub static ref WEBHOOK_TOTAL_MESSAGES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::WebhookTotalMessages,
+            "Total number of messages sent to this target",
+            &ALL_WEBHOOK_LABELS[..],
+            subsystems::LOGGER_WEBHOOK
+        );
+}
diff --git a/crates/obs/src/metrics/mod.rs b/crates/obs/src/metrics/mod.rs
new file mode 100644
index 00000000..150b3daf
--- /dev/null
+++ b/crates/obs/src/metrics/mod.rs
@@ -0,0 +1,28 @@
+pub(crate) mod audit;
+pub(crate) mod bucket;
+pub(crate) mod bucket_replication;
+pub(crate) mod cluster_config;
+pub(crate) mod cluster_erasure_set;
+pub(crate) mod cluster_health;
+pub(crate) mod cluster_iam;
+pub(crate) mod cluster_notification;
+pub(crate) mod cluster_usage;
+pub(crate) mod entry;
+pub(crate) mod ilm;
+pub(crate) mod logger_webhook;
+pub(crate) mod replication;
+pub(crate) mod request;
+pub(crate) mod scanner;
+pub(crate) mod system_cpu;
+pub(crate) mod system_drive;
+pub(crate) mod system_memory;
+pub(crate) mod system_network;
+pub(crate) mod system_process;
+
+pub use entry::descriptor::MetricDescriptor;
+pub use entry::metric_name::MetricName;
+pub use entry::metric_type::MetricType;
+pub use entry::namespace::MetricNamespace;
+pub use entry::subsystem::MetricSubsystem;
+pub use entry::subsystem::subsystems;
+pub use entry::{new_counter_md, new_gauge_md, new_histogram_md};
diff --git a/crates/obs/src/metrics/replication.rs b/crates/obs/src/metrics/replication.rs
new file mode 100644
index 00000000..c688ff56
--- /dev/null
+++ b/crates/obs/src/metrics/replication.rs
@@ -0,0 +1,108 @@
+/// Copy the relevant metric descriptor
+use crate::metrics::{MetricDescriptor, MetricName, new_gauge_md, subsystems};
+
+lazy_static::lazy_static! {
+    pub static ref REPLICATION_AVERAGE_ACTIVE_WORKERS_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ReplicationAverageActiveWorkers,
+            "Average number of active replication workers",
+            &[],
+            subsystems::REPLICATION
+        );
+
+    pub static ref REPLICATION_AVERAGE_QUEUED_BYTES_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ReplicationAverageQueuedBytes,
+            "Average number of bytes queued for replication since server start",
+            &[],
+            subsystems::REPLICATION
+        );
+
+    pub static ref REPLICATION_AVERAGE_QUEUED_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ReplicationAverageQueuedCount,
+            "Average number of objects queued for replication since server start",
+            &[],
+            subsystems::REPLICATION
+        );
+
+    pub static ref REPLICATION_AVERAGE_DATA_TRANSFER_RATE_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ReplicationAverageDataTransferRate,
+            "Average replication data transfer rate in bytes/sec",
+            &[],
+            subsystems::REPLICATION
+        );
+
+    pub static ref REPLICATION_CURRENT_ACTIVE_WORKERS_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ReplicationCurrentActiveWorkers,
+            "Total number of active replication workers",
+            &[],
+            subsystems::REPLICATION
+        );
+
+    pub static ref REPLICATION_CURRENT_DATA_TRANSFER_RATE_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ReplicationCurrentDataTransferRate,
+            "Current replication data transfer rate in bytes/sec",
+            &[],
+            subsystems::REPLICATION
+        );
+
+    pub static ref REPLICATION_LAST_MINUTE_QUEUED_BYTES_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ReplicationLastMinuteQueuedBytes,
+            "Number of bytes queued for replication in the last full minute",
+            &[],
+            subsystems::REPLICATION
+        );
+
+    pub static ref REPLICATION_LAST_MINUTE_QUEUED_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ReplicationLastMinuteQueuedCount,
+            "Number of objects queued for replication in the last full minute",
+            &[],
+            subsystems::REPLICATION
+        );
+
+    pub static ref REPLICATION_MAX_ACTIVE_WORKERS_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ReplicationMaxActiveWorkers,
+            "Maximum number of active replication workers seen since server start",
+            &[],
+            subsystems::REPLICATION
+        );
+
+    pub static ref REPLICATION_MAX_QUEUED_BYTES_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ReplicationMaxQueuedBytes,
+            "Maximum number of bytes queued for replication since server start",
+            &[],
+            subsystems::REPLICATION
+        );
+
+    pub static ref REPLICATION_MAX_QUEUED_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ReplicationMaxQueuedCount,
+            "Maximum number of objects queued for replication since server start",
+            &[],
+            subsystems::REPLICATION
+        );
+
+    pub static ref REPLICATION_MAX_DATA_TRANSFER_RATE_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ReplicationMaxDataTransferRate,
+            "Maximum replication data transfer rate in bytes/sec seen since server start",
+            &[],
+            subsystems::REPLICATION
+        );
+
+    pub static ref REPLICATION_RECENT_BACKLOG_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ReplicationRecentBacklogCount,
+            "Total number of objects seen in replication backlog in the last 5 minutes",
+            &[],
+            subsystems::REPLICATION
+        );
+}
diff --git a/crates/obs/src/metrics/request.rs b/crates/obs/src/metrics/request.rs
new file mode 100644
index 00000000..b96e66df
--- /dev/null
+++ b/crates/obs/src/metrics/request.rs
@@ -0,0 +1,123 @@
+use crate::metrics::{MetricDescriptor, MetricName, MetricSubsystem, new_counter_md, new_gauge_md, subsystems};
+
+lazy_static::lazy_static! {
+    pub static ref API_REJECTED_AUTH_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ApiRejectedAuthTotal,
+            "Total number of requests rejected for auth failure",
+            &["type"],
+            subsystems::API_REQUESTS
+        );
+
+    pub static ref API_REJECTED_HEADER_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ApiRejectedHeaderTotal,
+            "Total number of requests rejected for invalid header",
+            &["type"],
+            MetricSubsystem::ApiRequests
+        );
+
+    pub static ref API_REJECTED_TIMESTAMP_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ApiRejectedTimestampTotal,
+            "Total number of requests rejected for invalid timestamp",
+            &["type"],
+            MetricSubsystem::ApiRequests
+        );
+
+    pub static ref API_REJECTED_INVALID_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ApiRejectedInvalidTotal,
+            "Total number of invalid requests",
+            &["type"],
+            MetricSubsystem::ApiRequests
+        );
+
+    pub static ref API_REQUESTS_WAITING_TOTAL_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ApiRequestsWaitingTotal,
+            "Total number of requests in the waiting queue",
+            &["type"],
+            MetricSubsystem::ApiRequests
+        );
+
+    pub static ref API_REQUESTS_INCOMING_TOTAL_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ApiRequestsIncomingTotal,
+            "Total number of incoming requests",
+            &["type"],
+            MetricSubsystem::ApiRequests
+        );
+
+    pub static ref API_REQUESTS_IN_FLIGHT_TOTAL_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ApiRequestsInFlightTotal,
+            "Total number of requests currently in flight",
+            &["name", "type"],
+            MetricSubsystem::ApiRequests
+        );
+
+    pub static ref API_REQUESTS_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ApiRequestsTotal,
+            "Total number of requests",
+            &["name", "type"],
+            MetricSubsystem::ApiRequests
+        );
+
+    pub static ref API_REQUESTS_ERRORS_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ApiRequestsErrorsTotal,
+            "Total number of requests with (4xx and 5xx) errors",
+            &["name", "type"],
+            MetricSubsystem::ApiRequests
+        );
+
+    pub static ref API_REQUESTS_5XX_ERRORS_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ApiRequests5xxErrorsTotal,
+            "Total number of requests with 5xx errors",
+            &["name", "type"],
+            MetricSubsystem::ApiRequests
+        );
+
+    pub static ref API_REQUESTS_4XX_ERRORS_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ApiRequests4xxErrorsTotal,
+            "Total number of requests with 4xx errors",
+            &["name", "type"],
+            MetricSubsystem::ApiRequests
+        );
+
+    pub static ref API_REQUESTS_CANCELED_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ApiRequestsCanceledTotal,
+            "Total number of requests canceled by the client",
+            &["name", "type"],
+            MetricSubsystem::ApiRequests
+        );
+
+    pub static ref API_REQUESTS_TTFB_SECONDS_DISTRIBUTION_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ApiRequestsTTFBSecondsDistribution,
+            "Distribution of time to first byte across API calls",
+            &["name", "type", "le"],
+            MetricSubsystem::ApiRequests
+        );
+
+    pub static ref API_TRAFFIC_SENT_BYTES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ApiTrafficSentBytes,
+            "Total number of bytes sent",
+            &["type"],
+            MetricSubsystem::ApiRequests
+        );
+
+    pub static ref API_TRAFFIC_RECV_BYTES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ApiTrafficRecvBytes,
+            "Total number of bytes received",
+            &["type"],
+            MetricSubsystem::ApiRequests
+        );
+}
diff --git a/crates/obs/src/metrics/scanner.rs b/crates/obs/src/metrics/scanner.rs
new file mode 100644
index 00000000..e9136903
--- /dev/null
+++ b/crates/obs/src/metrics/scanner.rs
@@ -0,0 +1,52 @@
+/// Scanner-related metric descriptors
+use crate::metrics::{MetricDescriptor, MetricName, new_counter_md, new_gauge_md, subsystems};
+
+lazy_static::lazy_static! {
+    pub static ref SCANNER_BUCKET_SCANS_FINISHED_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ScannerBucketScansFinished,
+            "Total number of bucket scans finished since server start",
+            &[],
+            subsystems::SCANNER
+        );
+
+    pub static ref SCANNER_BUCKET_SCANS_STARTED_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ScannerBucketScansStarted,
+            "Total number of bucket scans started since server start",
+            &[],
+            subsystems::SCANNER
+        );
+
+    pub static ref SCANNER_DIRECTORIES_SCANNED_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ScannerDirectoriesScanned,
+            "Total number of directories scanned since server start",
+            &[],
+            subsystems::SCANNER
+        );
+
+    pub static ref SCANNER_OBJECTS_SCANNED_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ScannerObjectsScanned,
+            "Total number of unique objects scanned since server start",
+            &[],
+            subsystems::SCANNER
+        );
+
+    pub static ref SCANNER_VERSIONS_SCANNED_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ScannerVersionsScanned,
+            "Total number of object versions scanned since server start",
+            &[],
+            subsystems::SCANNER
+        );
+
+    pub static ref SCANNER_LAST_ACTIVITY_SECONDS_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ScannerLastActivitySeconds,
+            "Time elapsed (in seconds) since last scan activity.",
+            &[],
+            subsystems::SCANNER
+        );
+}
diff --git a/crates/obs/src/metrics/system_cpu.rs b/crates/obs/src/metrics/system_cpu.rs
new file mode 100644
index 00000000..b75b4552
--- /dev/null
+++ b/crates/obs/src/metrics/system_cpu.rs
@@ -0,0 +1,68 @@
+/// CPU system-related metric descriptors
+use crate::metrics::{MetricDescriptor, MetricName, new_gauge_md, subsystems};
+
+lazy_static::lazy_static! {
+    pub static ref SYS_CPU_AVG_IDLE_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::SysCPUAvgIdle,
+            "Average CPU idle time",
+            &[],
+            subsystems::SYSTEM_CPU
+        );
+
+    pub static ref SYS_CPU_AVG_IOWAIT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::SysCPUAvgIOWait,
+            "Average CPU IOWait time",
+            &[],
+            subsystems::SYSTEM_CPU
+        );
+
+    pub static ref SYS_CPU_LOAD_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::SysCPULoad,
+            "CPU load average 1min",
+            &[],
+            subsystems::SYSTEM_CPU
+        );
+
+    pub static ref SYS_CPU_LOAD_PERC_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::SysCPULoadPerc,
+            "CPU load average 1min (percentage)",
+            &[],
+            subsystems::SYSTEM_CPU
+        );
+
+    pub static ref SYS_CPU_NICE_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::SysCPUNice,
+            "CPU nice time",
+            &[],
+            subsystems::SYSTEM_CPU
+        );
+
+    pub static ref SYS_CPU_STEAL_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::SysCPUSteal,
+            "CPU steal time",
+            &[],
+            subsystems::SYSTEM_CPU
+        );
+
+    pub static ref SYS_CPU_SYSTEM_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::SysCPUSystem,
+            "CPU system time",
+            &[],
+            subsystems::SYSTEM_CPU
+        );
+
+    pub static ref SYS_CPU_USER_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::SysCPUUser,
+            "CPU user time",
+            &[],
+            subsystems::SYSTEM_CPU
+        );
+}
diff --git a/crates/obs/src/metrics/system_drive.rs b/crates/obs/src/metrics/system_drive.rs
new file mode 100644
index 00000000..09eaa7c6
--- /dev/null
+++ b/crates/obs/src/metrics/system_drive.rs
@@ -0,0 +1,196 @@
+/// Drive-related metric descriptors
+use crate::metrics::{MetricDescriptor, MetricName, new_counter_md, new_gauge_md, subsystems};
+
+/// drive related labels
+pub const DRIVE_LABEL: &str = "drive";
+/// pool index label
+pub const POOL_INDEX_LABEL: &str = "pool_index";
+/// set index label
+pub const SET_INDEX_LABEL: &str = "set_index";
+/// drive index label
+pub const DRIVE_INDEX_LABEL: &str = "drive_index";
+/// API label
+pub const API_LABEL: &str = "api";
+
+lazy_static::lazy_static! {
+    /// All drive-related labels
+    static ref ALL_DRIVE_LABELS: [&'static str; 4] = [DRIVE_LABEL, POOL_INDEX_LABEL, SET_INDEX_LABEL, DRIVE_INDEX_LABEL];
+}
+
+lazy_static::lazy_static! {
+    pub static ref DRIVE_USED_BYTES_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DriveUsedBytes,
+            "Total storage used on a drive in bytes",
+            &ALL_DRIVE_LABELS[..],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_FREE_BYTES_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DriveFreeBytes,
+            "Total storage free on a drive in bytes",
+            &ALL_DRIVE_LABELS[..],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_TOTAL_BYTES_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DriveTotalBytes,
+            "Total storage available on a drive in bytes",
+            &ALL_DRIVE_LABELS[..],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_USED_INODES_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DriveUsedInodes,
+            "Total used inodes on a drive",
+            &ALL_DRIVE_LABELS[..],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_FREE_INODES_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DriveFreeInodes,
+            "Total free inodes on a drive",
+            &ALL_DRIVE_LABELS[..],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_TOTAL_INODES_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DriveTotalInodes,
+            "Total inodes available on a drive",
+            &ALL_DRIVE_LABELS[..],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_TIMEOUT_ERRORS_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::DriveTimeoutErrorsTotal,
+            "Total timeout errors on a drive",
+            &ALL_DRIVE_LABELS[..],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_IO_ERRORS_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::DriveIOErrorsTotal,
+            "Total I/O errors on a drive",
+            &ALL_DRIVE_LABELS[..],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_AVAILABILITY_ERRORS_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::DriveAvailabilityErrorsTotal,
+            "Total availability errors (I/O errors, timeouts) on a drive",
+            &ALL_DRIVE_LABELS[..],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_WAITING_IO_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DriveWaitingIO,
+            "Total waiting I/O operations on a drive",
+            &ALL_DRIVE_LABELS[..],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_API_LATENCY_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DriveAPILatencyMicros,
+            "Average last minute latency in µs for drive API storage operations",
+            &[&ALL_DRIVE_LABELS[..], &[API_LABEL]].concat(),
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_HEALTH_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DriveHealth,
+            "Drive health (0 = offline, 1 = healthy, 2 = healing)",
+            &ALL_DRIVE_LABELS[..],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_OFFLINE_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DriveOfflineCount,
+            "Count of offline drives",
+            &[],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_ONLINE_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DriveOnlineCount,
+            "Count of online drives",
+            &[],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_COUNT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DriveCount,
+            "Count of all drives",
+            &[],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_READS_PER_SEC_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DriveReadsPerSec,
+            "Reads per second on a drive",
+            &ALL_DRIVE_LABELS[..],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_READS_KB_PER_SEC_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DriveReadsKBPerSec,
+            "Kilobytes read per second on a drive",
+            &ALL_DRIVE_LABELS[..],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_READS_AWAIT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DriveReadsAwait,
+            "Average time for read requests served on a drive",
+            &ALL_DRIVE_LABELS[..],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_WRITES_PER_SEC_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DriveWritesPerSec,
+            "Writes per second on a drive",
+            &ALL_DRIVE_LABELS[..],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_WRITES_KB_PER_SEC_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DriveWritesKBPerSec,
+            "Kilobytes written per second on a drive",
+            &ALL_DRIVE_LABELS[..],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_WRITES_AWAIT_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DriveWritesAwait,
+            "Average time for write requests served on a drive",
+            &ALL_DRIVE_LABELS[..],
+            subsystems::SYSTEM_DRIVE
+        );
+
+    pub static ref DRIVE_PERC_UTIL_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::DrivePercUtil,
+            "Percentage of time the disk was busy",
+            &ALL_DRIVE_LABELS[..],
+            subsystems::SYSTEM_DRIVE
+        );
+}
diff --git a/crates/obs/src/metrics/system_memory.rs b/crates/obs/src/metrics/system_memory.rs
new file mode 100644
index 00000000..4e062a95
--- /dev/null
+++ b/crates/obs/src/metrics/system_memory.rs
@@ -0,0 +1,68 @@
+/// Memory-related metric descriptors
+use crate::metrics::{MetricDescriptor, MetricName, new_gauge_md, subsystems};
+
+lazy_static::lazy_static! {
+    pub static ref MEM_TOTAL_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::MemTotal,
+            "Total memory on the node",
+            &[],
+            subsystems::SYSTEM_MEMORY
+        );
+
+    pub static ref MEM_USED_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::MemUsed,
+            "Used memory on the node",
+            &[],
+            subsystems::SYSTEM_MEMORY
+        );
+
+    pub static ref MEM_USED_PERC_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::MemUsedPerc,
+            "Used memory percentage on the node",
+            &[],
+            subsystems::SYSTEM_MEMORY
+        );
+
+    pub static ref MEM_FREE_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::MemFree,
+            "Free memory on the node",
+            &[],
+            subsystems::SYSTEM_MEMORY
+        );
+
+    pub static ref MEM_BUFFERS_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::MemBuffers,
+            "Buffers memory on the node",
+            &[],
+            subsystems::SYSTEM_MEMORY
+        );
+
+    pub static ref MEM_CACHE_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::MemCache,
+            "Cache memory on the node",
+            &[],
+            subsystems::SYSTEM_MEMORY
+        );
+
+    pub static ref MEM_SHARED_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::MemShared,
+            "Shared memory on the node",
+            &[],
+            subsystems::SYSTEM_MEMORY
+        );
+
+    pub static ref MEM_AVAILABLE_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::MemAvailable,
+            "Available memory on the node",
+            &[],
+            subsystems::SYSTEM_MEMORY
+        );
+}
diff --git a/crates/obs/src/metrics/system_network.rs b/crates/obs/src/metrics/system_network.rs
new file mode 100644
index 00000000..b3657e72
--- /dev/null
+++ b/crates/obs/src/metrics/system_network.rs
@@ -0,0 +1,44 @@
+/// Network-related metric descriptors
+use crate::metrics::{MetricDescriptor, MetricName, new_counter_md, new_gauge_md, subsystems};
+
+lazy_static::lazy_static! {
+    pub static ref INTERNODE_ERRORS_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::InternodeErrorsTotal,
+            "Total number of failed internode calls",
+            &[],
+            subsystems::SYSTEM_NETWORK_INTERNODE
+        );
+
+    pub static ref INTERNODE_DIAL_ERRORS_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::InternodeDialErrorsTotal,
+            "Total number of internode TCP dial timeouts and errors",
+            &[],
+            subsystems::SYSTEM_NETWORK_INTERNODE
+        );
+
+    pub static ref INTERNODE_DIAL_AVG_TIME_NANOS_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::InternodeDialAvgTimeNanos,
+            "Average dial time of internode TCP calls in nanoseconds",
+            &[],
+            subsystems::SYSTEM_NETWORK_INTERNODE
+        );
+
+    pub static ref INTERNODE_SENT_BYTES_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::InternodeSentBytesTotal,
+            "Total number of bytes sent to other peer nodes",
+            &[],
+            subsystems::SYSTEM_NETWORK_INTERNODE
+        );
+
+    pub static ref INTERNODE_RECV_BYTES_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::InternodeRecvBytesTotal,
+            "Total number of bytes received from other peer nodes",
+            &[],
+            subsystems::SYSTEM_NETWORK_INTERNODE
+        );
+}
diff --git a/crates/obs/src/metrics/system_process.rs b/crates/obs/src/metrics/system_process.rs
new file mode 100644
index 00000000..f021aabe
--- /dev/null
+++ b/crates/obs/src/metrics/system_process.rs
@@ -0,0 +1,140 @@
+/// process related metric descriptors
+use crate::metrics::{MetricDescriptor, MetricName, new_counter_md, new_gauge_md, subsystems};
+
+lazy_static::lazy_static! {
+    pub static ref PROCESS_LOCKS_READ_TOTAL_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ProcessLocksReadTotal,
+            "Number of current READ locks on this peer",
+            &[],
+            subsystems::SYSTEM_PROCESS
+        );
+
+    pub static ref PROCESS_LOCKS_WRITE_TOTAL_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ProcessLocksWriteTotal,
+            "Number of current WRITE locks on this peer",
+            &[],
+            subsystems::SYSTEM_PROCESS
+        );
+
+    pub static ref PROCESS_CPU_TOTAL_SECONDS_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ProcessCPUTotalSeconds,
+            "Total user and system CPU time spent in seconds",
+            &[],
+            subsystems::SYSTEM_PROCESS
+        );
+
+    pub static ref PROCESS_GO_ROUTINE_TOTAL_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ProcessGoRoutineTotal,
+            "Total number of go routines running",
+            &[],
+            subsystems::SYSTEM_PROCESS
+        );
+
+    pub static ref PROCESS_IO_RCHAR_BYTES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ProcessIORCharBytes,
+            "Total bytes read by the process from the underlying storage system including cache, /proc/[pid]/io rchar",
+            &[],
+            subsystems::SYSTEM_PROCESS
+        );
+
+    pub static ref PROCESS_IO_READ_BYTES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ProcessIOReadBytes,
+            "Total bytes read by the process from the underlying storage system, /proc/[pid]/io read_bytes",
+            &[],
+            subsystems::SYSTEM_PROCESS
+        );
+
+    pub static ref PROCESS_IO_WCHAR_BYTES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ProcessIOWCharBytes,
+            "Total bytes written by the process to the underlying storage system including page cache, /proc/[pid]/io wchar",
+            &[],
+            subsystems::SYSTEM_PROCESS
+        );
+
+    pub static ref PROCESS_IO_WRITE_BYTES_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ProcessIOWriteBytes,
+            "Total bytes written by the process to the underlying storage system, /proc/[pid]/io write_bytes",
+            &[],
+            subsystems::SYSTEM_PROCESS
+        );
+
+    pub static ref PROCESS_START_TIME_SECONDS_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ProcessStartTimeSeconds,
+            "Start time for RustFS process in seconds since Unix epoc",
+            &[],
+            subsystems::SYSTEM_PROCESS
+        );
+
+    pub static ref PROCESS_UPTIME_SECONDS_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ProcessUptimeSeconds,
+            "Uptime for RustFS process in seconds",
+            &[],
+            subsystems::SYSTEM_PROCESS
+        );
+
+    pub static ref PROCESS_FILE_DESCRIPTOR_LIMIT_TOTAL_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ProcessFileDescriptorLimitTotal,
+            "Limit on total number of open file descriptors for the RustFS Server process",
+            &[],
+            subsystems::SYSTEM_PROCESS
+        );
+
+    pub static ref PROCESS_FILE_DESCRIPTOR_OPEN_TOTAL_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ProcessFileDescriptorOpenTotal,
+            "Total number of open file descriptors by the RustFS Server process",
+            &[],
+            subsystems::SYSTEM_PROCESS
+        );
+
+    pub static ref PROCESS_SYSCALL_READ_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ProcessSyscallReadTotal,
+            "Total read SysCalls to the kernel. /proc/[pid]/io syscr",
+            &[],
+            subsystems::SYSTEM_PROCESS
+        );
+
+    pub static ref PROCESS_SYSCALL_WRITE_TOTAL_MD: MetricDescriptor =
+        new_counter_md(
+            MetricName::ProcessSyscallWriteTotal,
+            "Total write SysCalls to the kernel. /proc/[pid]/io syscw",
+            &[],
+            subsystems::SYSTEM_PROCESS
+        );
+
+    pub static ref PROCESS_RESIDENT_MEMORY_BYTES_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ProcessResidentMemoryBytes,
+            "Resident memory size in bytes",
+            &[],
+            subsystems::SYSTEM_PROCESS
+        );
+
+    pub static ref PROCESS_VIRTUAL_MEMORY_BYTES_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ProcessVirtualMemoryBytes,
+            "Virtual memory size in bytes",
+            &[],
+            subsystems::SYSTEM_PROCESS
+        );
+
+    pub static ref PROCESS_VIRTUAL_MEMORY_MAX_BYTES_MD: MetricDescriptor =
+        new_gauge_md(
+            MetricName::ProcessVirtualMemoryMaxBytes,
+            "Maximum virtual memory size in bytes",
+            &[],
+            subsystems::SYSTEM_PROCESS
+        );
+}
diff --git a/crates/obs/src/telemetry.rs b/crates/obs/src/telemetry.rs
index a83dbac9..b9ed9e9b 100644
--- a/crates/obs/src/telemetry.rs
+++ b/crates/obs/src/telemetry.rs
@@ -27,6 +27,7 @@ use tracing::info;
 use tracing_error::ErrorLayer;
 use tracing_opentelemetry::{MetricsLayer, OpenTelemetryLayer};
 use tracing_subscriber::fmt::format::FmtSpan;
+use tracing_subscriber::fmt::time::LocalTime;
 use tracing_subscriber::{EnvFilter, Layer, layer::SubscriberExt, util::SubscriberInitExt};
 
 /// A guard object that manages the lifecycle of OpenTelemetry components.
@@ -224,6 +225,7 @@ pub(crate) fn init_telemetry(config: &OtelConfig) -> OtelGuard {
             let fmt_layer = {
                 let enable_color = std::io::stdout().is_terminal();
                 let mut layer = tracing_subscriber::fmt::layer()
+                    .with_timer(LocalTime::rfc_3339())
                     .with_target(true)
                     .with_ansi(enable_color)
                     .with_thread_names(true)
diff --git a/crates/rio/Cargo.toml b/crates/rio/Cargo.toml
index ddf240b0..54d9ad67 100644
--- a/crates/rio/Cargo.toml
+++ b/crates/rio/Cargo.toml
@@ -14,23 +14,20 @@ tokio = { workspace = true, features = ["full"] }
 rand = { workspace = true }
 md-5 = { workspace = true }
 http.workspace = true
-flate2 = "1.1.1"
 aes-gcm = "0.10.3"
 crc32fast = "1.4.2"
 pin-project-lite.workspace = true
 async-trait.workspace = true
 base64-simd = "0.8.0"
 hex-simd = "0.8.0"
-zstd = "0.13.3"
-lz4 = "1.28.1"
-brotli = "8.0.1"
-snap = "1.1.1"
-
+serde = { workspace = true }
 bytes.workspace = true
 reqwest.workspace = true
 tokio-util.workspace = true
 futures.workspace = true
-rustfs-utils = {workspace = true, features= ["io","hash"]}
+rustfs-utils = {workspace = true, features= ["io","hash","compress"]}
+byteorder.workspace = true
+serde_json.workspace = true
 
 [dev-dependencies]
 criterion = { version = "0.5.1", features = ["async", "async_tokio", "tokio"] }
diff --git a/crates/rio/src/compress_index.rs b/crates/rio/src/compress_index.rs
new file mode 100644
index 00000000..dea594c4
--- /dev/null
+++ b/crates/rio/src/compress_index.rs
@@ -0,0 +1,672 @@
+use bytes::Bytes;
+use serde::{Deserialize, Serialize};
+use std::io::{self, Read, Seek, SeekFrom};
+
+const S2_INDEX_HEADER: &[u8] = b"s2idx\x00";
+const S2_INDEX_TRAILER: &[u8] = b"\x00xdi2s";
+const MAX_INDEX_ENTRIES: usize = 1 << 16;
+const MIN_INDEX_DIST: i64 = 1 << 20;
+// const MIN_INDEX_DIST: i64 = 0;
+
+pub trait TryGetIndex {
+    fn try_get_index(&self) -> Option<&Index> {
+        None
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Index {
+    pub total_uncompressed: i64,
+    pub total_compressed: i64,
+    info: Vec<IndexInfo>,
+    est_block_uncomp: i64,
+}
+
+impl Default for Index {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct IndexInfo {
+    pub compressed_offset: i64,
+    pub uncompressed_offset: i64,
+}
+
+#[allow(dead_code)]
+impl Index {
+    pub fn new() -> Self {
+        Self {
+            total_uncompressed: -1,
+            total_compressed: -1,
+            info: Vec::new(),
+            est_block_uncomp: 0,
+        }
+    }
+
+    #[allow(dead_code)]
+    fn reset(&mut self, max_block: usize) {
+        self.est_block_uncomp = max_block as i64;
+        self.total_compressed = -1;
+        self.total_uncompressed = -1;
+        self.info.clear();
+    }
+
+    pub fn len(&self) -> usize {
+        self.info.len()
+    }
+
+    fn alloc_infos(&mut self, n: usize) {
+        if n > MAX_INDEX_ENTRIES {
+            panic!("n > MAX_INDEX_ENTRIES");
+        }
+        self.info = Vec::with_capacity(n);
+    }
+
+    pub fn add(&mut self, compressed_offset: i64, uncompressed_offset: i64) -> io::Result<()> {
+        if self.info.is_empty() {
+            self.info.push(IndexInfo {
+                compressed_offset,
+                uncompressed_offset,
+            });
+            return Ok(());
+        }
+
+        let last_idx = self.info.len() - 1;
+        let latest = &mut self.info[last_idx];
+
+        if latest.uncompressed_offset == uncompressed_offset {
+            latest.compressed_offset = compressed_offset;
+            return Ok(());
+        }
+
+        if latest.uncompressed_offset > uncompressed_offset {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                format!(
+                    "internal error: Earlier uncompressed received ({} > {})",
+                    latest.uncompressed_offset, uncompressed_offset
+                ),
+            ));
+        }
+
+        if latest.compressed_offset > compressed_offset {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                format!(
+                    "internal error: Earlier compressed received ({} > {})",
+                    latest.uncompressed_offset, uncompressed_offset
+                ),
+            ));
+        }
+
+        if latest.uncompressed_offset + MIN_INDEX_DIST > uncompressed_offset {
+            return Ok(());
+        }
+
+        self.info.push(IndexInfo {
+            compressed_offset,
+            uncompressed_offset,
+        });
+
+        self.total_compressed = compressed_offset;
+        self.total_uncompressed = uncompressed_offset;
+        Ok(())
+    }
+
+    pub fn find(&self, offset: i64) -> io::Result<(i64, i64)> {
+        if self.total_uncompressed < 0 {
+            return Err(io::Error::other("corrupt index"));
+        }
+
+        let mut offset = offset;
+        if offset < 0 {
+            offset += self.total_uncompressed;
+            if offset < 0 {
+                return Err(io::Error::new(io::ErrorKind::UnexpectedEof, "offset out of bounds"));
+            }
+        }
+
+        if offset > self.total_uncompressed {
+            return Err(io::Error::new(io::ErrorKind::UnexpectedEof, "offset out of bounds"));
+        }
+
+        if self.info.is_empty() {
+            return Err(io::Error::new(io::ErrorKind::UnexpectedEof, "empty index"));
+        }
+
+        if self.info.len() > 200 {
+            let n = self
+                .info
+                .binary_search_by(|info| {
+                    if info.uncompressed_offset > offset {
+                        std::cmp::Ordering::Greater
+                    } else {
+                        std::cmp::Ordering::Less
+                    }
+                })
+                .unwrap_or_else(|i| i);
+
+            if n == 0 {
+                return Ok((self.info[0].compressed_offset, self.info[0].uncompressed_offset));
+            }
+            return Ok((self.info[n - 1].compressed_offset, self.info[n - 1].uncompressed_offset));
+        }
+
+        let mut compressed_off = 0;
+        let mut uncompressed_off = 0;
+        for info in &self.info {
+            if info.uncompressed_offset > offset {
+                break;
+            }
+            compressed_off = info.compressed_offset;
+            uncompressed_off = info.uncompressed_offset;
+        }
+        Ok((compressed_off, uncompressed_off))
+    }
+
+    fn reduce(&mut self) {
+        if self.info.len() < MAX_INDEX_ENTRIES && self.est_block_uncomp >= MIN_INDEX_DIST {
+            return;
+        }
+
+        let mut remove_n = (self.info.len() + 1) / MAX_INDEX_ENTRIES;
+        let src = self.info.clone();
+        let mut j = 0;
+
+        while self.est_block_uncomp * (remove_n as i64 + 1) < MIN_INDEX_DIST && self.info.len() / (remove_n + 1) > 1000 {
+            remove_n += 1;
+        }
+
+        let mut idx = 0;
+        while idx < src.len() {
+            self.info[j] = src[idx].clone();
+            j += 1;
+            idx += remove_n + 1;
+        }
+        self.info.truncate(j);
+        self.est_block_uncomp += self.est_block_uncomp * remove_n as i64;
+    }
+
+    pub fn into_vec(mut self) -> Bytes {
+        let mut b = Vec::new();
+        self.append_to(&mut b, self.total_uncompressed, self.total_compressed);
+        Bytes::from(b)
+    }
+
+    pub fn append_to(&mut self, b: &mut Vec<u8>, uncomp_total: i64, comp_total: i64) {
+        self.reduce();
+        let init_size = b.len();
+
+        // Add skippable header
+        b.extend_from_slice(&[0x50, 0x2A, 0x4D, 0x18]); // ChunkTypeIndex
+        b.extend_from_slice(&[0, 0, 0]); // Placeholder for chunk length
+
+        // Add header
+        b.extend_from_slice(S2_INDEX_HEADER);
+
+        // Add total sizes
+        let mut tmp = [0u8; 8];
+        let n = write_varint(&mut tmp, uncomp_total);
+        b.extend_from_slice(&tmp[..n]);
+        let n = write_varint(&mut tmp, comp_total);
+        b.extend_from_slice(&tmp[..n]);
+        let n = write_varint(&mut tmp, self.est_block_uncomp);
+        b.extend_from_slice(&tmp[..n]);
+        let n = write_varint(&mut tmp, self.info.len() as i64);
+        b.extend_from_slice(&tmp[..n]);
+
+        // Check if we should add uncompressed offsets
+        let mut has_uncompressed = 0u8;
+        for (idx, info) in self.info.iter().enumerate() {
+            if idx == 0 {
+                if info.uncompressed_offset != 0 {
+                    has_uncompressed = 1;
+                    break;
+                }
+                continue;
+            }
+            if info.uncompressed_offset != self.info[idx - 1].uncompressed_offset + self.est_block_uncomp {
+                has_uncompressed = 1;
+                break;
+            }
+        }
+        b.push(has_uncompressed);
+
+        // Add uncompressed offsets if needed
+        if has_uncompressed == 1 {
+            for (idx, info) in self.info.iter().enumerate() {
+                let mut u_off = info.uncompressed_offset;
+                if idx > 0 {
+                    let prev = &self.info[idx - 1];
+                    u_off -= prev.uncompressed_offset + self.est_block_uncomp;
+                }
+                let n = write_varint(&mut tmp, u_off);
+                b.extend_from_slice(&tmp[..n]);
+            }
+        }
+
+        // Add compressed offsets
+        let mut c_predict = self.est_block_uncomp / 2;
+        for (idx, info) in self.info.iter().enumerate() {
+            let mut c_off = info.compressed_offset;
+            if idx > 0 {
+                let prev = &self.info[idx - 1];
+                c_off -= prev.compressed_offset + c_predict;
+                c_predict += c_off / 2;
+            }
+            let n = write_varint(&mut tmp, c_off);
+            b.extend_from_slice(&tmp[..n]);
+        }
+
+        // Add total size and trailer
+        let total_size = (b.len() - init_size + 4 + S2_INDEX_TRAILER.len()) as u32;
+        b.extend_from_slice(&total_size.to_le_bytes());
+        b.extend_from_slice(S2_INDEX_TRAILER);
+
+        // Update chunk length
+        let chunk_len = b.len() - init_size - 4;
+        b[init_size + 1] = chunk_len as u8;
+        b[init_size + 2] = (chunk_len >> 8) as u8;
+        b[init_size + 3] = (chunk_len >> 16) as u8;
+    }
+
+    pub fn load<'a>(&mut self, mut b: &'a [u8]) -> io::Result<&'a [u8]> {
+        if b.len() <= 4 + S2_INDEX_HEADER.len() + S2_INDEX_TRAILER.len() {
+            return Err(io::Error::new(io::ErrorKind::UnexpectedEof, "buffer too small"));
+        }
+
+        if b[0] != 0x50 || b[1] != 0x2A || b[2] != 0x4D || b[3] != 0x18 {
+            return Err(io::Error::other("invalid chunk type"));
+        }
+
+        let chunk_len = (b[1] as usize) | ((b[2] as usize) << 8) | ((b[3] as usize) << 16);
+        b = &b[4..];
+
+        if b.len() < chunk_len {
+            return Err(io::Error::new(io::ErrorKind::UnexpectedEof, "buffer too small"));
+        }
+
+        if !b.starts_with(S2_INDEX_HEADER) {
+            return Err(io::Error::other("invalid header"));
+        }
+        b = &b[S2_INDEX_HEADER.len()..];
+
+        // Read total uncompressed
+        let (v, n) = read_varint(b)?;
+        if v < 0 {
+            return Err(io::Error::other("invalid uncompressed size"));
+        }
+        self.total_uncompressed = v;
+        b = &b[n..];
+
+        // Read total compressed
+        let (v, n) = read_varint(b)?;
+        if v < 0 {
+            return Err(io::Error::other("invalid compressed size"));
+        }
+        self.total_compressed = v;
+        b = &b[n..];
+
+        // Read est block uncomp
+        let (v, n) = read_varint(b)?;
+        if v < 0 {
+            return Err(io::Error::other("invalid block size"));
+        }
+        self.est_block_uncomp = v;
+        b = &b[n..];
+
+        // Read number of entries
+        let (v, n) = read_varint(b)?;
+        if v < 0 || v > MAX_INDEX_ENTRIES as i64 {
+            return Err(io::Error::other("invalid number of entries"));
+        }
+        let entries = v as usize;
+        b = &b[n..];
+
+        self.alloc_infos(entries);
+
+        if b.is_empty() {
+            return Err(io::Error::new(io::ErrorKind::UnexpectedEof, "buffer too small"));
+        }
+
+        let has_uncompressed = b[0];
+        b = &b[1..];
+
+        if has_uncompressed & 1 != has_uncompressed {
+            return Err(io::Error::other("invalid uncompressed flag"));
+        }
+
+        // Read uncompressed offsets
+        for idx in 0..entries {
+            let mut u_off = 0i64;
+            if has_uncompressed != 0 {
+                let (v, n) = read_varint(b)?;
+                u_off = v;
+                b = &b[n..];
+            }
+
+            if idx > 0 {
+                let prev = self.info[idx - 1].uncompressed_offset;
+                u_off += prev + self.est_block_uncomp;
+                if u_off <= prev {
+                    return Err(io::Error::other("invalid offset"));
+                }
+            }
+            if u_off < 0 {
+                return Err(io::Error::other("negative offset"));
+            }
+            self.info[idx].uncompressed_offset = u_off;
+        }
+
+        // Read compressed offsets
+        let mut c_predict = self.est_block_uncomp / 2;
+        for idx in 0..entries {
+            let (v, n) = read_varint(b)?;
+            let mut c_off = v;
+            b = &b[n..];
+
+            if idx > 0 {
+                c_predict += c_off / 2;
+                let prev = self.info[idx - 1].compressed_offset;
+                c_off += prev + c_predict;
+                if c_off <= prev {
+                    return Err(io::Error::other("invalid offset"));
+                }
+            }
+            if c_off < 0 {
+                return Err(io::Error::other("negative offset"));
+            }
+            self.info[idx].compressed_offset = c_off;
+        }
+
+        if b.len() < 4 + S2_INDEX_TRAILER.len() {
+            return Err(io::Error::new(io::ErrorKind::UnexpectedEof, "buffer too small"));
+        }
+
+        // Skip size
+        b = &b[4..];
+
+        // Check trailer
+        if !b.starts_with(S2_INDEX_TRAILER) {
+            return Err(io::Error::other("invalid trailer"));
+        }
+
+        Ok(&b[S2_INDEX_TRAILER.len()..])
+    }
+
+    pub fn load_stream<R: Read + Seek>(&mut self, mut rs: R) -> io::Result<()> {
+        // Go to end
+        rs.seek(SeekFrom::End(-10))?;
+        let mut tmp = [0u8; 10];
+        rs.read_exact(&mut tmp)?;
+
+        // Check trailer
+        if &tmp[4..4 + S2_INDEX_TRAILER.len()] != S2_INDEX_TRAILER {
+            return Err(io::Error::other("invalid trailer"));
+        }
+
+        let sz = u32::from_le_bytes(tmp[..4].try_into().unwrap());
+        if sz > 0x7fffffff {
+            return Err(io::Error::other("size too large"));
+        }
+
+        rs.seek(SeekFrom::End(-(sz as i64)))?;
+
+        let mut buf = vec![0u8; sz as usize];
+        rs.read_exact(&mut buf)?;
+
+        self.load(&buf)?;
+        Ok(())
+    }
+
+    pub fn to_json(&self) -> serde_json::Result<Vec<u8>> {
+        #[derive(Serialize)]
+        struct Offset {
+            compressed: i64,
+            uncompressed: i64,
+        }
+
+        #[derive(Serialize)]
+        struct IndexJson {
+            total_uncompressed: i64,
+            total_compressed: i64,
+            offsets: Vec<Offset>,
+            est_block_uncompressed: i64,
+        }
+
+        let json = IndexJson {
+            total_uncompressed: self.total_uncompressed,
+            total_compressed: self.total_compressed,
+            offsets: self
+                .info
+                .iter()
+                .map(|info| Offset {
+                    compressed: info.compressed_offset,
+                    uncompressed: info.uncompressed_offset,
+                })
+                .collect(),
+            est_block_uncompressed: self.est_block_uncomp,
+        };
+
+        serde_json::to_vec_pretty(&json)
+    }
+}
+
+// Helper functions for varint encoding/decoding
+fn write_varint(buf: &mut [u8], mut v: i64) -> usize {
+    let mut n = 0;
+    while v >= 0x80 {
+        buf[n] = (v as u8) | 0x80;
+        v >>= 7;
+        n += 1;
+    }
+    buf[n] = v as u8;
+    n + 1
+}
+
+fn read_varint(buf: &[u8]) -> io::Result<(i64, usize)> {
+    let mut result = 0i64;
+    let mut shift = 0;
+    let mut n = 0;
+
+    while n < buf.len() {
+        let byte = buf[n];
+        n += 1;
+        result |= ((byte & 0x7F) as i64) << shift;
+        if byte < 0x80 {
+            return Ok((result, n));
+        }
+        shift += 7;
+    }
+
+    Err(io::Error::new(io::ErrorKind::UnexpectedEof, "unexpected EOF"))
+}
+
+// Helper functions for index header manipulation
+#[allow(dead_code)]
+pub fn remove_index_headers(b: &[u8]) -> Option<&[u8]> {
+    if b.len() < 4 + S2_INDEX_TRAILER.len() {
+        return None;
+    }
+
+    // Skip size
+    let b = &b[4..];
+
+    // Check trailer
+    if !b.starts_with(S2_INDEX_TRAILER) {
+        return None;
+    }
+
+    Some(&b[S2_INDEX_TRAILER.len()..])
+}
+
+#[allow(dead_code)]
+pub fn restore_index_headers(in_data: &[u8]) -> Vec<u8> {
+    if in_data.is_empty() {
+        return Vec::new();
+    }
+
+    let mut b = Vec::with_capacity(4 + S2_INDEX_HEADER.len() + in_data.len() + S2_INDEX_TRAILER.len() + 4);
+    b.extend_from_slice(&[0x50, 0x2A, 0x4D, 0x18]);
+    b.extend_from_slice(S2_INDEX_HEADER);
+    b.extend_from_slice(in_data);
+
+    let total_size = (b.len() + 4 + S2_INDEX_TRAILER.len()) as u32;
+    b.extend_from_slice(&total_size.to_le_bytes());
+    b.extend_from_slice(S2_INDEX_TRAILER);
+
+    let chunk_len = b.len() - 4;
+    b[1] = chunk_len as u8;
+    b[2] = (chunk_len >> 8) as u8;
+    b[3] = (chunk_len >> 16) as u8;
+
+    b
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_index_new() {
+        let index = Index::new();
+        assert_eq!(index.total_uncompressed, -1);
+        assert_eq!(index.total_compressed, -1);
+        assert!(index.info.is_empty());
+        assert_eq!(index.est_block_uncomp, 0);
+    }
+
+    #[test]
+    fn test_index_add() -> io::Result<()> {
+        let mut index = Index::new();
+
+        // 测试添加第一个索引
+        index.add(100, 1000)?;
+        assert_eq!(index.info.len(), 1);
+        assert_eq!(index.info[0].compressed_offset, 100);
+        assert_eq!(index.info[0].uncompressed_offset, 1000);
+
+        // 测试添加相同未压缩偏移量的索引
+        index.add(200, 1000)?;
+        assert_eq!(index.info.len(), 1);
+        assert_eq!(index.info[0].compressed_offset, 200);
+        assert_eq!(index.info[0].uncompressed_offset, 1000);
+
+        // 测试添加新的索引（确保距离足够大）
+        index.add(300, 2000 + MIN_INDEX_DIST)?;
+        assert_eq!(index.info.len(), 2);
+        assert_eq!(index.info[1].compressed_offset, 300);
+        assert_eq!(index.info[1].uncompressed_offset, 2000 + MIN_INDEX_DIST);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_index_add_errors() {
+        let mut index = Index::new();
+
+        // 添加初始索引
+        index.add(100, 1000).unwrap();
+
+        // 测试添加更小的未压缩偏移量
+        let err = index.add(200, 500).unwrap_err();
+        assert_eq!(err.kind(), io::ErrorKind::InvalidData);
+
+        // 测试添加更小的压缩偏移量
+        let err = index.add(50, 2000).unwrap_err();
+        assert_eq!(err.kind(), io::ErrorKind::InvalidData);
+    }
+
+    #[test]
+    fn test_index_find() -> io::Result<()> {
+        let mut index = Index::new();
+        index.total_uncompressed = 1000 + MIN_INDEX_DIST * 3;
+        index.total_compressed = 5000;
+
+        // 添加一些测试数据，确保索引间距满足 MIN_INDEX_DIST 要求
+        index.add(100, 1000)?;
+        index.add(300, 1000 + MIN_INDEX_DIST)?;
+        index.add(500, 1000 + MIN_INDEX_DIST * 2)?;
+
+        // 测试查找存在的偏移量
+        let (comp, uncomp) = index.find(1500)?;
+        assert_eq!(comp, 100);
+        assert_eq!(uncomp, 1000);
+
+        // 测试查找边界值
+        let (comp, uncomp) = index.find(1000 + MIN_INDEX_DIST)?;
+        assert_eq!(comp, 300);
+        assert_eq!(uncomp, 1000 + MIN_INDEX_DIST);
+
+        // 测试查找最后一个索引
+        let (comp, uncomp) = index.find(1000 + MIN_INDEX_DIST * 2)?;
+        assert_eq!(comp, 500);
+        assert_eq!(uncomp, 1000 + MIN_INDEX_DIST * 2);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_index_find_errors() {
+        let mut index = Index::new();
+        index.total_uncompressed = 10000;
+        index.total_compressed = 5000;
+
+        // 测试未初始化的索引
+        let uninit_index = Index::new();
+        let err = uninit_index.find(1000).unwrap_err();
+        assert_eq!(err.kind(), io::ErrorKind::Other);
+
+        // 测试超出范围的偏移量
+        let err = index.find(15000).unwrap_err();
+        assert_eq!(err.kind(), io::ErrorKind::UnexpectedEof);
+
+        // 测试负数偏移量
+        let err = match index.find(-1000) {
+            Ok(_) => panic!("should be error"),
+            Err(e) => e,
+        };
+        assert_eq!(err.kind(), io::ErrorKind::UnexpectedEof);
+    }
+
+    #[test]
+    fn test_index_reduce() {
+        let mut index = Index::new();
+        index.est_block_uncomp = MIN_INDEX_DIST;
+
+        // 添加超过最大索引数量的条目，确保间距满足 MIN_INDEX_DIST 要求
+        for i in 0..MAX_INDEX_ENTRIES + 100 {
+            index.add(i as i64 * 100, i as i64 * MIN_INDEX_DIST).unwrap();
+        }
+
+        // 手动调用 reduce 方法
+        index.reduce();
+
+        // 验证索引数量是否被正确减少
+        assert!(index.info.len() <= MAX_INDEX_ENTRIES);
+    }
+
+    #[test]
+    fn test_index_json() -> io::Result<()> {
+        let mut index = Index::new();
+
+        // 添加一些测试数据
+        index.add(100, 1000)?;
+        index.add(300, 2000 + MIN_INDEX_DIST)?;
+
+        // 测试 JSON 序列化
+        let json = index.to_json().unwrap();
+        let json_str = String::from_utf8(json).unwrap();
+
+        println!("json_str: {}", json_str);
+        // 验证 JSON 内容
+
+        assert!(json_str.contains("\"compressed\": 100"));
+        assert!(json_str.contains("\"uncompressed\": 1000"));
+        assert!(json_str.contains("\"est_block_uncompressed\": 0"));
+
+        Ok(())
+    }
+}
diff --git a/crates/rio/src/compress_reader.rs b/crates/rio/src/compress_reader.rs
index 40720706..a453f901 100644
--- a/crates/rio/src/compress_reader.rs
+++ b/crates/rio/src/compress_reader.rs
@@ -1,12 +1,22 @@
-use crate::compress::{CompressionAlgorithm, compress_block, decompress_block};
+use crate::compress_index::{Index, TryGetIndex};
 use crate::{EtagResolvable, HashReaderDetector};
 use crate::{HashReaderMut, Reader};
 use pin_project_lite::pin_project;
-use rustfs_utils::{put_uvarint, put_uvarint_len, uvarint};
+use rustfs_utils::compress::{CompressionAlgorithm, compress_block, decompress_block};
+use rustfs_utils::{put_uvarint, uvarint};
+use std::cmp::min;
 use std::io::{self};
 use std::pin::Pin;
 use std::task::{Context, Poll};
 use tokio::io::{AsyncRead, ReadBuf};
+// use tracing::error;
+
+const COMPRESS_TYPE_COMPRESSED: u8 = 0x00;
+const COMPRESS_TYPE_UNCOMPRESSED: u8 = 0x01;
+const COMPRESS_TYPE_END: u8 = 0xFF;
+
+const DEFAULT_BLOCK_SIZE: usize = 1 << 20; // 1MB
+const HEADER_LEN: usize = 8;
 
 pin_project! {
     #[derive(Debug)]
@@ -19,6 +29,11 @@ pin_project! {
         done: bool,
         block_size: usize,
         compression_algorithm: CompressionAlgorithm,
+        index: Index,
+        written: usize,
+        uncomp_written: usize,
+        temp_buffer: Vec<u8>,
+        temp_pos: usize,
     }
 }
 
@@ -33,7 +48,12 @@ where
             pos: 0,
             done: false,
             compression_algorithm,
-            block_size: 1 << 20, // Default 1MB
+            block_size: DEFAULT_BLOCK_SIZE,
+            index: Index::new(),
+            written: 0,
+            uncomp_written: 0,
+            temp_buffer: Vec::with_capacity(DEFAULT_BLOCK_SIZE), // Pre-allocate capacity
+            temp_pos: 0,
         }
     }
 
@@ -46,19 +66,33 @@ where
             done: false,
             compression_algorithm,
             block_size,
+            index: Index::new(),
+            written: 0,
+            uncomp_written: 0,
+            temp_buffer: Vec::with_capacity(block_size),
+            temp_pos: 0,
         }
     }
 }
 
+impl<R> TryGetIndex for CompressReader<R>
+where
+    R: Reader,
+{
+    fn try_get_index(&self) -> Option<&Index> {
+        Some(&self.index)
+    }
+}
+
 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
+        // Copy from buffer first if available
         if *this.pos < this.buffer.len() {
-            let to_copy = std::cmp::min(buf.remaining(), this.buffer.len() - *this.pos);
+            let to_copy = 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() {
@@ -67,74 +101,60 @@ where
             }
             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(()))
+        // Fill temporary buffer
+        while this.temp_buffer.len() < *this.block_size {
+            let remaining = *this.block_size - this.temp_buffer.len();
+            let mut temp = vec![0u8; remaining];
+            let mut temp_buf = ReadBuf::new(&mut temp);
+            match this.inner.as_mut().poll_read(cx, &mut temp_buf) {
+                Poll::Pending => {
+                    if this.temp_buffer.is_empty() {
+                        return Poll::Pending;
+                    }
+                    break;
+                }
+                Poll::Ready(Ok(())) => {
+                    let n = temp_buf.filled().len();
+                    if n == 0 {
+                        if this.temp_buffer.is_empty() {
+                            return Poll::Ready(Ok(()));
+                        }
+                        break;
+                    }
+                    this.temp_buffer.extend_from_slice(&temp[..n]);
+                }
+                Poll::Ready(Err(e)) => {
+                    // error!("CompressReader poll_read: read inner error: {e}");
+                    return Poll::Ready(Err(e));
                 }
             }
-            Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
+        }
+        // Process accumulated data
+        if !this.temp_buffer.is_empty() {
+            let uncompressed_data = &this.temp_buffer;
+            let out = build_compressed_block(uncompressed_data, *this.compression_algorithm);
+            *this.written += out.len();
+            *this.uncomp_written += uncompressed_data.len();
+            if let Err(e) = this.index.add(*this.written as i64, *this.uncomp_written as i64) {
+                // error!("CompressReader index add error: {e}");
+                return Poll::Ready(Err(e));
+            }
+            *this.buffer = out;
+            *this.pos = 0;
+            this.temp_buffer.truncate(0); // More efficient way to clear
+            let to_copy = min(buf.remaining(), this.buffer.len());
+            buf.put_slice(&this.buffer[..to_copy]);
+            *this.pos += to_copy;
+            if *this.pos == this.buffer.len() {
+                this.buffer.clear();
+                *this.pos = 0;
+            }
+            Poll::Ready(Ok(()))
+        } else {
+            Poll::Pending
         }
     }
 }
@@ -163,9 +183,10 @@ where
 
 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
+    /// Header format:
+    /// - First byte: compression type (00 = compressed, 01 = uncompressed, FF = end)
+    /// - Bytes 1-3: length of compressed data (little-endian)
+    /// - Bytes 4-7: CRC32 checksum of uncompressed data (little-endian)
     #[derive(Debug)]
     pub struct DecompressReader<R> {
         #[pin]
@@ -173,11 +194,11 @@ pin_project! {
         buffer: Vec<u8>,
         buffer_pos: usize,
         finished: bool,
-        // New fields for saving header read progress across polls
+        // 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
+        // Fields for saving compressed block read progress across polls
         compressed_buf: Option<Vec<u8>>,
         compressed_read: usize,
         compressed_len: usize,
@@ -187,7 +208,7 @@ pin_project! {
 
 impl<R> DecompressReader<R>
 where
-    R: Reader,
+    R: AsyncRead + Unpin + Send + Sync,
 {
     pub fn new(inner: R, compression_algorithm: CompressionAlgorithm) -> Self {
         Self {
@@ -212,9 +233,9 @@ where
 {
     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
+        // Copy from buffer first if available
         if *this.buffer_pos < this.buffer.len() {
-            let to_copy = std::cmp::min(buf.remaining(), this.buffer.len() - *this.buffer_pos);
+            let to_copy = 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() {
@@ -223,15 +244,13 @@ where
             }
             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]);
+        // Read header
+        while !*this.header_done && *this.header_read < HEADER_LEN {
+            let mut temp = [0u8; HEADER_LEN];
+            let mut temp_buf = ReadBuf::new(&mut temp[0..HEADER_LEN - *this.header_read]);
             match this.inner.as_mut().poll_read(cx, &mut temp_buf) {
                 Poll::Pending => return Poll::Pending,
                 Poll::Ready(Ok(())) => {
@@ -243,34 +262,27 @@ where
                     *this.header_read += n;
                 }
                 Poll::Ready(Err(e)) => {
+                    // error!("DecompressReader poll_read: read header error: {e}");
                     return Poll::Ready(Err(e));
                 }
             }
-            if *this.header_read < 8 {
-                // Header not fully read, return Pending or Ok, wait for next poll
+            if *this.header_read < HEADER_LEN {
                 return Poll::Pending;
             }
         }
-
+        if !*this.header_done && *this.header_read == 0 {
+            return Poll::Ready(Ok(()));
+        }
         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_len = len;
             *this.compressed_buf = Some(vec![0u8; *this.compressed_len]);
             *this.compressed_read = 0;
         }
@@ -287,6 +299,7 @@ where
                     *this.compressed_read += n;
                 }
                 Poll::Ready(Err(e)) => {
+                    // error!("DecompressReader poll_read: read compressed block error: {e}");
                     this.compressed_buf.take();
                     *this.compressed_read = 0;
                     *this.compressed_len = 0;
@@ -294,44 +307,44 @@ where
                 }
             }
         }
-
-        // 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 {
+        let decompressed = if typ == COMPRESS_TYPE_COMPRESSED {
             match decompress_block(compressed_data, *this.compression_algorithm) {
                 Ok(out) => out,
                 Err(e) => {
+                    // error!("DecompressReader decompress_block error: {e}");
                     this.compressed_buf.take();
                     *this.compressed_read = 0;
                     *this.compressed_len = 0;
                     return Poll::Ready(Err(e));
                 }
             }
-        } else if typ == 0x01 {
+        } else if typ == COMPRESS_TYPE_UNCOMPRESSED {
             compressed_data.to_vec()
-        } else if typ == 0xFF {
-            // Handle end marker
+        } else if typ == COMPRESS_TYPE_END {
             this.compressed_buf.take();
             *this.compressed_read = 0;
             *this.compressed_len = 0;
             *this.finished = true;
             return Poll::Ready(Ok(()));
         } else {
+            // error!("DecompressReader unknown compression type: {typ}");
             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 {
+            // error!("DecompressReader decompressed length mismatch: {} != {}", decompressed.len(), uncompress_len);
             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 {
+            // error!("DecompressReader CRC32 mismatch: actual {actual_crc} != expected {crc}");
             this.compressed_buf.take();
             *this.compressed_read = 0;
             *this.compressed_len = 0;
@@ -339,15 +352,17 @@ where
         }
         *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());
+        let to_copy = min(buf.remaining(), this.buffer.len());
         buf.put_slice(&this.buffer[..to_copy]);
         *this.buffer_pos += to_copy;
-
+        if *this.buffer_pos == this.buffer.len() {
+            this.buffer.clear();
+            *this.buffer_pos = 0;
+        }
         Poll::Ready(Ok(()))
     }
 }
@@ -373,8 +388,34 @@ where
     }
 }
 
+/// Build compressed block with header + uvarint + compressed data
+fn build_compressed_block(uncompressed_data: &[u8], compression_algorithm: CompressionAlgorithm) -> Vec<u8> {
+    let crc = crc32fast::hash(uncompressed_data);
+    let compressed_data = compress_block(uncompressed_data, compression_algorithm);
+    let uncompressed_len = uncompressed_data.len();
+    let mut uncompressed_len_buf = [0u8; 10];
+    let int_len = put_uvarint(&mut uncompressed_len_buf[..], uncompressed_len as u64);
+    let len = compressed_data.len() + int_len;
+    let mut header = [0u8; HEADER_LEN];
+    header[0] = COMPRESS_TYPE_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;
+    let mut out = Vec::with_capacity(len + HEADER_LEN);
+    out.extend_from_slice(&header);
+    out.extend_from_slice(&uncompressed_len_buf[..int_len]);
+    out.extend_from_slice(&compressed_data);
+    out
+}
+
 #[cfg(test)]
 mod tests {
+    use crate::WarpReader;
+
     use super::*;
     use std::io::Cursor;
     use tokio::io::{AsyncReadExt, BufReader};
@@ -383,7 +424,7 @@ mod tests {
     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 compress_reader = CompressReader::new(WarpReader::new(reader), CompressionAlgorithm::Gzip);
 
         let mut compressed = Vec::new();
         compress_reader.read_to_end(&mut compressed).await.unwrap();
@@ -400,7 +441,7 @@ mod tests {
     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 compress_reader = CompressReader::new(WarpReader::new(reader), CompressionAlgorithm::Deflate);
 
         let mut compressed = Vec::new();
         compress_reader.read_to_end(&mut compressed).await.unwrap();
@@ -417,7 +458,7 @@ mod tests {
     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 compress_reader = CompressReader::new(WarpReader::new(reader), CompressionAlgorithm::Gzip);
 
         let mut compressed = Vec::new();
         compress_reader.read_to_end(&mut compressed).await.unwrap();
@@ -436,7 +477,7 @@ mod tests {
         let mut data = vec![0u8; 1024 * 1024];
         rand::rng().fill(&mut data[..]);
         let reader = Cursor::new(data.clone());
-        let mut compress_reader = CompressReader::new(reader, CompressionAlgorithm::Gzip);
+        let mut compress_reader = CompressReader::new(WarpReader::new(reader), CompressionAlgorithm::Gzip);
 
         let mut compressed = Vec::new();
         compress_reader.read_to_end(&mut compressed).await.unwrap();
@@ -452,15 +493,15 @@ mod tests {
     async fn test_compress_reader_large_deflate() {
         use rand::Rng;
         // Generate 1MB of random bytes
-        let mut data = vec![0u8; 1024 * 1024];
+        let mut data = vec![0u8; 1024 * 1024 * 3 + 512];
         rand::rng().fill(&mut data[..]);
         let reader = Cursor::new(data.clone());
-        let mut compress_reader = CompressReader::new(reader, CompressionAlgorithm::Deflate);
+        let mut compress_reader = CompressReader::new(WarpReader::new(reader), CompressionAlgorithm::default());
 
         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 decompress_reader = DecompressReader::new(Cursor::new(compressed.clone()), CompressionAlgorithm::default());
         let mut decompressed = Vec::new();
         decompress_reader.read_to_end(&mut decompressed).await.unwrap();
 
diff --git a/crates/rio/src/encrypt_reader.rs b/crates/rio/src/encrypt_reader.rs
index 976fa424..a1b814c3 100644
--- a/crates/rio/src/encrypt_reader.rs
+++ b/crates/rio/src/encrypt_reader.rs
@@ -1,5 +1,6 @@
 use crate::HashReaderDetector;
 use crate::HashReaderMut;
+use crate::compress_index::{Index, TryGetIndex};
 use crate::{EtagResolvable, Reader};
 use aes_gcm::aead::Aead;
 use aes_gcm::{Aes256Gcm, KeyInit, Nonce};
@@ -145,6 +146,15 @@ where
     }
 }
 
+impl<R> TryGetIndex for EncryptReader<R>
+where
+    R: TryGetIndex,
+{
+    fn try_get_index(&self) -> Option<&Index> {
+        self.inner.try_get_index()
+    }
+}
+
 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.
@@ -339,6 +349,8 @@ where
 mod tests {
     use std::io::Cursor;
 
+    use crate::WarpReader;
+
     use super::*;
     use rand::RngCore;
     use tokio::io::{AsyncReadExt, BufReader};
@@ -352,7 +364,7 @@ mod tests {
         rand::rng().fill_bytes(&mut nonce);
 
         let reader = BufReader::new(&data[..]);
-        let encrypt_reader = EncryptReader::new(reader, key, nonce);
+        let encrypt_reader = EncryptReader::new(WarpReader::new(reader), key, nonce);
 
         // Encrypt
         let mut encrypt_reader = encrypt_reader;
@@ -361,7 +373,7 @@ mod tests {
 
         // Decrypt using DecryptReader
         let reader = Cursor::new(encrypted.clone());
-        let decrypt_reader = DecryptReader::new(reader, key, nonce);
+        let decrypt_reader = DecryptReader::new(WarpReader::new(reader), key, nonce);
         let mut decrypt_reader = decrypt_reader;
         let mut decrypted = Vec::new();
         decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
@@ -380,7 +392,7 @@ mod tests {
 
         // Encrypt
         let reader = BufReader::new(&data[..]);
-        let encrypt_reader = EncryptReader::new(reader, key, nonce);
+        let encrypt_reader = EncryptReader::new(WarpReader::new(reader), key, nonce);
         let mut encrypt_reader = encrypt_reader;
         let mut encrypted = Vec::new();
         encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
@@ -388,7 +400,7 @@ mod tests {
         // Now test DecryptReader
 
         let reader = Cursor::new(encrypted.clone());
-        let decrypt_reader = DecryptReader::new(reader, key, nonce);
+        let decrypt_reader = DecryptReader::new(WarpReader::new(reader), key, nonce);
         let mut decrypt_reader = decrypt_reader;
         let mut decrypted = Vec::new();
         decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
@@ -408,13 +420,13 @@ mod tests {
         rand::rng().fill_bytes(&mut nonce);
 
         let reader = std::io::Cursor::new(data.clone());
-        let encrypt_reader = EncryptReader::new(reader, key, nonce);
+        let encrypt_reader = EncryptReader::new(WarpReader::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 decrypt_reader = DecryptReader::new(WarpReader::new(reader), key, nonce);
         let mut decrypt_reader = decrypt_reader;
         let mut decrypted = Vec::new();
         decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
diff --git a/crates/rio/src/etag.rs b/crates/rio/src/etag.rs
index a92618f0..d352b45b 100644
--- a/crates/rio/src/etag.rs
+++ b/crates/rio/src/etag.rs
@@ -17,14 +17,15 @@ The `EtagResolvable` trait provides a clean way to handle recursive unwrapping:
 
 ```rust
 use rustfs_rio::{CompressReader, EtagReader, resolve_etag_generic};
-use rustfs_rio::compress::CompressionAlgorithm;
+use rustfs_rio::WarpReader;
+use rustfs_utils::compress::CompressionAlgorithm;
 use tokio::io::BufReader;
 use std::io::Cursor;
 
 // Direct usage with trait-based approach
 let data = b"test data";
 let reader = BufReader::new(Cursor::new(&data[..]));
-let reader = Box::new(reader);
+let reader = Box::new(WarpReader::new(reader));
 let etag_reader = EtagReader::new(reader, Some("test_etag".to_string()));
 let mut reader = CompressReader::new(etag_reader, CompressionAlgorithm::Gzip);
 let etag = resolve_etag_generic(&mut reader);
@@ -34,9 +35,9 @@ 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 crate::{WarpReader, resolve_etag_generic};
+    use rustfs_utils::compress::CompressionAlgorithm;
     use std::io::Cursor;
     use tokio::io::BufReader;
 
@@ -44,7 +45,7 @@ mod tests {
     fn test_etag_reader_resolution() {
         let data = b"test data";
         let reader = BufReader::new(Cursor::new(&data[..]));
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::new(reader));
         let mut etag_reader = EtagReader::new(reader, Some("test_etag".to_string()));
 
         // Test direct ETag resolution
@@ -55,7 +56,7 @@ mod tests {
     fn test_hash_reader_resolution() {
         let data = b"test data";
         let reader = BufReader::new(Cursor::new(&data[..]));
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::new(reader));
         let mut hash_reader =
             HashReader::new(reader, data.len() as i64, data.len() as i64, Some("hash_etag".to_string()), false).unwrap();
 
@@ -67,7 +68,7 @@ mod tests {
     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 reader = Box::new(WarpReader::new(reader));
         let etag_reader = EtagReader::new(reader, Some("compress_etag".to_string()));
         let mut compress_reader = CompressReader::new(etag_reader, CompressionAlgorithm::Gzip);
 
@@ -79,7 +80,7 @@ mod tests {
     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 reader = Box::new(WarpReader::new(reader));
         let etag_reader = EtagReader::new(reader, Some("encrypt_etag".to_string()));
 
         let key = [0u8; 32];
@@ -94,7 +95,7 @@ mod tests {
     fn test_complex_nesting() {
         let data = b"test data for complex nesting";
         let reader = BufReader::new(Cursor::new(&data[..]));
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::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];
@@ -110,7 +111,7 @@ mod tests {
     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);
+        let reader = Box::new(WarpReader::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();
@@ -127,14 +128,14 @@ mod tests {
         // Test 1: Simple EtagReader
         let data1 = b"simple test";
         let reader1 = BufReader::new(Cursor::new(&data1[..]));
-        let reader1 = Box::new(reader1);
+        let reader1 = Box::new(WarpReader::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 reader2 = Box::new(WarpReader::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()));
@@ -142,7 +143,7 @@ mod tests {
         // Test 3: Single wrapper - CompressReader<EtagReader>
         let data3 = b"compress test";
         let reader3 = BufReader::new(Cursor::new(&data3[..]));
-        let reader3 = Box::new(reader3);
+        let reader3 = Box::new(WarpReader::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()));
@@ -150,7 +151,7 @@ mod tests {
         // 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 reader4 = Box::new(WarpReader::new(reader4));
         let etag_reader4 = EtagReader::new(reader4, Some("double_wrapped_etag".to_string()));
         let key = [1u8; 32];
         let nonce = [1u8; 12];
@@ -172,7 +173,7 @@ mod tests {
 
         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);
+        let base_reader = Box::new(WarpReader::new(base_reader));
         // Create a complex nested structure that might occur in practice:
         // CompressReader<EncryptReader<HashReader<BufReader<Cursor>>>>
         let hash_reader = HashReader::new(
@@ -197,7 +198,7 @@ mod tests {
         // 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 base_reader2 = Box::new(WarpReader::new(base_reader2));
         let etag_reader = EtagReader::new(base_reader2, Some("core_etag".to_string()));
         let key2 = [99u8; 32];
         let nonce2 = [88u8; 12];
@@ -223,21 +224,21 @@ mod tests {
         // 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 reader = Box::new(WarpReader::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 reader2 = Box::new(WarpReader::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 reader3 = Box::new(WarpReader::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);
diff --git a/crates/rio/src/etag_reader.rs b/crates/rio/src/etag_reader.rs
index 73176df8..f76f9fdd 100644
--- a/crates/rio/src/etag_reader.rs
+++ b/crates/rio/src/etag_reader.rs
@@ -1,3 +1,4 @@
+use crate::compress_index::{Index, TryGetIndex};
 use crate::{EtagResolvable, HashReaderDetector, HashReaderMut, Reader};
 use md5::{Digest, Md5};
 use pin_project_lite::pin_project;
@@ -82,8 +83,16 @@ impl HashReaderDetector for EtagReader {
     }
 }
 
+impl TryGetIndex for EtagReader {
+    fn try_get_index(&self) -> Option<&Index> {
+        self.inner.try_get_index()
+    }
+}
+
 #[cfg(test)]
 mod tests {
+    use crate::WarpReader;
+
     use super::*;
     use std::io::Cursor;
     use tokio::io::{AsyncReadExt, BufReader};
@@ -95,7 +104,7 @@ mod tests {
         hasher.update(data);
         let expected = format!("{:x}", hasher.finalize());
         let reader = BufReader::new(&data[..]);
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::new(reader));
         let mut etag_reader = EtagReader::new(reader, None);
 
         let mut buf = Vec::new();
@@ -114,7 +123,7 @@ mod tests {
         hasher.update(data);
         let expected = format!("{:x}", hasher.finalize());
         let reader = BufReader::new(&data[..]);
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::new(reader));
         let mut etag_reader = EtagReader::new(reader, None);
 
         let mut buf = Vec::new();
@@ -133,7 +142,7 @@ mod tests {
         hasher.update(data);
         let expected = format!("{:x}", hasher.finalize());
         let reader = BufReader::new(&data[..]);
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::new(reader));
         let mut etag_reader = EtagReader::new(reader, None);
 
         let mut buf = Vec::new();
@@ -150,7 +159,7 @@ mod tests {
     async fn test_etag_reader_not_finished() {
         let data = b"abc123";
         let reader = BufReader::new(&data[..]);
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::new(reader));
         let mut etag_reader = EtagReader::new(reader, None);
 
         // Do not read to end, etag should be None
@@ -174,7 +183,7 @@ mod tests {
         let expected = format!("{:x}", hasher.finalize());
 
         let reader = Cursor::new(data.clone());
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::new(reader));
         let mut etag_reader = EtagReader::new(reader, None);
 
         let mut buf = Vec::new();
@@ -193,7 +202,7 @@ mod tests {
         hasher.update(data);
         let expected = format!("{:x}", hasher.finalize());
         let reader = BufReader::new(&data[..]);
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::new(reader));
         let mut etag_reader = EtagReader::new(reader, Some(expected.clone()));
 
         let mut buf = Vec::new();
@@ -209,7 +218,7 @@ mod tests {
         let data = b"checksum test data";
         let wrong_checksum = "deadbeefdeadbeefdeadbeefdeadbeef".to_string();
         let reader = BufReader::new(&data[..]);
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::new(reader));
         let mut etag_reader = EtagReader::new(reader, Some(wrong_checksum));
 
         let mut buf = Vec::new();
diff --git a/crates/rio/src/hardlimit_reader.rs b/crates/rio/src/hardlimit_reader.rs
index 716655fc..c108964c 100644
--- a/crates/rio/src/hardlimit_reader.rs
+++ b/crates/rio/src/hardlimit_reader.rs
@@ -1,12 +1,11 @@
+use crate::compress_index::{Index, TryGetIndex};
+use crate::{EtagResolvable, HashReaderDetector, HashReaderMut, Reader};
+use pin_project_lite::pin_project;
 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]
@@ -60,10 +59,18 @@ impl HashReaderDetector for HardLimitReader {
     }
 }
 
+impl TryGetIndex for HardLimitReader {
+    fn try_get_index(&self) -> Option<&Index> {
+        self.inner.try_get_index()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::vec;
 
+    use crate::WarpReader;
+
     use super::*;
     use rustfs_utils::read_full;
     use tokio::io::{AsyncReadExt, BufReader};
@@ -72,7 +79,7 @@ mod tests {
     async fn test_hardlimit_reader_normal() {
         let data = b"hello world";
         let reader = BufReader::new(&data[..]);
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::new(reader));
         let hardlimit = HardLimitReader::new(reader, 20);
         let mut r = hardlimit;
         let mut buf = Vec::new();
@@ -85,7 +92,7 @@ mod tests {
     async fn test_hardlimit_reader_exact_limit() {
         let data = b"1234567890";
         let reader = BufReader::new(&data[..]);
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::new(reader));
         let hardlimit = HardLimitReader::new(reader, 10);
         let mut r = hardlimit;
         let mut buf = Vec::new();
@@ -98,7 +105,7 @@ mod tests {
     async fn test_hardlimit_reader_exceed_limit() {
         let data = b"abcdef";
         let reader = BufReader::new(&data[..]);
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::new(reader));
         let hardlimit = HardLimitReader::new(reader, 3);
         let mut r = hardlimit;
         let mut buf = vec![0u8; 10];
@@ -123,7 +130,7 @@ mod tests {
     async fn test_hardlimit_reader_empty() {
         let data = b"";
         let reader = BufReader::new(&data[..]);
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::new(reader));
         let hardlimit = HardLimitReader::new(reader, 5);
         let mut r = hardlimit;
         let mut buf = Vec::new();
diff --git a/crates/rio/src/hash_reader.rs b/crates/rio/src/hash_reader.rs
index f82f026b..c869431c 100644
--- a/crates/rio/src/hash_reader.rs
+++ b/crates/rio/src/hash_reader.rs
@@ -24,11 +24,12 @@
 //! use rustfs_rio::{HashReader, HardLimitReader, EtagReader};
 //! use tokio::io::BufReader;
 //! use std::io::Cursor;
+//! use rustfs_rio::WarpReader;
 //!
 //! # tokio_test::block_on(async {
 //! let data = b"hello world";
 //! let reader = BufReader::new(Cursor::new(&data[..]));
-//! let reader = Box::new(reader);
+//! let reader = Box::new(WarpReader::new(reader));
 //! let size = data.len() as i64;
 //! let actual_size = size;
 //! let etag = None;
@@ -39,7 +40,7 @@
 //!
 //! // Method 2: With manual wrapping to recreate original logic
 //! let reader2 = BufReader::new(Cursor::new(&data[..]));
-//! let reader2 = Box::new(reader2);
+//! let reader2 = Box::new(WarpReader::new(reader2));
 //! let wrapped_reader: Box<dyn rustfs_rio::Reader> = if size > 0 {
 //!     if !diskable_md5 {
 //!         // Wrap with both HardLimitReader and EtagReader
@@ -68,18 +69,19 @@
 //! use rustfs_rio::{HashReader, HashReaderDetector};
 //! use tokio::io::BufReader;
 //! use std::io::Cursor;
+//! use rustfs_rio::WarpReader;
 //!
 //! # tokio_test::block_on(async {
 //! let data = b"test";
 //! let reader = BufReader::new(Cursor::new(&data[..]));
-//! let hash_reader = HashReader::new(Box::new(reader), 4, 4, None, false).unwrap();
+//! let hash_reader = HashReader::new(Box::new(WarpReader::new(reader)), 4, 4, None, false).unwrap();
 //!
 //! // 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(Box::new(reader2), 4, 4, None, false);
+//! let result = HashReader::new(Box::new(WarpReader::new(reader2)), 4, 4, None, false);
 //! assert!(result.is_ok());
 //! # });
 //! ```
@@ -89,6 +91,7 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 use tokio::io::{AsyncRead, ReadBuf};
 
+use crate::compress_index::{Index, TryGetIndex};
 use crate::{EtagReader, EtagResolvable, HardLimitReader, HashReaderDetector, Reader};
 
 /// Trait for mutable operations on HashReader
@@ -283,10 +286,16 @@ impl HashReaderDetector for HashReader {
     }
 }
 
+impl TryGetIndex for HashReader {
+    fn try_get_index(&self) -> Option<&Index> {
+        self.inner.try_get_index()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{DecryptReader, encrypt_reader};
+    use crate::{DecryptReader, WarpReader, encrypt_reader};
     use std::io::Cursor;
     use tokio::io::{AsyncReadExt, BufReader};
 
@@ -299,14 +308,14 @@ mod tests {
 
         // Test 1: Simple creation
         let reader1 = BufReader::new(Cursor::new(&data[..]));
-        let reader1 = Box::new(reader1);
+        let reader1 = Box::new(WarpReader::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 reader2 = Box::new(WarpReader::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();
@@ -315,7 +324,7 @@ mod tests {
 
         // Test 3: With EtagReader wrapping
         let reader3 = BufReader::new(Cursor::new(&data[..]));
-        let reader3 = Box::new(reader3);
+        let reader3 = Box::new(WarpReader::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();
@@ -327,7 +336,7 @@ mod tests {
     async fn test_hashreader_etag_basic() {
         let data = b"hello hashreader";
         let reader = BufReader::new(Cursor::new(&data[..]));
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::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();
@@ -341,7 +350,7 @@ mod tests {
     async fn test_hashreader_diskable_md5() {
         let data = b"no etag";
         let reader = BufReader::new(Cursor::new(&data[..]));
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::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();
@@ -355,11 +364,11 @@ mod tests {
     async fn test_hashreader_new_logic() {
         let data = b"test data";
         let reader = BufReader::new(Cursor::new(&data[..]));
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::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);
+        let hash_reader = Box::new(WarpReader::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);
 
@@ -371,11 +380,11 @@ mod tests {
 
     #[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;
+        use rustfs_utils::compress::CompressionAlgorithm;
 
         // Generate 1MB random data
         let size = 1024 * 1024;
@@ -397,7 +406,7 @@ mod tests {
         let size = data.len() as i64;
         let actual_size = data.len() as i64;
 
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::new(reader));
         // 创建 HashReader
         let mut hr = HashReader::new(reader, size, actual_size, Some(expected.clone()), false).unwrap();
 
@@ -427,7 +436,7 @@ mod tests {
 
         if is_encrypt {
             // 加密压缩后的数据
-            let encrypt_reader = encrypt_reader::EncryptReader::new(Cursor::new(compressed_data), key, nonce);
+            let encrypt_reader = encrypt_reader::EncryptReader::new(WarpReader::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();
@@ -435,14 +444,15 @@ mod tests {
             println!("Encrypted size: {}", encrypted_data.len());
 
             // 解密数据
-            let decrypt_reader = DecryptReader::new(Cursor::new(encrypted_data), key, nonce);
+            let decrypt_reader = DecryptReader::new(WarpReader::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 decompress_reader =
+                    DecompressReader::new(WarpReader::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();
@@ -460,7 +470,8 @@ mod tests {
 
         // 如果不加密，直接处理压缩/解压缩
         if is_compress {
-            let decompress_reader = DecompressReader::new(Cursor::new(compressed_data), CompressionAlgorithm::Gzip);
+            let decompress_reader =
+                DecompressReader::new(WarpReader::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();
@@ -481,8 +492,8 @@ mod tests {
 
     #[tokio::test]
     async fn test_compression_with_compressible_data() {
-        use crate::compress::CompressionAlgorithm;
         use crate::{CompressReader, DecompressReader};
+        use rustfs_utils::compress::CompressionAlgorithm;
 
         // Create highly compressible data (repeated pattern)
         let pattern = b"Hello, World! This is a test pattern that should compress well. ";
@@ -495,7 +506,7 @@ mod tests {
         println!("Original data size: {} bytes", data.len());
 
         let reader = BufReader::new(Cursor::new(data.clone()));
-        let reader = Box::new(reader);
+        let reader = Box::new(WarpReader::new(reader));
         let hash_reader = HashReader::new(reader, data.len() as i64, data.len() as i64, None, false).unwrap();
 
         // Test compression
@@ -525,8 +536,8 @@ mod tests {
 
     #[tokio::test]
     async fn test_compression_algorithms() {
-        use crate::compress::CompressionAlgorithm;
         use crate::{CompressReader, DecompressReader};
+        use rustfs_utils::compress::CompressionAlgorithm;
 
         let data = b"This is test data for compression algorithm testing. ".repeat(1000);
         println!("Testing with {} bytes of data", data.len());
@@ -541,7 +552,7 @@ mod tests {
             println!("\nTesting algorithm: {:?}", algorithm);
 
             let reader = BufReader::new(Cursor::new(data.clone()));
-            let reader = Box::new(reader);
+            let reader = Box::new(WarpReader::new(reader));
             let hash_reader = HashReader::new(reader, data.len() as i64, data.len() as i64, None, false).unwrap();
 
             // Compress
diff --git a/crates/rio/src/http_reader.rs b/crates/rio/src/http_reader.rs
index 3bdb1d2d..e42c94f9 100644
--- a/crates/rio/src/http_reader.rs
+++ b/crates/rio/src/http_reader.rs
@@ -1,16 +1,27 @@
 use bytes::Bytes;
-use futures::{Stream, StreamExt};
+use futures::{Stream, TryStreamExt as _};
 use http::HeaderMap;
 use pin_project_lite::pin_project;
 use reqwest::{Client, Method, RequestBuilder};
+use std::error::Error as _;
 use std::io::{self, Error};
+use std::ops::Not as _;
 use std::pin::Pin;
+use std::sync::LazyLock;
 use std::task::{Context, Poll};
-use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt, DuplexStream, ReadBuf};
-use tokio::sync::{mpsc, oneshot};
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+use tokio::sync::mpsc;
+use tokio_util::io::StreamReader;
 
 use crate::{EtagResolvable, HashReaderDetector, HashReaderMut};
 
+fn get_http_client() -> Client {
+    // Reuse the HTTP connection pool in the global `reqwest::Client` instance
+    // TODO: interact with load balancing?
+    static CLIENT: LazyLock<Client> = LazyLock::new(Client::new);
+    CLIENT.clone()
+}
+
 static HTTP_DEBUG_LOG: bool = false;
 #[inline(always)]
 fn http_debug_log(args: std::fmt::Arguments) {
@@ -29,88 +40,68 @@ pin_project! {
         url:String,
         method: Method,
         headers: HeaderMap,
-        inner: DuplexStream,
-        err_rx: oneshot::Receiver<std::io::Error>,
+        #[pin]
+        inner: StreamReader<Pin<Box<dyn Stream<Item=std::io::Result<Bytes>>+Send+Sync>>, Bytes>,
     }
 }
 
 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
+    pub async fn new(url: String, method: Method, headers: HeaderMap, body: Option<Vec<u8>>) -> io::Result<Self> {
+        // http_log!("[HttpReader::new] url: {url}, method: {method:?}, headers: {headers:?}");
+        Self::with_capacity(url, method, headers, body, 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
-        );
+    pub async fn with_capacity(
+        url: String,
+        method: Method,
+        headers: HeaderMap,
+        body: Option<Vec<u8>>,
+        _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 client = get_http_client();
         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())));
+                    return Err(Error::other(format!("HEAD failed: url: {}, status {}", url, resp.status())));
                 }
             }
             Err(e) => {
                 http_log!("[HttpReader::new] HEAD error: {e}");
-                return Err(Error::other(format!("HEAD request failed: {e}")));
+                return Err(Error::other(e.source().map(|s| s.to_string()).unwrap_or_else(|| e.to_string())));
             }
         }
 
-        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 client = get_http_client();
+        let mut request: RequestBuilder = client.request(method.clone(), url.clone()).headers(headers.clone());
+        if let Some(body) = body {
+            request = request.body(body);
         }
-        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)));
-                }
-            }
+        let resp = request
+            .send()
+            .await
+            .map_err(|e| Error::other(format!("HttpReader HTTP request error: {}", e)))?;
+
+        if resp.status().is_success().not() {
+            return Err(Error::other(format!(
+                "HttpReader HTTP request failed with non-200 status {}",
+                resp.status()
+            )));
+        }
+
+        let stream = resp
+            .bytes_stream()
+            .map_err(|e| Error::other(format!("HttpReader stream error: {}", e)));
 
-            http_log!("[HttpReader::spawn] HTTP request completed, exiting");
-        });
         Ok(Self {
-            inner: rd,
-            err_rx,
+            inner: StreamReader::new(Box::pin(stream)),
             url,
             method,
             headers,
@@ -129,20 +120,12 @@ impl HttpReader {
 
 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")));
-            }
-        }
+        // http_log!(
+        //     "[HttpReader::poll_read] url: {}, method: {:?}, buf.remaining: {}",
+        //     self.url,
+        //     self.method,
+        //     buf.remaining()
+        // );
         // Read from the inner stream
         Pin::new(&mut self.inner).poll_read(cx, buf)
     }
@@ -175,20 +158,20 @@ 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(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))) => {
+        //         // 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
@@ -214,23 +197,23 @@ pin_project! {
 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:?}");
+        // 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 client = get_http_client();
         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());
+                // 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}");
+                // http_log!("[HttpWriter::new] empty PUT error: {e}");
                 return Err(Error::other(format!("Empty PUT failed: {e}")));
             }
         }
@@ -241,11 +224,11 @@ impl HttpWriter {
         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:?}"
-            );
+            // http_log!(
+            //     "[HttpWriter::spawn] sending HTTP request: url={url_clone}, method={method_clone:?}, headers={headers_clone:?}"
+            // );
 
-            let client = Client::new();
+            let client = get_http_client();
             let request = client
                 .request(method_clone, url_clone.clone())
                 .headers(headers_clone.clone())
@@ -256,7 +239,7 @@ impl HttpWriter {
 
             match response {
                 Ok(resp) => {
-                    http_log!("[HttpWriter::spawn] got response: status={}", resp.status());
+                    // 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 {}",
@@ -266,17 +249,17 @@ impl HttpWriter {
                     }
                 }
                 Err(e) => {
-                    http_log!("[HttpWriter::spawn] HTTP request error: {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");
+            // http_log!("[HttpWriter::spawn] HTTP request completed, exiting");
             Ok(())
         });
 
-        http_log!("[HttpWriter::new] connection established successfully");
+        // http_log!("[HttpWriter::new] connection established successfully");
         Ok(Self {
             url,
             method,
@@ -303,12 +286,12 @@ impl HttpWriter {
 
 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()
-        );
+        // 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));
         }
@@ -325,12 +308,19 @@ impl AsyncWrite for HttpWriter {
     }
 
     fn poll_shutdown(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        // let url = self.url.clone();
+        // let method = self.method.clone();
+
         if !self.finish {
-            http_log!("[HttpWriter::poll_shutdown] url: {}, method: {:?}", self.url, self.method);
+            // http_log!("[HttpWriter::poll_shutdown] url: {}, method: {:?}", url, 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");
+            // http_log!(
+            //     "[HttpWriter::poll_shutdown] sent shutdown signal to HTTP request, url: {}, method: {:?}",
+            //     url,
+            //     method
+            // );
 
             self.finish = true;
         }
@@ -338,13 +328,18 @@ impl AsyncWrite for HttpWriter {
         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");
+                // http_log!(
+                //     "[HttpWriter::poll_shutdown] HTTP request finished successfully, url: {}, method: {:?}",
+                //     url,
+                //     method
+                // );
             }
             Poll::Ready(Err(e)) => {
-                http_log!("[HttpWriter::poll_shutdown] HTTP request failed: {e}");
+                // http_log!("[HttpWriter::poll_shutdown] HTTP request failed: {e}, url: {}, method: {:?}", url, method);
                 return Poll::Ready(Err(Error::other(format!("HTTP request failed: {}", e))));
             }
             Poll::Pending => {
+                // http_log!("[HttpWriter::poll_shutdown] HTTP request pending, url: {}, method: {:?}", url, method);
                 return Poll::Pending;
             }
         }
diff --git a/crates/rio/src/lib.rs b/crates/rio/src/lib.rs
index 579c34f0..7f961cc1 100644
--- a/crates/rio/src/lib.rs
+++ b/crates/rio/src/lib.rs
@@ -1,11 +1,11 @@
 mod limit_reader;
-use std::io::Cursor;
 
 pub use limit_reader::LimitReader;
 
 mod etag_reader;
 pub use etag_reader::EtagReader;
 
+mod compress_index;
 mod compress_reader;
 pub use compress_reader::{CompressReader, DecompressReader};
 
@@ -18,21 +18,20 @@ pub use hardlimit_reader::HardLimitReader;
 mod hash_reader;
 pub use hash_reader::*;
 
-pub mod compress;
-
 pub mod reader;
 pub use reader::WarpReader;
 
 mod writer;
-use tokio::io::{AsyncRead, BufReader};
 pub use writer::*;
 
 mod http_reader;
 pub use http_reader::*;
 
+pub use compress_index::TryGetIndex;
+
 mod etag;
 
-pub trait Reader: tokio::io::AsyncRead + Unpin + Send + Sync + EtagResolvable + HashReaderDetector {}
+pub trait Reader: tokio::io::AsyncRead + Unpin + Send + Sync + EtagResolvable + HashReaderDetector + TryGetIndex {}
 
 // Trait for types that can be recursively searched for etag capability
 pub trait EtagResolvable {
@@ -52,12 +51,6 @@ where
     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 {
@@ -69,41 +62,8 @@ pub trait HashReaderDetector {
     }
 }
 
-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 {}
-
-impl Reader for tokio::fs::File {}
-impl HashReaderDetector for tokio::fs::File {}
-impl EtagResolvable for tokio::fs::File {}
-
-impl Reader for tokio::io::DuplexStream {}
-impl HashReaderDetector for tokio::io::DuplexStream {}
-impl EtagResolvable for tokio::io::DuplexStream {}
+impl<R> Reader for crate::EncryptReader<R> where R: Reader {}
diff --git a/crates/rio/src/limit_reader.rs b/crates/rio/src/limit_reader.rs
index 6c50d826..4e2ac18b 100644
--- a/crates/rio/src/limit_reader.rs
+++ b/crates/rio/src/limit_reader.rs
@@ -9,7 +9,7 @@
 //! 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 limit_reader = LimitReader::new(reader, data.len());
 //!
 //!      let mut buf = Vec::new();
 //!      let n = limit_reader.read_to_end(&mut buf).await.unwrap();
@@ -23,25 +23,25 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 use tokio::io::{AsyncRead, ReadBuf};
 
-use crate::{EtagResolvable, HashReaderDetector, HashReaderMut, Reader};
+use crate::{EtagResolvable, HashReaderDetector, HashReaderMut};
 
 pin_project! {
     #[derive(Debug)]
     pub struct LimitReader<R> {
         #[pin]
         pub inner: R,
-        limit: u64,
-        read: u64,
+        limit: usize,
+        read: usize,
     }
 }
 
 /// A wrapper for AsyncRead that limits the total number of bytes read.
 impl<R> LimitReader<R>
 where
-    R: Reader,
+    R: AsyncRead + Unpin + Send + Sync,
 {
     /// Create a new LimitReader wrapping `inner`, with a total read limit of `limit` bytes.
-    pub fn new(inner: R, limit: u64) -> Self {
+    pub fn new(inner: R, limit: usize) -> Self {
         Self { inner, limit, read: 0 }
     }
 }
@@ -57,7 +57,7 @@ where
             return Poll::Ready(Ok(()));
         }
         let orig_remaining = buf.remaining();
-        let allowed = remaining.min(orig_remaining as u64) as usize;
+        let allowed = remaining.min(orig_remaining);
         if allowed == 0 {
             return Poll::Ready(Ok(()));
         }
@@ -66,7 +66,7 @@ where
             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;
+                *this.read += n;
             }
             poll
         } else {
@@ -76,7 +76,7 @@ where
             if let Poll::Ready(Ok(())) = &poll {
                 let n = temp_buf.filled().len();
                 buf.put_slice(temp_buf.filled());
-                *this.read += n as u64;
+                *this.read += n;
             }
             poll
         }
@@ -115,7 +115,7 @@ mod tests {
     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 limit_reader = LimitReader::new(reader, data.len());
 
         let mut buf = Vec::new();
         let n = limit_reader.read_to_end(&mut buf).await.unwrap();
@@ -176,7 +176,7 @@ mod tests {
         let mut data = vec![0u8; size];
         rand::rng().fill(&mut data[..]);
         let reader = Cursor::new(data.clone());
-        let mut limit_reader = LimitReader::new(reader, size as u64);
+        let mut limit_reader = LimitReader::new(reader, size);
 
         // Read data into buffer
         let mut buf = Vec::new();
diff --git a/crates/rio/src/reader.rs b/crates/rio/src/reader.rs
index 88ed8b31..147a315c 100644
--- a/crates/rio/src/reader.rs
+++ b/crates/rio/src/reader.rs
@@ -2,6 +2,7 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 use tokio::io::{AsyncRead, ReadBuf};
 
+use crate::compress_index::TryGetIndex;
 use crate::{EtagResolvable, HashReaderDetector, Reader};
 
 pub struct WarpReader<R> {
@@ -24,4 +25,6 @@ impl<R: AsyncRead + Unpin + Send + Sync> HashReaderDetector for WarpReader<R> {}
 
 impl<R: AsyncRead + Unpin + Send + Sync> EtagResolvable for WarpReader<R> {}
 
+impl<R: AsyncRead + Unpin + Send + Sync> TryGetIndex for WarpReader<R> {}
+
 impl<R: AsyncRead + Unpin + Send + Sync> Reader for WarpReader<R> {}
diff --git a/crates/utils/Cargo.toml b/crates/utils/Cargo.toml
index c208772a..08339cbe 100644
--- a/crates/utils/Cargo.toml
+++ b/crates/utils/Cargo.toml
@@ -18,7 +18,7 @@ md-5 = { workspace = true, optional = true }
 netif= { workspace = true , optional = true}
 nix = { workspace = true, optional = true }
 regex= { workspace = true, optional = true }
-rustfs-config = { workspace = true }
+rustfs-config = { workspace = true, features = ["constants"] }
 rustls = { workspace = true, optional = true }
 rustls-pemfile = { workspace = true, optional = true }
 rustls-pki-types = { workspace = true, optional = true }
@@ -28,6 +28,16 @@ tempfile = { workspace = true, optional = true }
 tokio = { workspace = true, optional = true, features = ["io-util", "macros"] }
 tracing = { workspace = true }
 url = { workspace = true , optional = true}
+flate2 = { workspace = true, optional = true }
+brotli = { workspace = true, optional = true }
+zstd = { workspace = true, optional = true }
+snap = { workspace = true, optional = true }
+lz4 = { workspace = true, optional = true }
+rand = { workspace = true, optional = true }
+futures = { workspace = true, optional = true }
+transform-stream = { workspace = true, optional = true }
+bytes = { workspace = true, optional = true }
+sysinfo = { workspace = true, optional = true }
 hyper.workspace = true
 hyper-util.workspace = true
 common.workspace = true
@@ -36,9 +46,9 @@ sha2 = { workspace = true, optional = true }
 hmac.workspace = true
 s3s.workspace = true
 
-
 [dev-dependencies]
 tempfile = { workspace = true }
+rand = { workspace = true }
 
 [target.'cfg(windows)'.dependencies]
 winapi = { workspace = true, optional = true, features = ["std", "fileapi", "minwindef", "ntdef", "winnt"] }
@@ -50,12 +60,14 @@ workspace = true
 default = ["ip"]  # features that are enabled by default
 ip = ["dep:local-ip-address"]  # ip characteristics and their dependencies
 tls = ["dep:rustls", "dep:rustls-pemfile", "dep:rustls-pki-types"]  # tls characteristics and their dependencies
-net = ["ip","dep:url", "dep:netif", "dep:lazy_static"]  # empty network features
+net = ["ip", "dep:url", "dep:netif", "dep:lazy_static", "dep:futures", "dep:transform-stream", "dep:bytes"]  # empty network features
 io = ["dep:tokio"]
 path = []
-string = ["dep:regex","dep:lazy_static"]
+compress = ["dep:flate2", "dep:brotli", "dep:snap", "dep:lz4", "dep:zstd"]
+string = ["dep:regex", "dep:lazy_static", "dep:rand"]
 crypto = ["dep:base64-simd","dep:hex-simd"]
 hash = ["dep:highway", "dep:md-5", "dep:sha2", "dep:blake3", "dep:serde", "dep:siphasher"]
 os = ["dep:nix", "dep:tempfile", "winapi"]  # operating system utilities
 integration = []  # integration test features
-full = ["ip", "tls", "net", "io","hash", "os", "integration","path","crypto", "string"]  # all features
+sys = ["dep:sysinfo"]  # system information features
+full = ["ip", "tls", "net", "io", "hash", "os", "integration", "path", "crypto", "string", "compress", "sys"]  # all features
diff --git a/crates/rio/src/compress.rs b/crates/utils/src/compress.rs
similarity index 81%
rename from crates/rio/src/compress.rs
rename to crates/utils/src/compress.rs
index 9ba4fc46..75470648 100644
--- a/crates/rio/src/compress.rs
+++ b/crates/utils/src/compress.rs
@@ -1,13 +1,13 @@
-use http::HeaderMap;
 use std::io::Write;
 use tokio::io;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
 pub enum CompressionAlgorithm {
+    None,
     Gzip,
-    #[default]
     Deflate,
     Zstd,
+    #[default]
     Lz4,
     Brotli,
     Snappy,
@@ -16,6 +16,7 @@ pub enum CompressionAlgorithm {
 impl CompressionAlgorithm {
     pub fn as_str(&self) -> &str {
         match self {
+            CompressionAlgorithm::None => "none",
             CompressionAlgorithm::Gzip => "gzip",
             CompressionAlgorithm::Deflate => "deflate",
             CompressionAlgorithm::Zstd => "zstd",
@@ -42,10 +43,8 @@ impl std::str::FromStr for CompressionAlgorithm {
             "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),
-            )),
+            "none" => Ok(CompressionAlgorithm::None),
+            _ => Err(std::io::Error::other(format!("Unsupported compression algorithm: {}", s))),
         }
     }
 }
@@ -88,6 +87,7 @@ pub fn compress_block(input: &[u8], algorithm: CompressionAlgorithm) -> Vec<u8>
             let _ = encoder.write_all(input);
             encoder.into_inner().unwrap_or_default()
         }
+        CompressionAlgorithm::None => input.to_vec(),
     }
 }
 
@@ -129,20 +129,15 @@ pub fn decompress_block(compressed: &[u8], algorithm: CompressionAlgorithm) -> i
             std::io::Read::read_to_end(&mut decoder, &mut out)?;
             Ok(out)
         }
+        CompressionAlgorithm::None => Ok(Vec::new()),
     }
 }
 
-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;
+    use std::time::Instant;
 
     #[test]
     fn test_compress_decompress_gzip() {
@@ -267,4 +262,57 @@ mod tests {
                 && !snappy.is_empty()
         );
     }
+
+    #[test]
+    fn test_compression_benchmark() {
+        let sizes = [128 * 1024, 512 * 1024, 1024 * 1024];
+        let algorithms = [
+            CompressionAlgorithm::Gzip,
+            CompressionAlgorithm::Deflate,
+            CompressionAlgorithm::Zstd,
+            CompressionAlgorithm::Lz4,
+            CompressionAlgorithm::Brotli,
+            CompressionAlgorithm::Snappy,
+        ];
+
+        println!("\n压缩算法基准测试结果:");
+        println!(
+            "{:<10} {:<10} {:<15} {:<15} {:<15}",
+            "数据大小", "算法", "压缩时间(ms)", "压缩后大小", "压缩率"
+        );
+
+        for size in sizes {
+            // 生成可压缩的数据（重复的文本模式）
+            let pattern = b"Hello, this is a test pattern that will be repeated multiple times to create compressible data. ";
+            let data: Vec<u8> = pattern.iter().cycle().take(size).copied().collect();
+
+            for algo in algorithms {
+                // 压缩测试
+                let start = Instant::now();
+                let compressed = compress_block(&data, algo);
+                let compress_time = start.elapsed();
+
+                // 解压测试
+                let start = Instant::now();
+                let _decompressed = decompress_block(&compressed, algo).unwrap();
+                let _decompress_time = start.elapsed();
+
+                // 计算压缩率
+                let compression_ratio = (size as f64 / compressed.len() as f64) as f32;
+
+                println!(
+                    "{:<10} {:<10} {:<15.2} {:<15} {:<15.2}x",
+                    format!("{}KB", size / 1024),
+                    algo.as_str(),
+                    compress_time.as_secs_f64() * 1000.0,
+                    compressed.len(),
+                    compression_ratio
+                );
+
+                // 验证解压结果
+                assert_eq!(_decompressed, data);
+            }
+            println!(); // 添加空行分隔不同大小的结果
+        }
+    }
 }
diff --git a/crates/utils/src/dirs.rs b/crates/utils/src/dirs.rs
new file mode 100644
index 00000000..e2bcaebd
--- /dev/null
+++ b/crates/utils/src/dirs.rs
@@ -0,0 +1,60 @@
+use std::env;
+use std::path::{Path, PathBuf};
+
+/// Get the absolute path to the current project
+///
+/// This function will try the following method to get the project path:
+/// 1. Use the `CARGO_MANIFEST_DIR` environment variable to get the project root directory.
+/// 2. Use `std::env::current_exe()` to get the executable file path and deduce the project root directory.
+/// 3. Use `std::env::current_dir()` to get the current working directory and try to deduce the project root directory.
+///
+/// If all methods fail, an error is returned.
+///
+/// # Returns
+/// - `Ok(PathBuf)`: The absolute path of the project that was successfully obtained.
+/// - `Err(String)`: Error message for the failed path.
+pub fn get_project_root() -> Result<PathBuf, String> {
+    // Try to get the project root directory through the CARGO_MANIFEST_DIR environment variable
+    if let Ok(manifest_dir) = env::var("CARGO_MANIFEST_DIR") {
+        let project_root = Path::new(&manifest_dir).to_path_buf();
+        println!("Get the project root directory with CARGO_MANIFEST_DIR:{}", project_root.display());
+        return Ok(project_root);
+    }
+
+    // Try to deduce the project root directory through the current executable file path
+    if let Ok(current_exe) = env::current_exe() {
+        let mut project_root = current_exe;
+        // Assume that the project root directory is in the parent directory of the parent directory of the executable path (usually target/debug or target/release)
+        project_root.pop(); // Remove the executable file name
+        project_root.pop(); // Remove target/debug or target/release
+        println!("Deduce the project root directory through current_exe:{}", project_root.display());
+        return Ok(project_root);
+    }
+
+    // Try to deduce the project root directory from the current working directory
+    if let Ok(mut current_dir) = env::current_dir() {
+        // Assume that the project root directory is in the parent directory of the current working directory
+        current_dir.pop();
+        println!("Deduce the project root directory through current_dir:{}", current_dir.display());
+        return Ok(current_dir);
+    }
+
+    // If all methods fail, return an error
+    Err("The project root directory cannot be obtained. Please check the running environment and project structure.".to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_project_root() {
+        match get_project_root() {
+            Ok(path) => {
+                assert!(path.exists(), "The project root directory does not exist:{}", path.display());
+                println!("The test is passed, the project root directory:{}", path.display());
+            }
+            Err(e) => panic!("Failed to get the project root directory:{}", e),
+        }
+    }
+}
diff --git a/crates/utils/src/hash.rs b/crates/utils/src/hash.rs
index 2f526f1b..a2b503a0 100644
--- a/crates/utils/src/hash.rs
+++ b/crates/utils/src/hash.rs
@@ -24,24 +24,56 @@ pub enum HashAlgorithm {
     None,
 }
 
+enum HashEncoded {
+    Md5([u8; 16]),
+    Sha256([u8; 32]),
+    HighwayHash256([u8; 32]),
+    HighwayHash256S([u8; 32]),
+    Blake2b512(blake3::Hash),
+    None,
+}
+
+impl AsRef<[u8]> for HashEncoded {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        match self {
+            HashEncoded::Md5(hash) => hash.as_ref(),
+            HashEncoded::Sha256(hash) => hash.as_ref(),
+            HashEncoded::HighwayHash256(hash) => hash.as_ref(),
+            HashEncoded::HighwayHash256S(hash) => hash.as_ref(),
+            HashEncoded::Blake2b512(hash) => hash.as_bytes(),
+            HashEncoded::None => &[],
+        }
+    }
+}
+
+#[inline]
+fn u8x32_from_u64x4(input: [u64; 4]) -> [u8; 32] {
+    let mut output = [0u8; 32];
+    for (i, &n) in input.iter().enumerate() {
+        output[i * 8..(i + 1) * 8].copy_from_slice(&n.to_le_bytes());
+    }
+    output
+}
+
 impl HashAlgorithm {
     /// Hash the input data and return the hash result as Vec<u8>.
-    pub fn hash_encode(&self, data: &[u8]) -> Vec<u8> {
+    pub fn hash_encode(&self, data: &[u8]) -> impl AsRef<[u8]> {
         match self {
-            HashAlgorithm::Md5 => Md5::digest(data).to_vec(),
+            HashAlgorithm::Md5 => HashEncoded::Md5(Md5::digest(data).into()),
             HashAlgorithm::HighwayHash256 => {
                 let mut hasher = HighwayHasher::new(Key(HIGHWAY_HASH256_KEY));
                 hasher.append(data);
-                hasher.finalize256().iter().flat_map(|&n| n.to_le_bytes()).collect()
+                HashEncoded::HighwayHash256(u8x32_from_u64x4(hasher.finalize256()))
             }
-            HashAlgorithm::SHA256 => Sha256::digest(data).to_vec(),
+            HashAlgorithm::SHA256 => HashEncoded::Sha256(Sha256::digest(data).into()),
             HashAlgorithm::HighwayHash256S => {
                 let mut hasher = HighwayHasher::new(Key(HIGHWAY_HASH256_KEY));
                 hasher.append(data);
-                hasher.finalize256().iter().flat_map(|&n| n.to_le_bytes()).collect()
+                HashEncoded::HighwayHash256S(u8x32_from_u64x4(hasher.finalize256()))
             }
-            HashAlgorithm::BLAKE2b512 => blake3::hash(data).as_bytes().to_vec(),
-            HashAlgorithm::None => Vec::new(),
+            HashAlgorithm::BLAKE2b512 => HashEncoded::Blake2b512(blake3::hash(data)),
+            HashAlgorithm::None => HashEncoded::None,
         }
     }
 
@@ -100,6 +132,7 @@ mod tests {
     fn test_hash_encode_none() {
         let data = b"test data";
         let hash = HashAlgorithm::None.hash_encode(data);
+        let hash = hash.as_ref();
         assert_eq!(hash.len(), 0);
     }
 
@@ -107,9 +140,11 @@ mod tests {
     fn test_hash_encode_md5() {
         let data = b"test data";
         let hash = HashAlgorithm::Md5.hash_encode(data);
+        let hash = hash.as_ref();
         assert_eq!(hash.len(), 16);
         // MD5 should be deterministic
         let hash2 = HashAlgorithm::Md5.hash_encode(data);
+        let hash2 = hash2.as_ref();
         assert_eq!(hash, hash2);
     }
 
@@ -117,9 +152,11 @@ mod tests {
     fn test_hash_encode_highway() {
         let data = b"test data";
         let hash = HashAlgorithm::HighwayHash256.hash_encode(data);
+        let hash = hash.as_ref();
         assert_eq!(hash.len(), 32);
         // HighwayHash should be deterministic
         let hash2 = HashAlgorithm::HighwayHash256.hash_encode(data);
+        let hash2 = hash2.as_ref();
         assert_eq!(hash, hash2);
     }
 
@@ -127,9 +164,11 @@ mod tests {
     fn test_hash_encode_sha256() {
         let data = b"test data";
         let hash = HashAlgorithm::SHA256.hash_encode(data);
+        let hash = hash.as_ref();
         assert_eq!(hash.len(), 32);
         // SHA256 should be deterministic
         let hash2 = HashAlgorithm::SHA256.hash_encode(data);
+        let hash2 = hash2.as_ref();
         assert_eq!(hash, hash2);
     }
 
@@ -137,9 +176,11 @@ mod tests {
     fn test_hash_encode_blake2b512() {
         let data = b"test data";
         let hash = HashAlgorithm::BLAKE2b512.hash_encode(data);
+        let hash = hash.as_ref();
         assert_eq!(hash.len(), 32); // blake3 outputs 32 bytes by default
         // BLAKE2b512 should be deterministic
         let hash2 = HashAlgorithm::BLAKE2b512.hash_encode(data);
+        let hash2 = hash2.as_ref();
         assert_eq!(hash, hash2);
     }
 
@@ -150,18 +191,18 @@ mod tests {
 
         let md5_hash1 = HashAlgorithm::Md5.hash_encode(data1);
         let md5_hash2 = HashAlgorithm::Md5.hash_encode(data2);
-        assert_ne!(md5_hash1, md5_hash2);
+        assert_ne!(md5_hash1.as_ref(), md5_hash2.as_ref());
 
         let highway_hash1 = HashAlgorithm::HighwayHash256.hash_encode(data1);
         let highway_hash2 = HashAlgorithm::HighwayHash256.hash_encode(data2);
-        assert_ne!(highway_hash1, highway_hash2);
+        assert_ne!(highway_hash1.as_ref(), highway_hash2.as_ref());
 
         let sha256_hash1 = HashAlgorithm::SHA256.hash_encode(data1);
         let sha256_hash2 = HashAlgorithm::SHA256.hash_encode(data2);
-        assert_ne!(sha256_hash1, sha256_hash2);
+        assert_ne!(sha256_hash1.as_ref(), sha256_hash2.as_ref());
 
         let blake_hash1 = HashAlgorithm::BLAKE2b512.hash_encode(data1);
         let blake_hash2 = HashAlgorithm::BLAKE2b512.hash_encode(data2);
-        assert_ne!(blake_hash1, blake_hash2);
+        assert_ne!(blake_hash1.as_ref(), blake_hash2.as_ref());
     }
 }
diff --git a/crates/utils/src/lib.rs b/crates/utils/src/lib.rs
index 2f2aff60..19d1a9b9 100644
--- a/crates/utils/src/lib.rs
+++ b/crates/utils/src/lib.rs
@@ -27,14 +27,29 @@ pub mod string;
 #[cfg(feature = "crypto")]
 pub mod crypto;
 
+#[cfg(feature = "compress")]
+pub mod compress;
+
+#[cfg(feature = "path")]
+pub mod dirs;
+
 #[cfg(feature = "tls")]
 pub use certs::*;
+
 #[cfg(feature = "hash")]
 pub use hash::*;
+
 #[cfg(feature = "io")]
 pub use io::*;
+
 #[cfg(feature = "ip")]
 pub use ip::*;
 
 #[cfg(feature = "crypto")]
 pub use crypto::*;
+
+#[cfg(feature = "compress")]
+pub use compress::*;
+
+#[cfg(feature = "sys")]
+pub mod sys;
diff --git a/crates/utils/src/net.rs b/crates/utils/src/net.rs
index 4125bb7d..1d8ac5fd 100644
--- a/crates/utils/src/net.rs
+++ b/crates/utils/src/net.rs
@@ -1,3 +1,6 @@
+use bytes::Bytes;
+use futures::pin_mut;
+use futures::{Stream, StreamExt};
 use hyper::client::conn::http2::Builder;
 use hyper_util::rt::TokioExecutor;
 use lazy_static::lazy_static;
@@ -6,6 +9,7 @@ use std::{
     fmt::Display,
     net::{IpAddr, Ipv6Addr, SocketAddr, TcpListener, ToSocketAddrs},
 };
+use transform_stream::AsyncTryStream;
 use url::{Host, Url};
 //use hyper::{client::conn::http2::Builder, rt::Executor};
 //use tonic::{SharedExec, UserAgent};
@@ -278,6 +282,27 @@ pub fn parse_and_resolve_address(addr_str: &str) -> std::io::Result<SocketAddr>
     Ok(resolved_addr)
 }
 
+#[allow(dead_code)]
+pub fn bytes_stream<S, E>(stream: S, content_length: usize) -> impl Stream<Item = std::result::Result<Bytes, E>> + Send + 'static
+where
+    S: Stream<Item = std::result::Result<Bytes, E>> + Send + 'static,
+    E: Send + 'static,
+{
+    AsyncTryStream::<Bytes, E, _>::new(|mut y| async move {
+        pin_mut!(stream);
+        let mut remaining: usize = content_length;
+        while let Some(result) = stream.next().await {
+            let mut bytes = result?;
+            if bytes.len() > remaining {
+                bytes.truncate(remaining);
+            }
+            remaining -= bytes.len();
+            y.yield_ok(bytes).await;
+        }
+        Ok(())
+    })
+}
+
 #[cfg(test)]
 mod test {
     use std::net::{Ipv4Addr, Ipv6Addr};
diff --git a/crates/utils/src/os/mod.rs b/crates/utils/src/os/mod.rs
index 42323282..79eee3df 100644
--- a/crates/utils/src/os/mod.rs
+++ b/crates/utils/src/os/mod.rs
@@ -102,6 +102,7 @@ mod tests {
         // Test passes if the function doesn't panic - the actual result depends on test environment
     }
 
+    #[ignore] // FIXME: failed in github actions
     #[test]
     fn test_get_drive_stats_default() {
         let stats = get_drive_stats(0, 0).unwrap();
diff --git a/crates/utils/src/os/unix.rs b/crates/utils/src/os/unix.rs
index ad8c07cb..d1ec42c1 100644
--- a/crates/utils/src/os/unix.rs
+++ b/crates/utils/src/os/unix.rs
@@ -8,9 +8,9 @@ pub fn get_info(p: impl AsRef<Path>) -> std::io::Result<DiskInfo> {
     let stat = statfs(p.as_ref())?;
 
     let bsize = stat.block_size() as u64;
-    let bfree = stat.blocks_free() as u64;
-    let bavail = stat.blocks_available() as u64;
-    let blocks = stat.blocks() as u64;
+    let bfree = stat.blocks_free();
+    let bavail = stat.blocks_available();
+    let blocks = stat.blocks();
 
     let reserved = match bfree.checked_sub(bavail) {
         Some(reserved) => reserved,
diff --git a/crates/utils/src/string.rs b/crates/utils/src/string.rs
index e0087718..a3420572 100644
--- a/crates/utils/src/string.rs
+++ b/crates/utils/src/string.rs
@@ -1,4 +1,5 @@
 use lazy_static::*;
+use rand::{Rng, RngCore};
 use regex::Regex;
 use std::io::{Error, Result};
 
@@ -32,6 +33,29 @@ pub fn match_pattern(pattern: &str, name: &str) -> bool {
     deep_match_rune(name.as_bytes(), pattern.as_bytes(), false)
 }
 
+pub fn has_pattern(patterns: &[&str], match_str: &str) -> bool {
+    for pattern in patterns {
+        if match_simple(pattern, match_str) {
+            return true;
+        }
+    }
+    false
+}
+
+pub fn has_string_suffix_in_slice(str: &str, list: &[&str]) -> bool {
+    let str = str.to_lowercase();
+    for v in list {
+        if *v == "*" {
+            return true;
+        }
+
+        if str.ends_with(&v.to_lowercase()) {
+            return true;
+        }
+    }
+    false
+}
+
 fn deep_match_rune(str_: &[u8], pattern: &[u8], simple: bool) -> bool {
     let (mut str_, mut pattern) = (str_, pattern);
     while !pattern.is_empty() {
@@ -283,6 +307,43 @@ pub fn parse_ellipses_range(pattern: &str) -> Result<Vec<String>> {
     Ok(ret)
 }
 
+pub fn gen_access_key(length: usize) -> Result<String> {
+    const ALPHA_NUMERIC_TABLE: [char; 36] = [
+        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
+        'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+    ];
+
+    if length < 3 {
+        return Err(Error::other("access key length is too short"));
+    }
+
+    let mut result = String::with_capacity(length);
+    let mut rng = rand::rng();
+
+    for _ in 0..length {
+        result.push(ALPHA_NUMERIC_TABLE[rng.random_range(0..ALPHA_NUMERIC_TABLE.len())]);
+    }
+
+    Ok(result)
+}
+
+pub fn gen_secret_key(length: usize) -> Result<String> {
+    use base64_simd::URL_SAFE_NO_PAD;
+
+    if length < 8 {
+        return Err(Error::other("secret key length is too short"));
+    }
+    let mut rng = rand::rng();
+
+    let mut key = vec![0u8; URL_SAFE_NO_PAD.estimated_decoded_length(length)];
+    rng.fill_bytes(&mut key);
+
+    let encoded = URL_SAFE_NO_PAD.encode_to_string(&key);
+    let key_str = encoded.replace("/", "+");
+
+    Ok(key_str)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/utils/src/sys/mod.rs b/crates/utils/src/sys/mod.rs
new file mode 100644
index 00000000..93d3cdad
--- /dev/null
+++ b/crates/utils/src/sys/mod.rs
@@ -0,0 +1,4 @@
+mod user_agent;
+
+pub use user_agent::ServiceType;
+pub use user_agent::get_user_agent;
diff --git a/crates/utils/src/sys/user_agent.rs b/crates/utils/src/sys/user_agent.rs
new file mode 100644
index 00000000..99d53ffc
--- /dev/null
+++ b/crates/utils/src/sys/user_agent.rs
@@ -0,0 +1,209 @@
+use rustfs_config::VERSION;
+use std::env;
+use std::fmt;
+use sysinfo::System;
+
+/// Business Type Enumeration
+#[derive(Debug, Clone, PartialEq)]
+pub enum ServiceType {
+    Basis,
+    Core,
+    Event,
+    Logger,
+    Custom(String),
+}
+
+impl ServiceType {
+    fn as_str(&self) -> &str {
+        match self {
+            ServiceType::Basis => "basis",
+            ServiceType::Core => "core",
+            ServiceType::Event => "event",
+            ServiceType::Logger => "logger",
+            ServiceType::Custom(s) => s.as_str(),
+        }
+    }
+}
+
+// UserAgent structure
+struct UserAgent {
+    os_platform: String,
+    arch: String,
+    version: String,
+    service: ServiceType,
+}
+
+impl UserAgent {
+    /// Create a new UserAgent instance and accept business type parameters
+    ///
+    /// # Arguments
+    /// * `service` - The type of service for which the User-Agent is being created.
+    /// # Returns
+    /// A new instance of `UserAgent` with the current OS platform, architecture, version, and service type.
+    fn new(service: ServiceType) -> Self {
+        let os_platform = Self::get_os_platform();
+        let arch = env::consts::ARCH.to_string();
+        let version = VERSION.to_string();
+
+        UserAgent {
+            os_platform,
+            arch,
+            version,
+            service,
+        }
+    }
+
+    /// Obtain operating system platform information
+    fn get_os_platform() -> String {
+        if cfg!(target_os = "windows") {
+            Self::get_windows_platform()
+        } else if cfg!(target_os = "macos") {
+            Self::get_macos_platform()
+        } else if cfg!(target_os = "linux") {
+            Self::get_linux_platform()
+        } else {
+            "Unknown".to_string()
+        }
+    }
+
+    /// Get Windows platform information
+    #[cfg(windows)]
+    fn get_windows_platform() -> String {
+        // Priority to using sysinfo to get versions
+        if let Some(version) = System::os_version() {
+            format!("Windows NT {}", version)
+        } else {
+            // Fallback to cmd /c ver
+            let output = std::process::Command::new("cmd")
+                .args(&["/C", "ver"])
+                .output()
+                .unwrap_or_default();
+            let version = String::from_utf8_lossy(&output.stdout);
+            let version = version
+                .lines()
+                .next()
+                .unwrap_or("Windows NT 10.0")
+                .replace("Microsoft Windows [Version ", "")
+                .replace("]", "");
+            format!("Windows NT {}", version.trim())
+        }
+    }
+
+    #[cfg(not(windows))]
+    fn get_windows_platform() -> String {
+        "N/A".to_string()
+    }
+
+    /// Get macOS platform information
+    #[cfg(target_os = "macos")]
+    fn get_macos_platform() -> String {
+        let binding = System::os_version().unwrap_or("14.5.0".to_string());
+        let version = binding.split('.').collect::<Vec<&str>>();
+        let major = version.first().unwrap_or(&"14").to_string();
+        let minor = version.get(1).unwrap_or(&"5").to_string();
+        let patch = version.get(2).unwrap_or(&"0").to_string();
+
+        let arch = env::consts::ARCH;
+        let cpu_info = if arch == "aarch64" { "Apple" } else { "Intel" };
+
+        // Convert to User-Agent format
+        format!("Macintosh; {} Mac OS X {}_{}_{}", cpu_info, major, minor, patch)
+    }
+
+    #[cfg(not(target_os = "macos"))]
+    fn get_macos_platform() -> String {
+        "N/A".to_string()
+    }
+
+    /// Get Linux platform information
+    #[cfg(target_os = "linux")]
+    fn get_linux_platform() -> String {
+        format!("X11; {}", System::long_os_version().unwrap_or("Linux Unknown".to_string()))
+    }
+
+    #[cfg(not(target_os = "linux"))]
+    fn get_linux_platform() -> String {
+        "N/A".to_string()
+    }
+}
+
+/// Implement Display trait to format User-Agent
+impl fmt::Display for UserAgent {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if self.service == ServiceType::Basis {
+            return write!(f, "Mozilla/5.0 ({}; {}) Rustfs/{}", self.os_platform, self.arch, self.version);
+        }
+        write!(
+            f,
+            "Mozilla/5.0 ({}; {}) Rustfs/{} ({})",
+            self.os_platform,
+            self.arch,
+            self.version,
+            self.service.as_str()
+        )
+    }
+}
+
+// Get the User-Agent string and accept business type parameters
+pub fn get_user_agent(service: ServiceType) -> String {
+    UserAgent::new(service).to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_user_agent_format_basis() {
+        let ua = get_user_agent(ServiceType::Basis);
+        assert!(ua.starts_with("Mozilla/5.0"));
+        assert!(ua.contains("Rustfs/1.0.0"));
+        println!("User-Agent: {}", ua);
+    }
+
+    #[test]
+    fn test_user_agent_format_core() {
+        let ua = get_user_agent(ServiceType::Core);
+        assert!(ua.starts_with("Mozilla/5.0"));
+        assert!(ua.contains("Rustfs/1.0.0 (core)"));
+        println!("User-Agent: {}", ua);
+    }
+
+    #[test]
+    fn test_user_agent_format_event() {
+        let ua = get_user_agent(ServiceType::Event);
+        assert!(ua.starts_with("Mozilla/5.0"));
+        assert!(ua.contains("Rustfs/1.0.0 (event)"));
+        println!("User-Agent: {}", ua);
+    }
+
+    #[test]
+    fn test_user_agent_format_logger() {
+        let ua = get_user_agent(ServiceType::Logger);
+        assert!(ua.starts_with("Mozilla/5.0"));
+        assert!(ua.contains("Rustfs/1.0.0 (logger)"));
+        println!("User-Agent: {}", ua);
+    }
+
+    #[test]
+    fn test_user_agent_format_custom() {
+        let ua = get_user_agent(ServiceType::Custom("monitor".to_string()));
+        assert!(ua.starts_with("Mozilla/5.0"));
+        assert!(ua.contains("Rustfs/1.0.0 (monitor)"));
+        println!("User-Agent: {}", ua);
+    }
+
+    #[test]
+    fn test_all_service_type() {
+        // Example: Generate User-Agents of Different Business Types
+        let ua_core = get_user_agent(ServiceType::Core);
+        let ua_event = get_user_agent(ServiceType::Event);
+        let ua_logger = get_user_agent(ServiceType::Logger);
+        let ua_custom = get_user_agent(ServiceType::Custom("monitor".to_string()));
+
+        println!("Core User-Agent: {}", ua_core);
+        println!("Event User-Agent: {}", ua_event);
+        println!("Logger User-Agent: {}", ua_logger);
+        println!("Custom User-Agent: {}", ua_custom);
+    }
+}
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 00000000..5ba1d936
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,221 @@
+version: '3.8'
+
+services:
+  # RustFS main service
+  rustfs:
+    image: rustfs/rustfs:latest
+    container_name: rustfs-server
+    build:
+      context: .
+      dockerfile: Dockerfile.multi-stage
+      args:
+        TARGETPLATFORM: linux/amd64
+    ports:
+      - "9000:9000"  # S3 API port
+      - "9001:9001"  # Console port
+    environment:
+      - RUSTFS_VOLUMES=/data/rustfs0,/data/rustfs1,/data/rustfs2,/data/rustfs3
+      - RUSTFS_ADDRESS=0.0.0.0:9000
+      - RUSTFS_CONSOLE_ENABLE=true
+      - RUSTFS_CONSOLE_ADDRESS=0.0.0.0:9001
+      - RUSTFS_ACCESS_KEY=rustfsadmin
+      - RUSTFS_SECRET_KEY=rustfsadmin
+      - RUSTFS_LOG_LEVEL=info
+      - RUSTFS_OBS_ENDPOINT=http://otel-collector:4317
+    volumes:
+      - rustfs_data_0:/data/rustfs0
+      - rustfs_data_1:/data/rustfs1
+      - rustfs_data_2:/data/rustfs2
+      - rustfs_data_3:/data/rustfs3
+      - ./logs:/app/logs
+    networks:
+      - rustfs-network
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:9000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+    depends_on:
+      - otel-collector
+
+  # Development environment
+  rustfs-dev:
+    image: rustfs/rustfs:devenv
+    container_name: rustfs-dev
+    build:
+      context: .
+      dockerfile: .docker/Dockerfile.devenv
+    ports:
+      - "9010:9000"
+      - "9011:9001"
+    environment:
+      - RUSTFS_VOLUMES=/data/rustfs0,/data/rustfs1
+      - RUSTFS_ADDRESS=0.0.0.0:9000
+      - RUSTFS_CONSOLE_ENABLE=true
+      - RUSTFS_CONSOLE_ADDRESS=0.0.0.0:9001
+      - RUSTFS_ACCESS_KEY=devadmin
+      - RUSTFS_SECRET_KEY=devadmin
+      - RUSTFS_LOG_LEVEL=debug
+    volumes:
+      - .:/root/s3-rustfs
+      - rustfs_dev_data:/data
+    networks:
+      - rustfs-network
+    restart: unless-stopped
+    profiles:
+      - dev
+
+  # OpenTelemetry Collector
+  otel-collector:
+    image: otel/opentelemetry-collector-contrib:latest
+    container_name: otel-collector
+    command:
+      - --config=/etc/otelcol-contrib/otel-collector.yml
+    volumes:
+      - ./.docker/observability/otel-collector.yml:/etc/otelcol-contrib/otel-collector.yml:ro
+    ports:
+      - "4317:4317"   # OTLP gRPC receiver
+      - "4318:4318"   # OTLP HTTP receiver
+      - "8888:8888"   # Prometheus metrics
+      - "8889:8889"   # Prometheus exporter metrics
+    networks:
+      - rustfs-network
+    restart: unless-stopped
+    profiles:
+      - observability
+
+  # Jaeger for tracing
+  jaeger:
+    image: jaegertracing/all-in-one:latest
+    container_name: jaeger
+    ports:
+      - "16686:16686"  # Jaeger UI
+      - "14250:14250"  # Jaeger gRPC
+    environment:
+      - COLLECTOR_OTLP_ENABLED=true
+    networks:
+      - rustfs-network
+    restart: unless-stopped
+    profiles:
+      - observability
+
+  # Prometheus for metrics
+  prometheus:
+    image: prom/prometheus:latest
+    container_name: prometheus
+    ports:
+      - "9090:9090"
+    volumes:
+      - ./.docker/observability/prometheus.yml:/etc/prometheus/prometheus.yml:ro
+      - prometheus_data:/prometheus
+    command:
+      - '--config.file=/etc/prometheus/prometheus.yml'
+      - '--storage.tsdb.path=/prometheus'
+      - '--web.console.libraries=/etc/prometheus/console_libraries'
+      - '--web.console.templates=/etc/prometheus/consoles'
+      - '--storage.tsdb.retention.time=200h'
+      - '--web.enable-lifecycle'
+    networks:
+      - rustfs-network
+    restart: unless-stopped
+    profiles:
+      - observability
+
+  # Grafana for visualization
+  grafana:
+    image: grafana/grafana:latest
+    container_name: grafana
+    ports:
+      - "3000:3000"
+    environment:
+      - GF_SECURITY_ADMIN_USER=admin
+      - GF_SECURITY_ADMIN_PASSWORD=admin
+    volumes:
+      - grafana_data:/var/lib/grafana
+      - ./.docker/observability/grafana/provisioning:/etc/grafana/provisioning:ro
+      - ./.docker/observability/grafana/dashboards:/var/lib/grafana/dashboards:ro
+    networks:
+      - rustfs-network
+    restart: unless-stopped
+    profiles:
+      - observability
+
+  # MinIO for S3 API testing
+  minio:
+    image: minio/minio:latest
+    container_name: minio-test
+    ports:
+      - "9020:9000"
+      - "9021:9001"
+    environment:
+      - MINIO_ROOT_USER=minioadmin
+      - MINIO_ROOT_PASSWORD=minioadmin
+    volumes:
+      - minio_data:/data
+    command: server /data --console-address ":9001"
+    networks:
+      - rustfs-network
+    restart: unless-stopped
+    profiles:
+      - testing
+
+  # Redis for caching (optional)
+  redis:
+    image: redis:7-alpine
+    container_name: redis
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    networks:
+      - rustfs-network
+    restart: unless-stopped
+    profiles:
+      - cache
+
+  # NGINX reverse proxy (optional)
+  nginx:
+    image: nginx:alpine
+    container_name: nginx-proxy
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - ./.docker/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
+      - ./.docker/nginx/ssl:/etc/nginx/ssl:ro
+    networks:
+      - rustfs-network
+    restart: unless-stopped
+    profiles:
+      - proxy
+    depends_on:
+      - rustfs
+
+networks:
+  rustfs-network:
+    driver: bridge
+    ipam:
+      config:
+        - subnet: 172.20.0.0/16
+
+volumes:
+  rustfs_data_0:
+    driver: local
+  rustfs_data_1:
+    driver: local
+  rustfs_data_2:
+    driver: local
+  rustfs_data_3:
+    driver: local
+  rustfs_dev_data:
+    driver: local
+  prometheus_data:
+    driver: local
+  grafana_data:
+    driver: local
+  minio_data:
+    driver: local
+  redis_data:
+    driver: local
diff --git a/docs/docker-build.md b/docs/docker-build.md
new file mode 100644
index 00000000..ce016ff9
--- /dev/null
+++ b/docs/docker-build.md
@@ -0,0 +1,530 @@
+# RustFS Docker Build and Deployment Guide
+
+This document describes how to build and deploy RustFS using Docker, including the automated GitHub Actions workflow for building and pushing images to Docker Hub and GitHub Container Registry.
+
+## 🚀 Quick Start
+
+### Using Pre-built Images
+
+```bash
+# Pull and run the latest RustFS image
+docker run -d \
+  --name rustfs \
+  -p 9000:9000 \
+  -p 9001:9001 \
+  -v rustfs_data:/data \
+  -e RUSTFS_VOLUMES=/data/rustfs0,/data/rustfs1,/data/rustfs2,/data/rustfs3 \
+  -e RUSTFS_ACCESS_KEY=rustfsadmin \
+  -e RUSTFS_SECRET_KEY=rustfsadmin \
+  -e RUSTFS_CONSOLE_ENABLE=true \
+  rustfs/rustfs:latest
+```
+
+### Using Docker Compose
+
+```bash
+# Basic deployment
+docker-compose up -d
+
+# Development environment
+docker-compose --profile dev up -d
+
+# With observability stack
+docker-compose --profile observability up -d
+
+# Full stack with all services
+docker-compose --profile dev --profile observability --profile testing up -d
+```
+
+## 📦 Available Images
+
+Our GitHub Actions workflow builds multiple image variants:
+
+### Image Registries
+
+- **Docker Hub**: `rustfs/rustfs`
+- **GitHub Container Registry**: `ghcr.io/rustfs/s3-rustfs`
+
+### Image Variants
+
+| Variant | Tag Suffix | Description | Use Case |
+|---------|------------|-------------|----------|
+| Production | *(none)* | Minimal Ubuntu-based runtime | Production deployment |
+| Ubuntu | `-ubuntu22.04` | Ubuntu 22.04 based build environment | Development/Testing |
+| Rocky Linux | `-rockylinux9.3` | Rocky Linux 9.3 based build environment | Enterprise environments |
+| Development | `-devenv` | Full development environment | Development/Debugging |
+
+### Supported Architectures
+
+All images support multi-architecture:
+- `linux/amd64` (x86_64-unknown-linux-musl)
+- `linux/arm64` (aarch64-unknown-linux-gnu)
+
+### Tag Examples
+
+```bash
+# Latest production image
+rustfs/rustfs:latest
+rustfs/rustfs:main
+
+# Specific version
+rustfs/rustfs:v1.0.0
+rustfs/rustfs:v1.0.0-ubuntu22.04
+
+# Development environment
+rustfs/rustfs:latest-devenv
+rustfs/rustfs:main-devenv
+```
+
+## 🔧 GitHub Actions Workflow
+
+The Docker build workflow (`.github/workflows/docker.yml`) automatically:
+
+1. **Builds cross-platform binaries** for `amd64` and `arm64`
+2. **Creates Docker images** for all variants
+3. **Pushes to registries** (Docker Hub and GitHub Container Registry)
+4. **Creates multi-arch manifests** for seamless platform selection
+5. **Performs security scanning** using Trivy
+
+### Cross-Compilation Strategy
+
+To handle complex native dependencies, we use different compilation strategies:
+
+- **x86_64**: Native compilation with `x86_64-unknown-linux-musl` for static linking
+- **aarch64**: Cross-compilation with `aarch64-unknown-linux-gnu` using the `cross` tool
+
+This approach ensures compatibility with various C libraries while maintaining performance.
+
+### Workflow Triggers
+
+- **Push to main branch**: Builds and pushes `main` and `latest` tags
+- **Tag push** (`v*`): Builds and pushes version tags
+- **Pull requests**: Builds images without pushing
+- **Manual trigger**: Workflow dispatch with options
+
+### Required Secrets
+
+Configure these secrets in your GitHub repository:
+
+```bash
+# Docker Hub credentials
+DOCKERHUB_USERNAME=your-dockerhub-username
+DOCKERHUB_TOKEN=your-dockerhub-access-token
+
+# GitHub token is automatically available
+GITHUB_TOKEN=automatically-provided
+```
+
+## 🏗️ Building Locally
+
+### Prerequisites
+
+- Docker with BuildKit enabled
+- Rust toolchain (1.85+)
+- Protocol Buffers compiler (protoc 31.1+)
+- FlatBuffers compiler (flatc 25.2.10+)
+- `cross` tool for ARM64 compilation
+
+### Installation Commands
+
+```bash
+# Install Rust targets
+rustup target add x86_64-unknown-linux-musl
+rustup target add aarch64-unknown-linux-gnu
+
+# Install cross for ARM64 compilation
+cargo install cross --git https://github.com/cross-rs/cross
+
+# Install protoc (macOS)
+brew install protobuf
+
+# Install protoc (Ubuntu)
+sudo apt-get install protobuf-compiler
+
+# Install flatc
+# Download from: https://github.com/google/flatbuffers/releases
+```
+
+### Build Commands
+
+```bash
+# Test cross-compilation setup
+./scripts/test-cross-build.sh
+
+# Build production image for local platform
+docker build -t rustfs:local .
+
+# Build multi-stage production image
+docker build -f Dockerfile.multi-stage -t rustfs:multi-stage .
+
+# Build specific variant
+docker build -f .docker/Dockerfile.ubuntu22.04 -t rustfs:ubuntu .
+
+# Build for specific platform
+docker build --platform linux/amd64 -t rustfs:amd64 .
+docker build --platform linux/arm64 -t rustfs:arm64 .
+
+# Build multi-platform image
+docker buildx build --platform linux/amd64,linux/arm64 -t rustfs:multi .
+```
+
+### Cross-Compilation
+
+```bash
+# Generate protobuf code first
+cargo run --bin gproto
+
+# Native x86_64 build
+cargo build --release --target x86_64-unknown-linux-musl --bin rustfs
+
+# Cross-compile for ARM64
+cross build --release --target aarch64-unknown-linux-gnu --bin rustfs
+```
+
+### Build with Docker Compose
+
+```bash
+# Build all services
+docker-compose build
+
+# Build specific service
+docker-compose build rustfs
+
+# Build development environment
+docker-compose build rustfs-dev
+```
+
+## 🚀 Deployment Options
+
+### 1. Single Container
+
+```bash
+docker run -d \
+  --name rustfs \
+  --restart unless-stopped \
+  -p 9000:9000 \
+  -p 9001:9001 \
+  -v /data/rustfs:/data \
+  -e RUSTFS_VOLUMES=/data/rustfs0,/data/rustfs1,/data/rustfs2,/data/rustfs3 \
+  -e RUSTFS_ADDRESS=0.0.0.0:9000 \
+  -e RUSTFS_CONSOLE_ENABLE=true \
+  -e RUSTFS_CONSOLE_ADDRESS=0.0.0.0:9001 \
+  -e RUSTFS_ACCESS_KEY=rustfsadmin \
+  -e RUSTFS_SECRET_KEY=rustfsadmin \
+  rustfs/rustfs:latest
+```
+
+### 2. Docker Compose Profiles
+
+```bash
+# Production deployment
+docker-compose up -d
+
+# Development with debugging
+docker-compose --profile dev up -d
+
+# With monitoring stack
+docker-compose --profile observability up -d
+
+# Complete testing environment
+docker-compose --profile dev --profile observability --profile testing up -d
+```
+
+### 3. Kubernetes Deployment
+
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: rustfs
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: rustfs
+  template:
+    metadata:
+      labels:
+        app: rustfs
+    spec:
+      containers:
+      - name: rustfs
+        image: rustfs/rustfs:latest
+        ports:
+        - containerPort: 9000
+        - containerPort: 9001
+        env:
+        - name: RUSTFS_VOLUMES
+          value: "/data/rustfs0,/data/rustfs1,/data/rustfs2,/data/rustfs3"
+        - name: RUSTFS_ADDRESS
+          value: "0.0.0.0:9000"
+        - name: RUSTFS_CONSOLE_ENABLE
+          value: "true"
+        - name: RUSTFS_CONSOLE_ADDRESS
+          value: "0.0.0.0:9001"
+        volumeMounts:
+        - name: data
+          mountPath: /data
+      volumes:
+      - name: data
+        persistentVolumeClaim:
+          claimName: rustfs-data
+```
+
+## ⚙️ Configuration
+
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `RUSTFS_VOLUMES` | Comma-separated list of data volumes | Required |
+| `RUSTFS_ADDRESS` | Server bind address | `0.0.0.0:9000` |
+| `RUSTFS_CONSOLE_ENABLE` | Enable web console | `false` |
+| `RUSTFS_CONSOLE_ADDRESS` | Console bind address | `0.0.0.0:9001` |
+| `RUSTFS_ACCESS_KEY` | S3 access key | `rustfsadmin` |
+| `RUSTFS_SECRET_KEY` | S3 secret key | `rustfsadmin` |
+| `RUSTFS_LOG_LEVEL` | Log level | `info` |
+| `RUSTFS_OBS_ENDPOINT` | Observability endpoint | `""` |
+| `RUSTFS_TLS_PATH` | TLS certificates path | `""` |
+
+### Volume Mounts
+
+- **Data volumes**: `/data/rustfs{0,1,2,3}` - RustFS data storage
+- **Logs**: `/app/logs` - Application logs
+- **Config**: `/etc/rustfs/` - Configuration files
+- **TLS**: `/etc/ssl/rustfs/` - TLS certificates
+
+### Ports
+
+- **9000**: S3 API endpoint
+- **9001**: Web console (if enabled)
+- **9002**: Admin API (if enabled)
+- **50051**: gRPC API (if enabled)
+
+## 🔍 Monitoring and Observability
+
+### Health Checks
+
+The Docker images include built-in health checks:
+
+```bash
+# Check container health
+docker ps --filter "name=rustfs" --format "table {{.Names}}\t{{.Status}}"
+
+# View health check logs
+docker inspect rustfs --format='{{json .State.Health}}'
+```
+
+### Metrics and Tracing
+
+When using the observability profile:
+
+- **Prometheus**: http://localhost:9090
+- **Grafana**: http://localhost:3000 (admin/admin)
+- **Jaeger**: http://localhost:16686
+- **OpenTelemetry Collector**: http://localhost:8888/metrics
+
+### Log Collection
+
+```bash
+# View container logs
+docker logs rustfs -f
+
+# Export logs
+docker logs rustfs > rustfs.log 2>&1
+```
+
+## 🛠️ Development
+
+### Development Environment
+
+```bash
+# Start development container
+docker-compose --profile dev up -d rustfs-dev
+
+# Access development container
+docker exec -it rustfs-dev bash
+
+# Mount source code for live development
+docker run -it --rm \
+  -v $(pwd):/root/s3-rustfs \
+  -p 9000:9000 \
+  rustfs/rustfs:devenv \
+  bash
+```
+
+### Building from Source in Container
+
+```bash
+# Use development image for building
+docker run --rm \
+  -v $(pwd):/root/s3-rustfs \
+  -w /root/s3-rustfs \
+  rustfs/rustfs:ubuntu22.04 \
+  cargo build --release --bin rustfs
+```
+
+### Testing Cross-Compilation
+
+```bash
+# Run the test script to verify cross-compilation setup
+./scripts/test-cross-build.sh
+
+# This will test:
+# - x86_64-unknown-linux-musl compilation
+# - aarch64-unknown-linux-gnu cross-compilation
+# - Docker builds for both architectures
+```
+
+## 🔐 Security
+
+### Security Scanning
+
+The workflow includes Trivy security scanning:
+
+```bash
+# Run security scan locally
+docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
+  -v $HOME/Library/Caches:/root/.cache/ \
+  aquasec/trivy:latest image rustfs/rustfs:latest
+```
+
+### Security Best Practices
+
+1. **Use non-root user**: Images run as `rustfs` user (UID 1000)
+2. **Minimal base images**: Ubuntu minimal for production
+3. **Security updates**: Regular base image updates
+4. **Secret management**: Use Docker secrets or environment files
+5. **Network security**: Use Docker networks and proper firewall rules
+
+## 📝 Troubleshooting
+
+### Common Issues
+
+#### 1. Cross-Compilation Failures
+
+**Problem**: ARM64 build fails with linking errors
+```bash
+error: linking with `aarch64-linux-gnu-gcc` failed
+```
+
+**Solution**: Use the `cross` tool instead of native cross-compilation:
+```bash
+# Install cross tool
+cargo install cross --git https://github.com/cross-rs/cross
+
+# Use cross for ARM64 builds
+cross build --release --target aarch64-unknown-linux-gnu --bin rustfs
+```
+
+#### 2. Protobuf Generation Issues
+
+**Problem**: Missing protobuf definitions
+```bash
+error: failed to run custom build command for `protos`
+```
+
+**Solution**: Generate protobuf code first:
+```bash
+cargo run --bin gproto
+```
+
+#### 3. Docker Build Failures
+
+**Problem**: Binary not found in Docker build
+```bash
+COPY failed: file not found in build context
+```
+
+**Solution**: Ensure binaries are built before Docker build:
+```bash
+# Build binaries first
+cargo build --release --target x86_64-unknown-linux-musl --bin rustfs
+cross build --release --target aarch64-unknown-linux-gnu --bin rustfs
+
+# Then build Docker image
+docker build .
+```
+
+### Debug Commands
+
+```bash
+# Check container status
+docker ps -a
+
+# View container logs
+docker logs rustfs --tail 100
+
+# Access container shell
+docker exec -it rustfs bash
+
+# Check resource usage
+docker stats rustfs
+
+# Inspect container configuration
+docker inspect rustfs
+
+# Test cross-compilation setup
+./scripts/test-cross-build.sh
+```
+
+## 🔄 CI/CD Integration
+
+### GitHub Actions
+
+The provided workflow can be customized:
+
+```yaml
+# Override image names
+env:
+  REGISTRY_IMAGE_DOCKERHUB: myorg/rustfs
+  REGISTRY_IMAGE_GHCR: ghcr.io/myorg/rustfs
+```
+
+### GitLab CI
+
+```yaml
+build:
+  stage: build
+  image: docker:latest
+  services:
+    - docker:dind
+  script:
+    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
+    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
+```
+
+### Jenkins Pipeline
+
+```groovy
+pipeline {
+    agent any
+    stages {
+        stage('Build') {
+            steps {
+                script {
+                    docker.build("rustfs:${env.BUILD_ID}")
+                }
+            }
+        }
+        stage('Push') {
+            steps {
+                script {
+                    docker.withRegistry('https://registry.hub.docker.com', 'dockerhub-credentials') {
+                        docker.image("rustfs:${env.BUILD_ID}").push()
+                    }
+                }
+            }
+        }
+    }
+}
+```
+
+## 📚 Additional Resources
+
+- [Docker Official Documentation](https://docs.docker.com/)
+- [Docker Compose Reference](https://docs.docker.com/compose/)
+- [GitHub Actions Documentation](https://docs.github.com/en/actions)
+- [Cross-compilation with Rust](https://rust-lang.github.io/rustup/cross-compilation.html)
+- [Cross tool documentation](https://github.com/cross-rs/cross)
+- [RustFS Configuration Guide](../README.md)
diff --git a/e2e_test/Cargo.toml b/e2e_test/Cargo.toml
index 2903d485..81198005 100644
--- a/e2e_test/Cargo.toml
+++ b/e2e_test/Cargo.toml
@@ -28,4 +28,5 @@ tower.workspace = true
 url.workspace = true
 madmin.workspace =true
 common.workspace = true
-rustfs-filemeta.workspace = true
\ No newline at end of file
+rustfs-filemeta.workspace = true
+bytes.workspace = true
diff --git a/e2e_test/src/reliant/node_interact_test.rs b/e2e_test/src/reliant/node_interact_test.rs
index 325f9730..5b74a533 100644
--- a/e2e_test/src/reliant/node_interact_test.rs
+++ b/e2e_test/src/reliant/node_interact_test.rs
@@ -43,7 +43,7 @@ async fn ping() -> Result<(), Box<dyn Error>> {
     // Construct PingRequest
     let request = Request::new(PingRequest {
         version: 1,
-        body: finished_data.to_vec(),
+        body: bytes::Bytes::copy_from_slice(finished_data),
     });
 
     // Send request and get response
@@ -114,7 +114,7 @@ async fn walk_dir() -> Result<(), Box<dyn Error>> {
     let mut client = node_service_time_out_client(&CLUSTER_ADDR.to_string()).await?;
     let request = Request::new(WalkDirRequest {
         disk: "/home/dandan/code/rust/s3-rustfs/target/debug/data".to_string(),
-        walk_dir_options: buf,
+        walk_dir_options: buf.into(),
     });
     let mut response = client.walk_dir(request).await?.into_inner();
 
diff --git a/ecstore/BENCHMARK.md b/ecstore/BENCHMARK.md
deleted file mode 100644
index 5a420dc8..00000000
--- a/ecstore/BENCHMARK.md
+++ /dev/null
@@ -1,270 +0,0 @@
-# Reed-Solomon Erasure Coding Performance Benchmark
-
-This directory contains a comprehensive benchmark suite for comparing the performance of different Reed-Solomon implementations.
-
-## 📊 Test Overview
-
-### Supported Implementation Modes
-
-#### 🏛️ Pure Erasure Mode (Default, Recommended)
-- **Stable and Reliable**: Uses mature reed-solomon-erasure implementation
-- **Wide Compatibility**: Supports arbitrary shard sizes
-- **Memory Efficient**: Optimized memory usage patterns
-- **Predictable**: Performance insensitive to shard size
-- **Use Case**: Default choice for production environments, suitable for most application scenarios
-
-#### 🎯 SIMD Mode (`reed-solomon-simd` feature)
-- **High Performance Optimization**: Uses SIMD instruction sets for high-performance encoding/decoding
-- **Performance Oriented**: Focuses on maximizing processing performance
-- **Target Scenarios**: High-performance scenarios for large data processing
-- **Use Case**: Scenarios requiring maximum performance, suitable for handling large amounts of data
-
-### Test Dimensions
-
-- **Encoding Performance** - Speed of encoding data into erasure code shards
-- **Decoding Performance** - Speed of recovering original data from erasure code shards
-- **Shard Size Sensitivity** - Impact of different shard sizes on performance
-- **Erasure Code Configuration** - Performance impact of different data/parity shard ratios
-- **SIMD Mode Performance** - Performance characteristics of SIMD optimization
-- **Concurrency Performance** - Performance in multi-threaded environments
-- **Memory Efficiency** - Memory usage patterns and efficiency
-- **Error Recovery Capability** - Recovery performance under different numbers of lost shards
-
-## 🚀 Quick Start
-
-### Run Quick Tests
-
-```bash
-# Run quick performance comparison tests (default pure Erasure mode)
-./run_benchmarks.sh quick
-```
-
-### Run Complete Comparison Tests
-
-```bash
-# Run detailed implementation comparison tests
-./run_benchmarks.sh comparison
-```
-
-### Run Specific Mode Tests
-
-```bash
-# Test default pure erasure mode (recommended)
-./run_benchmarks.sh erasure
-
-# Test SIMD mode
-./run_benchmarks.sh simd
-```
-
-## 📈 Manual Benchmark Execution
-
-### Basic Usage
-
-```bash
-# Run all benchmarks (default pure erasure mode)
-cargo bench
-
-# Run specific benchmark files
-cargo bench --bench erasure_benchmark
-cargo bench --bench comparison_benchmark
-```
-
-### Compare Different Implementation Modes
-
-```bash
-# Test default pure erasure mode
-cargo bench --bench comparison_benchmark
-
-# Test SIMD mode
-cargo bench --bench comparison_benchmark \
-    --features reed-solomon-simd
-
-# Save baseline for comparison
-cargo bench --bench comparison_benchmark \
-    -- --save-baseline erasure_baseline
-
-# Compare SIMD mode performance with baseline
-cargo bench --bench comparison_benchmark \
-    --features reed-solomon-simd \
-    -- --baseline erasure_baseline
-```
-
-### Filter Specific Tests
-
-```bash
-# Run only encoding tests
-cargo bench encode
-
-# Run only decoding tests  
-cargo bench decode
-
-# Run tests for specific data sizes
-cargo bench 1MB
-
-# Run tests for specific configurations
-cargo bench "4+2"
-```
-
-## 📊 View Results
-
-### HTML Reports
-
-Benchmark results automatically generate HTML reports:
-
-```bash
-# Start local server to view reports
-cd target/criterion
-python3 -m http.server 8080
-
-# Access in browser
-open http://localhost:8080/report/index.html
-```
-
-### Command Line Output
-
-Benchmarks display in terminal:
-- Operations per second (ops/sec)
-- Throughput (MB/s)
-- Latency statistics (mean, standard deviation, percentiles)
-- Performance trend changes
-
-## 🔧 Test Configuration
-
-### Data Sizes
-
-- **Small Data**: 1KB, 8KB - Test small file scenarios
-- **Medium Data**: 64KB, 256KB - Test common file sizes
-- **Large Data**: 1MB, 4MB - Test large file processing and SIMD optimization
-- **Very Large Data**: 16MB+ - Test high throughput scenarios
-
-### Erasure Code Configurations
-
-- **(4,2)** - Common configuration, 33% redundancy
-- **(6,3)** - 50% redundancy, balanced performance and reliability
-- **(8,4)** - 50% redundancy, more parallelism
-- **(10,5)**, **(12,6)** - High parallelism configurations
-
-### Shard Sizes
-
-Test different shard sizes from 32 bytes to 8KB, with special focus on:
-- **Memory Alignment**: 64, 128, 256 bytes - Impact of memory alignment on performance
-- **Cache Friendly**: 1KB, 2KB, 4KB - CPU cache-friendly sizes
-
-## 📝 Interpreting Test Results
-
-### Performance Metrics
-
-1. **Throughput**
-   - Unit: MB/s or GB/s
-   - Measures data processing speed
-   - Higher is better
-
-2. **Latency**
-   - Unit: microseconds (μs) or milliseconds (ms)
-   - Measures single operation time
-   - Lower is better
-
-3. **CPU Efficiency**
-   - Bytes processed per CPU cycle
-   - Reflects algorithm efficiency
-
-### Expected Results
-
-**Pure Erasure Mode (Default)**:
-- Stable performance, insensitive to shard size
-- Best compatibility, supports all configurations
-- Stable and predictable memory usage
-
-**SIMD Mode (`reed-solomon-simd` feature)**:
-- High-performance SIMD optimized implementation
-- Suitable for large data processing scenarios
-- Focuses on maximizing performance
-
-**Shard Size Sensitivity**:
-- SIMD mode may be more sensitive to shard sizes
-- Pure Erasure mode relatively insensitive to shard size
-
-**Memory Usage**:
-- SIMD mode may have specific memory alignment requirements
-- Pure Erasure mode has more stable memory usage
-
-## 🛠️ Custom Testing
-
-### Adding New Test Scenarios
-
-Edit `benches/erasure_benchmark.rs` or `benches/comparison_benchmark.rs`:
-
-```rust
-// Add new test configuration
-let configs = vec![
-    // Your custom configuration
-    BenchConfig::new(10, 4, 2048 * 1024, 2048 * 1024), // 10+4, 2MB
-];
-```
-
-### Adjust Test Parameters
-
-```rust
-// Modify sampling and test time
-group.sample_size(20);  // Sample count
-group.measurement_time(Duration::from_secs(10));  // Test duration
-```
-
-## 🐛 Troubleshooting
-
-### Common Issues
-
-1. **Compilation Errors**: Ensure correct dependencies are installed
-```bash
-cargo update
-cargo build --all-features
-```
-
-2. **Performance Anomalies**: Check if running in correct mode
-```bash
-# Check current configuration
-cargo bench --bench comparison_benchmark -- --help
-```
-
-3. **Tests Taking Too Long**: Adjust test parameters
-```bash
-# Use shorter test duration
-cargo bench -- --quick
-```
-
-### Performance Analysis
-
-Use tools like `perf` for detailed performance analysis:
-
-```bash
-# Analyze CPU usage
-cargo bench --bench comparison_benchmark & 
-perf record -p $(pgrep -f comparison_benchmark)
-perf report
-```
-
-## 🤝 Contributing
-
-Welcome to submit new benchmark scenarios or optimization suggestions:
-
-1. Fork the project
-2. Create feature branch: `git checkout -b feature/new-benchmark`
-3. Add test cases
-4. Commit changes: `git commit -m 'Add new benchmark for XYZ'`
-5. Push to branch: `git push origin feature/new-benchmark`
-6. Create Pull Request
-
-## 📚 References
-
-- [reed-solomon-erasure crate](https://crates.io/crates/reed-solomon-erasure)
-- [reed-solomon-simd crate](https://crates.io/crates/reed-solomon-simd)
-- [Criterion.rs benchmark framework](https://bheisler.github.io/criterion.rs/book/)
-- [Reed-Solomon error correction principles](https://en.wikipedia.org/wiki/Reed%E2%80%93Solomon_error_correction)
-
----
-
-💡 **Tips**: 
-- Recommend using the default pure Erasure mode, which provides stable performance across various scenarios
-- Consider SIMD mode for high-performance requirements
-- Benchmark results may vary based on hardware, operating system, and compiler versions
-- Suggest running tests in target deployment environment for most accurate performance data 
\ No newline at end of file
diff --git a/ecstore/BENCHMARK_ZH.md b/ecstore/BENCHMARK_ZH.md
deleted file mode 100644
index 88355ed6..00000000
--- a/ecstore/BENCHMARK_ZH.md
+++ /dev/null
@@ -1,270 +0,0 @@
-# Reed-Solomon 纠删码性能基准测试
-
-本目录包含了比较不同 Reed-Solomon 实现性能的综合基准测试套件。
-
-## 📊 测试概述
-
-### 支持的实现模式
-
-#### 🏛️ 纯 Erasure 模式（默认，推荐）
-- **稳定可靠**: 使用成熟的 reed-solomon-erasure 实现
-- **广泛兼容**: 支持任意分片大小
-- **内存高效**: 优化的内存使用模式
-- **可预测性**: 性能对分片大小不敏感
-- **使用场景**: 生产环境默认选择，适合大多数应用场景
-
-#### 🎯 SIMD模式（`reed-solomon-simd` feature）
-- **高性能优化**: 使用SIMD指令集进行高性能编码解码
-- **性能导向**: 专注于最大化处理性能
-- **适用场景**: 大数据量处理的高性能场景
-- **使用场景**: 需要最大化性能的场景，适合处理大量数据
-
-### 测试维度
-
-- **编码性能** - 数据编码成纠删码分片的速度
-- **解码性能** - 从纠删码分片恢复原始数据的速度
-- **分片大小敏感性** - 不同分片大小对性能的影响
-- **纠删码配置** - 不同数据/奇偶分片比例的性能影响
-- **SIMD模式性能** - SIMD优化的性能表现
-- **并发性能** - 多线程环境下的性能表现
-- **内存效率** - 内存使用模式和效率
-- **错误恢复能力** - 不同丢失分片数量下的恢复性能
-
-## 🚀 快速开始
-
-### 运行快速测试
-
-```bash
-# 运行快速性能对比测试（默认纯Erasure模式）
-./run_benchmarks.sh quick
-```
-
-### 运行完整对比测试
-
-```bash
-# 运行详细的实现对比测试
-./run_benchmarks.sh comparison
-```
-
-### 运行特定模式的测试
-
-```bash
-# 测试默认纯 erasure 模式（推荐）
-./run_benchmarks.sh erasure
-
-# 测试SIMD模式
-./run_benchmarks.sh simd
-```
-
-## 📈 手动运行基准测试
-
-### 基本使用
-
-```bash
-# 运行所有基准测试（默认纯 erasure 模式）
-cargo bench
-
-# 运行特定的基准测试文件
-cargo bench --bench erasure_benchmark
-cargo bench --bench comparison_benchmark
-```
-
-### 对比不同实现模式
-
-```bash
-# 测试默认纯 erasure 模式
-cargo bench --bench comparison_benchmark
-
-# 测试SIMD模式
-cargo bench --bench comparison_benchmark \
-    --features reed-solomon-simd
-
-# 保存基线进行对比
-cargo bench --bench comparison_benchmark \
-    -- --save-baseline erasure_baseline
-
-# 与基线比较SIMD模式性能
-cargo bench --bench comparison_benchmark \
-    --features reed-solomon-simd \
-    -- --baseline erasure_baseline
-```
-
-### 过滤特定测试
-
-```bash
-# 只运行编码测试
-cargo bench encode
-
-# 只运行解码测试  
-cargo bench decode
-
-# 只运行特定数据大小的测试
-cargo bench 1MB
-
-# 只运行特定配置的测试
-cargo bench "4+2"
-```
-
-## 📊 查看结果
-
-### HTML 报告
-
-基准测试结果会自动生成 HTML 报告：
-
-```bash
-# 启动本地服务器查看报告
-cd target/criterion
-python3 -m http.server 8080
-
-# 在浏览器中访问
-open http://localhost:8080/report/index.html
-```
-
-### 命令行输出
-
-基准测试会在终端显示：
-- 每秒操作数 (ops/sec)
-- 吞吐量 (MB/s)
-- 延迟统计 (平均值、标准差、百分位数)
-- 性能变化趋势
-
-## 🔧 测试配置
-
-### 数据大小
-
-- **小数据**: 1KB, 8KB - 测试小文件场景
-- **中等数据**: 64KB, 256KB - 测试常见文件大小
-- **大数据**: 1MB, 4MB - 测试大文件处理和 SIMD 优化
-- **超大数据**: 16MB+ - 测试高吞吐量场景
-
-### 纠删码配置
-
-- **(4,2)** - 常用配置，33% 冗余
-- **(6,3)** - 50% 冗余，平衡性能和可靠性
-- **(8,4)** - 50% 冗余，更多并行度
-- **(10,5)**, **(12,6)** - 高并行度配置
-
-### 分片大小
-
-测试从 32 字节到 8KB 的不同分片大小，特别关注：
-- **内存对齐**: 64, 128, 256 字节 - 内存对齐对性能的影响
-- **Cache 友好**: 1KB, 2KB, 4KB - CPU 缓存友好的大小
-
-## 📝 解读测试结果
-
-### 性能指标
-
-1. **吞吐量 (Throughput)**
-   - 单位: MB/s 或 GB/s
-   - 衡量数据处理速度
-   - 越高越好
-
-2. **延迟 (Latency)**
-   - 单位: 微秒 (μs) 或毫秒 (ms)
-   - 衡量单次操作时间
-   - 越低越好
-
-3. **CPU 效率**
-   - 每 CPU 周期处理的字节数
-   - 反映算法效率
-
-### 预期结果
-
-**纯 Erasure 模式（默认）**:
-- 性能稳定，对分片大小不敏感
-- 兼容性最佳，支持所有配置
-- 内存使用稳定可预测
-
-**SIMD模式（`reed-solomon-simd` feature）**:
-- 高性能SIMD优化实现
-- 适合大数据量处理场景
-- 专注于最大化性能
-
-**分片大小敏感性**:
-- SIMD模式对分片大小可能更敏感
-- 纯 Erasure 模式对分片大小相对不敏感
-
-**内存使用**:
-- SIMD模式可能有特定的内存对齐要求
-- 纯 Erasure 模式内存使用更稳定
-
-## 🛠️ 自定义测试
-
-### 添加新的测试场景
-
-编辑 `benches/erasure_benchmark.rs` 或 `benches/comparison_benchmark.rs`：
-
-```rust
-// 添加新的测试配置
-let configs = vec![
-    // 你的自定义配置
-    BenchConfig::new(10, 4, 2048 * 1024, 2048 * 1024), // 10+4, 2MB
-];
-```
-
-### 调整测试参数
-
-```rust
-// 修改采样和测试时间
-group.sample_size(20);  // 样本数量
-group.measurement_time(Duration::from_secs(10));  // 测试时间
-```
-
-## 🐛 故障排除
-
-### 常见问题
-
-1. **编译错误**: 确保安装了正确的依赖
-```bash
-cargo update
-cargo build --all-features
-```
-
-2. **性能异常**: 检查是否在正确的模式下运行
-```bash
-# 检查当前配置
-cargo bench --bench comparison_benchmark -- --help
-```
-
-3. **测试时间过长**: 调整测试参数
-```bash
-# 使用更短的测试时间
-cargo bench -- --quick
-```
-
-### 性能分析
-
-使用 `perf` 等工具进行更详细的性能分析：
-
-```bash
-# 分析 CPU 使用情况
-cargo bench --bench comparison_benchmark & 
-perf record -p $(pgrep -f comparison_benchmark)
-perf report
-```
-
-## 🤝 贡献
-
-欢迎提交新的基准测试场景或优化建议：
-
-1. Fork 项目
-2. 创建特性分支: `git checkout -b feature/new-benchmark`
-3. 添加测试用例
-4. 提交更改: `git commit -m 'Add new benchmark for XYZ'`
-5. 推送到分支: `git push origin feature/new-benchmark`
-6. 创建 Pull Request
-
-## 📚 参考资料
-
-- [reed-solomon-erasure crate](https://crates.io/crates/reed-solomon-erasure)
-- [reed-solomon-simd crate](https://crates.io/crates/reed-solomon-simd)
-- [Criterion.rs 基准测试框架](https://bheisler.github.io/criterion.rs/book/)
-- [Reed-Solomon 纠删码原理](https://en.wikipedia.org/wiki/Reed%E2%80%93Solomon_error_correction)
-
----
-
-💡 **提示**: 
-- 推荐使用默认的纯Erasure模式，它在各种场景下都有稳定的表现
-- 对于高性能需求可以考虑SIMD模式
-- 基准测试结果可能因硬件、操作系统和编译器版本而异
-- 建议在目标部署环境中运行测试以获得最准确的性能数据 
\ No newline at end of file
diff --git a/ecstore/Cargo.toml b/ecstore/Cargo.toml
index 0d24be11..33af4ffd 100644
--- a/ecstore/Cargo.toml
+++ b/ecstore/Cargo.toml
@@ -11,12 +11,10 @@ rust-version.workspace = true
 workspace = true
 
 [features]
-default = ["reed-solomon-simd"]
-reed-solomon-simd = []
-reed-solomon-erasure = []
+default = []
 
 [dependencies]
-rustfs-config = { workspace = true }
+rustfs-config = { workspace = true, features = ["constants"] }
 async-trait.workspace = true
 backon.workspace = true
 blake2 = { workspace = true }
@@ -43,7 +41,6 @@ http-body-util = "0.1.1"
 highway = { workspace = true }
 url.workspace = true
 uuid = { workspace = true, features = ["v4", "fast-rng", "serde"] }
-reed-solomon-erasure = { version = "6.0.0", features = ["simd-accel"] }
 reed-solomon-simd = { version = "3.0.0" }
 transform-stream = "0.3.1"
 lazy_static.workspace = true
@@ -59,8 +56,12 @@ tokio-util = { workspace = true, features = ["io", "compat"] }
 crc32fast = { workspace = true }
 siphasher = { workspace = true }
 base64-simd = { workspace = true }
-sha1 = { workspace = true }
+
+base64 = { workspace = true }
+hmac = { workspace = true }
 sha2 = { workspace = true }
+sha1 = { workspace = true }
+
 hex-simd = { workspace = true }
 path-clean = { workspace = true }
 tempfile.workspace = true
@@ -94,6 +95,8 @@ shadow-rs.workspace = true
 rustfs-filemeta.workspace = true
 rustfs-utils ={workspace = true, features=["full"]}
 rustfs-rio.workspace = true
+futures-util.workspace = true
+serde_urlencoded.workspace = true
 reader = { workspace = true }
 
 [target.'cfg(not(windows))'.dependencies]
@@ -106,6 +109,7 @@ winapi = { workspace = true }
 [dev-dependencies]
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
 criterion = { version = "0.5", features = ["html_reports"] }
+temp-env = "0.2.0"
 
 [build-dependencies]
 shadow-rs = { workspace = true, features = ["build", "metadata"] }
@@ -116,4 +120,4 @@ harness = false
 
 [[bench]]
 name = "comparison_benchmark"
-harness = false
+harness = false
\ No newline at end of file
diff --git a/ecstore/IMPLEMENTATION_COMPARISON.md b/ecstore/IMPLEMENTATION_COMPARISON.md
deleted file mode 100644
index 1e5c2d32..00000000
--- a/ecstore/IMPLEMENTATION_COMPARISON.md
+++ /dev/null
@@ -1,333 +0,0 @@
-# Reed-Solomon Implementation Comparison Analysis
-
-## 🔍 Issue Analysis
-
-With the optimized SIMD mode design, we provide high-performance Reed-Solomon implementation. The system can now deliver optimal performance across different scenarios.
-
-## 📊 Implementation Mode Comparison
-
-### 🏛️ Pure Erasure Mode (Default, Recommended)
-
-**Default Configuration**: No features specified, uses stable reed-solomon-erasure implementation
-
-**Characteristics**:
-- ✅ **Wide Compatibility**: Supports any shard size from byte-level to GB-level
-- 📈 **Stable Performance**: Performance insensitive to shard size, predictable
-- 🔧 **Production Ready**: Mature and stable implementation, widely used in production
-- 💾 **Memory Efficient**: Optimized memory usage patterns
-- 🎯 **Consistency**: Completely consistent behavior across all scenarios
-
-**Use Cases**:
-- Default choice for most production environments
-- Systems requiring completely consistent and predictable performance behavior
-- Performance-change-sensitive systems
-- Scenarios mainly processing small files or small shards
-- Systems requiring strict memory usage control
-
-### 🎯 SIMD Mode (`reed-solomon-simd` feature)
-
-**Configuration**: `--features reed-solomon-simd`
-
-**Characteristics**:
-- 🚀 **High-Performance SIMD**: Uses SIMD instruction sets for high-performance encoding/decoding
-- 🎯 **Performance Oriented**: Focuses on maximizing processing performance
-- ⚡ **Large Data Optimization**: Suitable for high-throughput scenarios with large data processing
-- 🏎️ **Speed Priority**: Designed for performance-critical applications
-
-**Use Cases**:
-- Application scenarios requiring maximum performance
-- High-throughput systems processing large amounts of data
-- Scenarios with extremely high performance requirements
-- CPU-intensive workloads
-
-## 📏 Shard Size vs Performance Comparison
-
-Performance across different configurations:
-
-| Data Size | Config | Shard Size | Pure Erasure Mode (Default) | SIMD Mode Strategy | Performance Comparison |
-|-----------|--------|------------|----------------------------|-------------------|----------------------|
-| 1KB | 4+2 | 256 bytes | Erasure implementation | SIMD implementation | SIMD may be faster |
-| 1KB | 6+3 | 171 bytes | Erasure implementation | SIMD implementation | SIMD may be faster |
-| 1KB | 8+4 | 128 bytes | Erasure implementation | SIMD implementation | SIMD may be faster |
-| 64KB | 4+2 | 16KB | Erasure implementation | SIMD optimization | SIMD mode faster |
-| 64KB | 6+3 | 10.7KB | Erasure implementation | SIMD optimization | SIMD mode faster |
-| 1MB | 4+2 | 256KB | Erasure implementation | SIMD optimization | SIMD mode significantly faster |
-| 16MB | 8+4 | 2MB | Erasure implementation | SIMD optimization | SIMD mode substantially faster |
-
-## 🎯 Benchmark Results Interpretation
-
-### Pure Erasure Mode Example (Default) ✅
-
-```
-encode_comparison/implementation/1KB_6+3_erasure
-                        time:   [245.67 ns 256.78 ns 267.89 ns]
-                        thrpt:  [3.73 GiB/s 3.89 GiB/s 4.07 GiB/s]
-                        
-💡 Consistent Erasure performance - All configurations use the same implementation
-```
-
-```
-encode_comparison/implementation/64KB_4+2_erasure
-                        time:   [2.3456 μs 2.4567 μs 2.5678 μs]
-                        thrpt:  [23.89 GiB/s 24.65 GiB/s 25.43 GiB/s]
-                        
-💡 Stable and reliable performance - Suitable for most production scenarios
-```
-
-### SIMD Mode Success Examples ✅
-
-**Large Shard SIMD Optimization**:
-```
-encode_comparison/implementation/64KB_4+2_simd
-                        time:   [1.2345 μs 1.2567 μs 1.2789 μs]
-                        thrpt:  [47.89 GiB/s 48.65 GiB/s 49.43 GiB/s]
-                        
-💡 Using SIMD optimization - Shard size: 16KB, high-performance processing
-```
-
-**Small Shard SIMD Processing**:
-```
-encode_comparison/implementation/1KB_6+3_simd
-                        time:   [234.56 ns 245.67 ns 256.78 ns]
-                        thrpt:  [3.89 GiB/s 4.07 GiB/s 4.26 GiB/s]
-                        
-💡 SIMD processing small shards - Shard size: 171 bytes
-```
-
-## 🛠️ Usage Guide
-
-### Selection Strategy
-
-#### 1️⃣ Recommended: Pure Erasure Mode (Default)
-```bash
-# No features needed, use default configuration
-cargo run
-cargo test
-cargo bench
-```
-
-**Applicable Scenarios**:
-- 📊 **Consistency Requirements**: Need completely predictable performance behavior
-- 🔬 **Production Environment**: Best choice for most production scenarios
-- 💾 **Memory Sensitive**: Strict requirements for memory usage patterns
-- 🏗️ **Stable and Reliable**: Mature and stable implementation
-
-#### 2️⃣ High Performance Requirements: SIMD Mode
-```bash
-# Enable SIMD mode for maximum performance
-cargo run --features reed-solomon-simd
-cargo test --features reed-solomon-simd
-cargo bench --features reed-solomon-simd
-```
-
-**Applicable Scenarios**:
-- 🎯 **High Performance Scenarios**: Processing large amounts of data requiring maximum throughput
-- 🚀 **Performance Optimization**: Want optimal performance for large data
-- ⚡ **Speed Priority**: Scenarios with extremely high speed requirements
-- 🏎️ **Compute Intensive**: CPU-intensive workloads
-
-### Configuration Optimization Recommendations
-
-#### Based on Data Size
-
-**Small Files Primarily** (< 64KB):
-```toml
-# Recommended to use default pure Erasure mode
-# No special configuration needed, stable and reliable performance
-```
-
-**Large Files Primarily** (> 1MB):
-```toml
-# Recommend enabling SIMD mode for higher performance
-# features = ["reed-solomon-simd"]
-```
-
-**Mixed Scenarios**:
-```toml
-# Default pure Erasure mode suits most scenarios
-# For maximum performance, enable: features = ["reed-solomon-simd"]
-```
-
-#### Recommendations Based on Erasure Coding Configuration
-
-| Config | Small Data (< 64KB) | Large Data (> 1MB) | Recommended Mode |
-|--------|-------------------|-------------------|------------------|
-| 4+2 | Pure Erasure | Pure Erasure / SIMD Mode | Pure Erasure (Default) |
-| 6+3 | Pure Erasure | Pure Erasure / SIMD Mode | Pure Erasure (Default) |
-| 8+4 | Pure Erasure | Pure Erasure / SIMD Mode | Pure Erasure (Default) |
-| 10+5 | Pure Erasure | Pure Erasure / SIMD Mode | Pure Erasure (Default) |
-
-### Production Environment Deployment Recommendations
-
-#### 1️⃣ Default Deployment Strategy
-```bash
-# Production environment recommended configuration: Use pure Erasure mode (default)
-cargo build --release
-```
-
-**Advantages**:
-- ✅ Maximum compatibility: Handle data of any size
-- ✅ Stable and reliable: Mature implementation, predictable behavior
-- ✅ Zero configuration: No complex performance tuning needed
-- ✅ Memory efficient: Optimized memory usage patterns
-
-#### 2️⃣ High Performance Deployment Strategy
-```bash
-# High performance scenarios: Enable SIMD mode
-cargo build --release --features reed-solomon-simd
-```
-
-**Advantages**:
-- ✅ Optimal performance: SIMD instruction set optimization
-- ✅ High throughput: Suitable for large data processing
-- ✅ Performance oriented: Focuses on maximizing processing speed
-- ✅ Modern hardware: Fully utilizes modern CPU features
-
-#### 2️⃣ Monitoring and Tuning
-```rust
-// Choose appropriate implementation based on specific scenarios
-match data_size {
-    size if size > 1024 * 1024 => {
-        // Large data: Consider using SIMD mode
-        println!("Large data detected, SIMD mode recommended");
-    }
-    _ => {
-        // General case: Use default Erasure mode
-        println!("Using default Erasure mode");
-    }
-}
-```
-
-#### 3️⃣ Performance Monitoring Metrics
-- **Throughput Monitoring**: Monitor encoding/decoding data processing rates
-- **Latency Analysis**: Analyze processing latency for different data sizes
-- **CPU Utilization**: Observe CPU utilization efficiency of SIMD instructions
-- **Memory Usage**: Monitor memory allocation patterns of different implementations
-
-## 🔧 Troubleshooting
-
-### Performance Issue Diagnosis
-
-#### Issue 1: Performance Not Meeting Expectations
-**Symptom**: SIMD mode performance improvement not significant
-**Cause**: Data size may not be suitable for SIMD optimization
-**Solution**: 
-```rust
-// Check shard size and data characteristics
-let shard_size = data.len().div_ceil(data_shards);
-println!("Shard size: {} bytes", shard_size);
-if shard_size >= 1024 {
-    println!("Good candidate for SIMD optimization");
-} else {
-    println!("Consider using default Erasure mode");
-}
-```
-
-#### Issue 2: Compilation Errors
-**Symptom**: SIMD-related compilation errors
-**Cause**: Platform not supported or missing dependencies
-**Solution**:
-```bash
-# Check platform support
-cargo check --features reed-solomon-simd
-# If failed, use default mode
-cargo check
-```
-
-#### Issue 3: Abnormal Memory Usage
-**Symptom**: Memory usage exceeds expectations
-**Cause**: Memory alignment requirements of SIMD implementation
-**Solution**:
-```bash
-# Use pure Erasure mode for comparison
-cargo run --features reed-solomon-erasure
-```
-
-### Debugging Tips
-
-#### 1️⃣ Performance Comparison Testing
-```bash
-# Test pure Erasure mode performance
-cargo bench --features reed-solomon-erasure
-
-# Test SIMD mode performance
-cargo bench --features reed-solomon-simd
-```
-
-#### 2️⃣ Analyze Data Characteristics
-```rust
-// Statistics of data characteristics in your application
-let data_sizes: Vec<usize> = data_samples.iter()
-    .map(|data| data.len())
-    .collect();
-
-let large_data_count = data_sizes.iter()
-    .filter(|&&size| size >= 1024 * 1024)
-    .count();
-
-println!("Large data (>1MB): {}/{} ({}%)", 
-    large_data_count, 
-    data_sizes.len(),
-    large_data_count * 100 / data_sizes.len()
-);
-```
-
-#### 3️⃣ Benchmark Comparison
-```bash
-# Generate detailed performance comparison report
-./run_benchmarks.sh comparison
-
-# View HTML report to analyze performance differences
-cd target/criterion && python3 -m http.server 8080
-```
-
-## 📈 Performance Optimization Recommendations
-
-### Application Layer Optimization
-
-#### 1️⃣ Data Chunking Strategy
-```rust
-// Optimize data chunking for SIMD mode
-const OPTIMAL_BLOCK_SIZE: usize = 1024 * 1024; // 1MB
-const MIN_EFFICIENT_SIZE: usize = 64 * 1024; // 64KB
-
-let block_size = if data.len() < MIN_EFFICIENT_SIZE {
-    data.len() // Small data can consider default mode
-} else {
-    OPTIMAL_BLOCK_SIZE.min(data.len()) // Use optimal block size
-};
-```
-
-#### 2️⃣ Configuration Tuning
-```rust
-// Choose erasure coding configuration based on typical data size
-let (data_shards, parity_shards) = if typical_file_size > 1024 * 1024 {
-    (8, 4) // Large files: more parallelism, utilize SIMD
-} else {
-    (4, 2) // Small files: simple configuration, reduce overhead
-};
-```
-
-### System Layer Optimization
-
-#### 1️⃣ CPU Feature Detection
-```bash
-# Check CPU supported SIMD instruction sets
-lscpu | grep -i flags
-cat /proc/cpuinfo | grep -i flags | head -1
-```
-
-#### 2️⃣ Memory Alignment Optimization
-```rust
-// Ensure data memory alignment to improve SIMD performance
-use aligned_vec::AlignedVec;
-let aligned_data = AlignedVec::<u8, aligned_vec::A64>::from_slice(&data);
-```
-
----
-
-💡 **Key Conclusions**: 
-- 🎯 **Pure Erasure mode (default) is the best general choice**: Stable and reliable, suitable for most scenarios
-- 🚀 **SIMD mode suitable for high-performance scenarios**: Best choice for large data processing
-- 📊 **Choose based on data characteristics**: Small data use Erasure, large data consider SIMD
-- 🛡️ **Stability priority**: Production environments recommend using default Erasure mode 
\ No newline at end of file
diff --git a/ecstore/IMPLEMENTATION_COMPARISON_ZH.md b/ecstore/IMPLEMENTATION_COMPARISON_ZH.md
deleted file mode 100644
index 87fcb720..00000000
--- a/ecstore/IMPLEMENTATION_COMPARISON_ZH.md
+++ /dev/null
@@ -1,333 +0,0 @@
-# Reed-Solomon 实现对比分析
-
-## 🔍 问题分析
-
-随着SIMD模式的优化设计，我们提供了高性能的Reed-Solomon实现。现在系统能够在不同场景下提供最优的性能表现。
-
-## 📊 实现模式对比
-
-### 🏛️ 纯 Erasure 模式（默认，推荐）
-
-**默认配置**: 不指定任何 feature，使用稳定的 reed-solomon-erasure 实现
-
-**特点**:
-- ✅ **广泛兼容**: 支持任意分片大小，从字节级到 GB 级
-- 📈 **稳定性能**: 性能对分片大小不敏感，可预测
-- 🔧 **生产就绪**: 成熟稳定的实现，已在生产环境广泛使用
-- 💾 **内存高效**: 优化的内存使用模式
-- 🎯 **一致性**: 在所有场景下行为完全一致
-
-**使用场景**:
-- 大多数生产环境的默认选择
-- 需要完全一致和可预测的性能行为
-- 对性能变化敏感的系统
-- 主要处理小文件或小分片的场景
-- 需要严格的内存使用控制
-
-### 🎯 SIMD模式（`reed-solomon-simd` feature）
-
-**配置**: `--features reed-solomon-simd`
-
-**特点**:
-- 🚀 **高性能SIMD**: 使用SIMD指令集进行高性能编码解码
-- 🎯 **性能导向**: 专注于最大化处理性能
-- ⚡ **大数据优化**: 适合大数据量处理的高吞吐量场景
-- 🏎️ **速度优先**: 为性能关键型应用设计
-
-**使用场景**:
-- 需要最大化性能的应用场景
-- 处理大量数据的高吞吐量系统
-- 对性能要求极高的场景
-- CPU密集型工作负载
-
-## 📏 分片大小与性能对比
-
-不同配置下的性能表现：
-
-| 数据大小 | 配置 | 分片大小 | 纯 Erasure 模式（默认） | SIMD模式策略 | 性能对比 |
-|---------|------|----------|------------------------|-------------|----------|
-| 1KB | 4+2 | 256字节 | Erasure 实现 | SIMD 实现 | SIMD可能更快 |
-| 1KB | 6+3 | 171字节 | Erasure 实现 | SIMD 实现 | SIMD可能更快 |
-| 1KB | 8+4 | 128字节 | Erasure 实现 | SIMD 实现 | SIMD可能更快 |
-| 64KB | 4+2 | 16KB | Erasure 实现 | SIMD 优化 | SIMD模式更快 |
-| 64KB | 6+3 | 10.7KB | Erasure 实现 | SIMD 优化 | SIMD模式更快 |
-| 1MB | 4+2 | 256KB | Erasure 实现 | SIMD 优化 | SIMD模式显著更快 |
-| 16MB | 8+4 | 2MB | Erasure 实现 | SIMD 优化 | SIMD模式大幅领先 |
-
-## 🎯 基准测试结果解读
-
-### 纯 Erasure 模式示例（默认） ✅
-
-```
-encode_comparison/implementation/1KB_6+3_erasure
-                        time:   [245.67 ns 256.78 ns 267.89 ns]
-                        thrpt:  [3.73 GiB/s 3.89 GiB/s 4.07 GiB/s]
-                        
-💡 一致的 Erasure 性能 - 所有配置都使用相同实现
-```
-
-```
-encode_comparison/implementation/64KB_4+2_erasure
-                        time:   [2.3456 μs 2.4567 μs 2.5678 μs]
-                        thrpt:  [23.89 GiB/s 24.65 GiB/s 25.43 GiB/s]
-                        
-💡 稳定可靠的性能 - 适合大多数生产场景
-```
-
-### SIMD模式成功示例 ✅
-
-**大分片 SIMD 优化**:
-```
-encode_comparison/implementation/64KB_4+2_simd
-                        time:   [1.2345 μs 1.2567 μs 1.2789 μs]
-                        thrpt:  [47.89 GiB/s 48.65 GiB/s 49.43 GiB/s]
-                        
-💡 使用 SIMD 优化 - 分片大小: 16KB，高性能处理
-```
-
-**小分片 SIMD 处理**:
-```
-encode_comparison/implementation/1KB_6+3_simd
-                        time:   [234.56 ns 245.67 ns 256.78 ns]
-                        thrpt:  [3.89 GiB/s 4.07 GiB/s 4.26 GiB/s]
-                        
-💡 SIMD 处理小分片 - 分片大小: 171字节
-```
-
-## 🛠️ 使用指南
-
-### 选择策略
-
-#### 1️⃣ 推荐：纯 Erasure 模式（默认）
-```bash
-# 无需指定 feature，使用默认配置
-cargo run
-cargo test
-cargo bench
-```
-
-**适用场景**:
-- 📊 **一致性要求**: 需要完全可预测的性能行为
-- 🔬 **生产环境**: 大多数生产场景的最佳选择
-- 💾 **内存敏感**: 对内存使用模式有严格要求
-- 🏗️ **稳定可靠**: 成熟稳定的实现
-
-#### 2️⃣ 高性能需求：SIMD模式
-```bash
-# 启用SIMD模式获得最大性能
-cargo run --features reed-solomon-simd
-cargo test --features reed-solomon-simd
-cargo bench --features reed-solomon-simd
-```
-
-**适用场景**:
-- 🎯 **高性能场景**: 处理大量数据需要最大吞吐量
-- 🚀 **性能优化**: 希望在大数据时获得最佳性能
-- ⚡ **速度优先**: 对处理速度有极高要求的场景
-- 🏎️ **计算密集**: CPU密集型工作负载
-
-### 配置优化建议
-
-#### 针对数据大小的配置
-
-**小文件为主** (< 64KB):
-```toml
-# 推荐使用默认纯 Erasure 模式
-# 无需特殊配置，性能稳定可靠
-```
-
-**大文件为主** (> 1MB):
-```toml
-# 建议启用SIMD模式获得更高性能
-# features = ["reed-solomon-simd"]
-```
-
-**混合场景**:
-```toml
-# 默认纯 Erasure 模式适合大多数场景
-# 如需最大性能可启用: features = ["reed-solomon-simd"]
-```
-
-#### 针对纠删码配置的建议
-
-| 配置 | 小数据 (< 64KB) | 大数据 (> 1MB) | 推荐模式 |
-|------|----------------|----------------|----------|
-| 4+2 | 纯 Erasure | 纯 Erasure / SIMD模式 | 纯 Erasure（默认） |
-| 6+3 | 纯 Erasure | 纯 Erasure / SIMD模式 | 纯 Erasure（默认） |
-| 8+4 | 纯 Erasure | 纯 Erasure / SIMD模式 | 纯 Erasure（默认） |
-| 10+5 | 纯 Erasure | 纯 Erasure / SIMD模式 | 纯 Erasure（默认） |
-
-### 生产环境部署建议
-
-#### 1️⃣ 默认部署策略
-```bash
-# 生产环境推荐配置：使用纯 Erasure 模式（默认）
-cargo build --release
-```
-
-**优势**:
-- ✅ 最大兼容性：处理任意大小数据
-- ✅ 稳定可靠：成熟的实现，行为可预测
-- ✅ 零配置：无需复杂的性能调优
-- ✅ 内存高效：优化的内存使用模式
-
-#### 2️⃣ 高性能部署策略
-```bash
-# 高性能场景：启用SIMD模式
-cargo build --release --features reed-solomon-simd
-```
-
-**优势**:
-- ✅ 最优性能：SIMD指令集优化
-- ✅ 高吞吐量：适合大数据处理
-- ✅ 性能导向：专注于最大化处理速度
-- ✅ 现代硬件：充分利用现代CPU特性
-
-#### 2️⃣ 监控和调优
-```rust
-// 根据具体场景选择合适的实现
-match data_size {
-    size if size > 1024 * 1024 => {
-        // 大数据：考虑使用SIMD模式
-        println!("Large data detected, SIMD mode recommended");
-    }
-    _ => {
-        // 一般情况：使用默认Erasure模式
-        println!("Using default Erasure mode");
-    }
-}
-```
-
-#### 3️⃣ 性能监控指标
-- **吞吐量监控**: 监控编码/解码的数据处理速率
-- **延迟分析**: 分析不同数据大小的处理延迟
-- **CPU使用率**: 观察SIMD指令的CPU利用效率
-- **内存使用**: 监控不同实现的内存分配模式
-
-## 🔧 故障排除
-
-### 性能问题诊断
-
-#### 问题1: 性能不符合预期
-**现象**: SIMD模式性能提升不明显
-**原因**: 可能数据大小不适合SIMD优化
-**解决**: 
-```rust
-// 检查分片大小和数据特征
-let shard_size = data.len().div_ceil(data_shards);
-println!("Shard size: {} bytes", shard_size);
-if shard_size >= 1024 {
-    println!("Good candidate for SIMD optimization");
-} else {
-    println!("Consider using default Erasure mode");
-}
-```
-
-#### 问题2: 编译错误
-**现象**: SIMD相关的编译错误
-**原因**: 平台不支持或依赖缺失
-**解决**:
-```bash
-# 检查平台支持
-cargo check --features reed-solomon-simd
-# 如果失败，使用默认模式
-cargo check
-```
-
-#### 问题3: 内存使用异常
-**现象**: 内存使用超出预期
-**原因**: SIMD实现的内存对齐要求
-**解决**:
-```bash
-# 使用纯 Erasure 模式进行对比
-cargo run --features reed-solomon-erasure
-```
-
-### 调试技巧
-
-#### 1️⃣ 性能对比测试
-```bash
-# 测试纯 Erasure 模式性能
-cargo bench --features reed-solomon-erasure
-
-# 测试SIMD模式性能
-cargo bench --features reed-solomon-simd
-```
-
-#### 2️⃣ 分析数据特征
-```rust
-// 统计你的应用中的数据特征
-let data_sizes: Vec<usize> = data_samples.iter()
-    .map(|data| data.len())
-    .collect();
-
-let large_data_count = data_sizes.iter()
-    .filter(|&&size| size >= 1024 * 1024)
-    .count();
-
-println!("Large data (>1MB): {}/{} ({}%)", 
-    large_data_count, 
-    data_sizes.len(),
-    large_data_count * 100 / data_sizes.len()
-);
-```
-
-#### 3️⃣ 基准测试对比
-```bash
-# 生成详细的性能对比报告
-./run_benchmarks.sh comparison
-
-# 查看 HTML 报告分析性能差异
-cd target/criterion && python3 -m http.server 8080
-```
-
-## 📈 性能优化建议
-
-### 应用层优化
-
-#### 1️⃣ 数据分块策略
-```rust
-// 针对SIMD模式优化数据分块
-const OPTIMAL_BLOCK_SIZE: usize = 1024 * 1024; // 1MB
-const MIN_EFFICIENT_SIZE: usize = 64 * 1024; // 64KB
-
-let block_size = if data.len() < MIN_EFFICIENT_SIZE {
-    data.len() // 小数据可以考虑默认模式
-} else {
-    OPTIMAL_BLOCK_SIZE.min(data.len()) // 使用最优块大小
-};
-```
-
-#### 2️⃣ 配置调优
-```rust
-// 根据典型数据大小选择纠删码配置
-let (data_shards, parity_shards) = if typical_file_size > 1024 * 1024 {
-    (8, 4) // 大文件：更多并行度，利用 SIMD
-} else {
-    (4, 2) // 小文件：简单配置，减少开销
-};
-```
-
-### 系统层优化
-
-#### 1️⃣ CPU 特性检测
-```bash
-# 检查 CPU 支持的 SIMD 指令集
-lscpu | grep -i flags
-cat /proc/cpuinfo | grep -i flags | head -1
-```
-
-#### 2️⃣ 内存对齐优化
-```rust
-// 确保数据内存对齐以提升 SIMD 性能
-use aligned_vec::AlignedVec;
-let aligned_data = AlignedVec::<u8, aligned_vec::A64>::from_slice(&data);
-```
-
----
-
-💡 **关键结论**: 
-- 🎯 **纯Erasure模式（默认）是最佳通用选择**：稳定可靠，适合大多数场景
-- 🚀 **SIMD模式适合高性能场景**：大数据处理的最佳选择
-- 📊 **根据数据特征选择**：小数据用Erasure，大数据考虑SIMD
-- 🛡️ **稳定性优先**：生产环境建议使用默认Erasure模式 
\ No newline at end of file
diff --git a/ecstore/README_cn.md b/ecstore/README_cn.md
index a6a0a0bd..27ca55b4 100644
--- a/ecstore/README_cn.md
+++ b/ecstore/README_cn.md
@@ -1,38 +1,15 @@
 # ECStore - Erasure Coding Storage
 
-ECStore provides erasure coding functionality for the RustFS project, supporting multiple Reed-Solomon implementations for optimal performance and compatibility.
+ECStore provides erasure coding functionality for the RustFS project, using high-performance Reed-Solomon SIMD implementation for optimal performance.
 
-## Reed-Solomon Implementations
+## Reed-Solomon Implementation
 
-### Available Backends
+### SIMD Backend (Only)
 
-#### `reed-solomon-erasure` (Default)
-- **Stability**: Mature and well-tested implementation
-- **Performance**: Good performance with SIMD acceleration when available
-- **Compatibility**: Works with any shard size
-- **Memory**: Efficient memory usage
-- **Use case**: Recommended for production use
-
-#### `reed-solomon-simd` (Optional)
-- **Performance**: Optimized SIMD implementation for maximum speed
-- **Limitations**: Has restrictions on shard sizes (must be >= 64 bytes typically)
-- **Memory**: May use more memory for small shards
-- **Use case**: Best for large data blocks where performance is critical
-
-### Feature Flags
-
-Configure the Reed-Solomon implementation using Cargo features:
-
-```toml
-# Use default implementation (reed-solomon-erasure)
-ecstore = "0.0.1"
-
-# Use SIMD implementation for maximum performance
-ecstore = { version = "0.0.1", features = ["reed-solomon-simd"], default-features = false }
-
-# Use traditional implementation explicitly
-ecstore = { version = "0.0.1", features = ["reed-solomon-erasure"], default-features = false }
-```
+- **Performance**: Uses SIMD optimization for high-performance encoding/decoding
+- **Compatibility**: Works with any shard size through SIMD implementation
+- **Reliability**: High-performance SIMD implementation for large data processing
+- **Use case**: Optimized for maximum performance in large data processing scenarios
 
 ### Usage Example
 
@@ -68,42 +45,52 @@ assert_eq!(&recovered, data);
 
 ## Performance Considerations
 
-### When to use `reed-solomon-simd`
-- Large block sizes (>= 1KB recommended)
-- High-throughput scenarios
-- CPU-intensive workloads where encoding/decoding is the bottleneck
-
-### When to use `reed-solomon-erasure`
-- Small block sizes
-- Memory-constrained environments
-- General-purpose usage
-- Production deployments requiring maximum stability
+### SIMD Implementation Benefits
+- **High Throughput**: Optimized for large block sizes (>= 1KB recommended)
+- **CPU Optimization**: Leverages modern CPU SIMD instructions
+- **Scalability**: Excellent performance for high-throughput scenarios
 
 ### Implementation Details
 
-#### `reed-solomon-erasure`
-- **Instance Reuse**: The encoder instance is cached and reused across multiple operations
-- **Thread Safety**: Thread-safe with interior mutability
-- **Memory Efficiency**: Lower memory footprint for small data
-
 #### `reed-solomon-simd`
-- **Instance Creation**: New encoder/decoder instances are created for each operation
-- **API Design**: The SIMD implementation's API is designed for single-use instances
-- **Performance Trade-off**: While instances are created per operation, the SIMD optimizations provide significant performance benefits for large data blocks
-- **Optimization**: Future versions may implement instance pooling if the underlying API supports reuse
+- **Instance Caching**: Encoder/decoder instances are cached and reused for optimal performance
+- **Thread Safety**: Thread-safe with RwLock-based caching
+- **SIMD Optimization**: Leverages CPU SIMD instructions for maximum performance
+- **Reset Capability**: Cached instances are reset for different parameters, avoiding unnecessary allocations
 
 ### Performance Tips
 
 1. **Batch Operations**: When possible, batch multiple small operations into larger blocks
-2. **Block Size Optimization**: Use block sizes that are multiples of 64 bytes for SIMD implementations
+2. **Block Size Optimization**: Use block sizes that are multiples of 64 bytes for optimal SIMD performance
 3. **Memory Allocation**: Pre-allocate buffers when processing multiple blocks
-4. **Feature Selection**: Choose the appropriate feature based on your data size and performance requirements
+4. **Cache Warming**: Initial operations may be slower due to cache setup, subsequent operations benefit from caching
 
 ## Cross-Platform Compatibility
 
-Both implementations support:
-- x86_64 with SIMD acceleration
-- aarch64 (ARM64) with optimizations
+The SIMD implementation supports:
+- x86_64 with advanced SIMD instructions (AVX2, SSE)
+- aarch64 (ARM64) with NEON SIMD optimizations
 - Other architectures with fallback implementations
 
-The `reed-solomon-erasure` implementation provides better cross-platform compatibility and is recommended for most use cases. 
\ No newline at end of file
+The implementation automatically selects the best available SIMD instructions for the target platform, providing optimal performance across different architectures.
+
+## Testing and Benchmarking
+
+Run performance benchmarks:
+```bash
+# Run erasure coding benchmarks
+cargo bench --bench erasure_benchmark
+
+# Run comparison benchmarks
+cargo bench --bench comparison_benchmark
+
+# Generate benchmark reports
+./run_benchmarks.sh
+```
+
+## Error Handling
+
+All operations return `Result` types with comprehensive error information:
+- Encoding errors: Invalid parameters, insufficient memory
+- Decoding errors: Too many missing shards, corrupted data
+- Configuration errors: Invalid shard counts, unsupported parameters 
\ No newline at end of file
diff --git a/ecstore/benches/comparison_benchmark.rs b/ecstore/benches/comparison_benchmark.rs
index 42147266..5140e306 100644
--- a/ecstore/benches/comparison_benchmark.rs
+++ b/ecstore/benches/comparison_benchmark.rs
@@ -1,29 +1,28 @@
-//! 专门比较 Pure Erasure 和 Hybrid (SIMD) 模式性能的基准测试
+//! Reed-Solomon SIMD performance analysis benchmarks
 //!
-//! 这个基准测试使用不同的feature编译配置来直接对比两种实现的性能。
+//! This benchmark analyzes the performance characteristics of the SIMD Reed-Solomon implementation
+//! across different data sizes, shard configurations, and usage patterns.
 //!
-//! ## 运行比较测试
+//! ## Running Performance Analysis
 //!
 //! ```bash
-//! # 测试 Pure Erasure 实现 (默认)
+//! # Run all SIMD performance tests
 //! cargo bench --bench comparison_benchmark
 //!
-//! # 测试 Hybrid (SIMD) 实现  
-//! cargo bench --bench comparison_benchmark --features reed-solomon-simd
+//! # Generate detailed performance report
+//! cargo bench --bench comparison_benchmark -- --save-baseline simd_analysis
 //!
-//! # 测试强制 erasure-only 模式
-//! cargo bench --bench comparison_benchmark --features reed-solomon-erasure
-//!
-//! # 生成对比报告
-//! cargo bench --bench comparison_benchmark -- --save-baseline erasure
-//! cargo bench --bench comparison_benchmark --features reed-solomon-simd -- --save-baseline hybrid
+//! # Run specific test categories
+//! cargo bench --bench comparison_benchmark encode_analysis
+//! cargo bench --bench comparison_benchmark decode_analysis
+//! cargo bench --bench comparison_benchmark shard_analysis
 //! ```
 
 use criterion::{BenchmarkId, Criterion, Throughput, black_box, criterion_group, criterion_main};
 use ecstore::erasure_coding::Erasure;
 use std::time::Duration;
 
-/// 基准测试数据配置
+/// Performance test data configuration
 struct TestData {
     data: Vec<u8>,
     size_name: &'static str,
@@ -36,41 +35,41 @@ impl TestData {
     }
 }
 
-/// 生成不同大小的测试数据集
+/// Generate different sized test datasets for performance analysis
 fn generate_test_datasets() -> Vec<TestData> {
     vec![
-        TestData::new(1024, "1KB"),            // 小数据
-        TestData::new(8 * 1024, "8KB"),        // 中小数据
-        TestData::new(64 * 1024, "64KB"),      // 中等数据
-        TestData::new(256 * 1024, "256KB"),    // 中大数据
-        TestData::new(1024 * 1024, "1MB"),     // 大数据
-        TestData::new(4 * 1024 * 1024, "4MB"), // 超大数据
+        TestData::new(1024, "1KB"),            // Small data
+        TestData::new(8 * 1024, "8KB"),        // Medium-small data
+        TestData::new(64 * 1024, "64KB"),      // Medium data
+        TestData::new(256 * 1024, "256KB"),    // Medium-large data
+        TestData::new(1024 * 1024, "1MB"),     // Large data
+        TestData::new(4 * 1024 * 1024, "4MB"), // Extra large data
     ]
 }
 
-/// 编码性能比较基准测试
-fn bench_encode_comparison(c: &mut Criterion) {
+/// SIMD encoding performance analysis
+fn bench_encode_analysis(c: &mut Criterion) {
     let datasets = generate_test_datasets();
     let configs = vec![
-        (4, 2, "4+2"), // 常用配置
-        (6, 3, "6+3"), // 50%冗余
-        (8, 4, "8+4"), // 50%冗余，更多分片
+        (4, 2, "4+2"), // Common configuration
+        (6, 3, "6+3"), // 50% redundancy
+        (8, 4, "8+4"), // 50% redundancy, more shards
     ];
 
     for dataset in &datasets {
         for (data_shards, parity_shards, config_name) in &configs {
-            let test_name = format!("{}_{}_{}", dataset.size_name, config_name, get_implementation_name());
+            let test_name = format!("{}_{}_{}", dataset.size_name, config_name, "simd");
 
-            let mut group = c.benchmark_group("encode_comparison");
+            let mut group = c.benchmark_group("encode_analysis");
             group.throughput(Throughput::Bytes(dataset.data.len() as u64));
             group.sample_size(20);
             group.measurement_time(Duration::from_secs(10));
 
-            // 检查是否能够创建erasure实例（某些配置在纯SIMD模式下可能失败）
+            // Test SIMD encoding performance
             match Erasure::new(*data_shards, *parity_shards, dataset.data.len()).encode_data(&dataset.data) {
                 Ok(_) => {
                     group.bench_with_input(
-                        BenchmarkId::new("implementation", &test_name),
+                        BenchmarkId::new("simd_encode", &test_name),
                         &(&dataset.data, *data_shards, *parity_shards),
                         |b, (data, data_shards, parity_shards)| {
                             let erasure = Erasure::new(*data_shards, *parity_shards, data.len());
@@ -82,7 +81,7 @@ fn bench_encode_comparison(c: &mut Criterion) {
                     );
                 }
                 Err(e) => {
-                    println!("⚠️  跳过测试 {} - 配置不支持: {}", test_name, e);
+                    println!("⚠️  Skipping test {} - configuration not supported: {}", test_name, e);
                 }
             }
             group.finish();
@@ -90,35 +89,35 @@ fn bench_encode_comparison(c: &mut Criterion) {
     }
 }
 
-/// 解码性能比较基准测试
-fn bench_decode_comparison(c: &mut Criterion) {
+/// SIMD decoding performance analysis
+fn bench_decode_analysis(c: &mut Criterion) {
     let datasets = generate_test_datasets();
     let configs = vec![(4, 2, "4+2"), (6, 3, "6+3"), (8, 4, "8+4")];
 
     for dataset in &datasets {
         for (data_shards, parity_shards, config_name) in &configs {
-            let test_name = format!("{}_{}_{}", dataset.size_name, config_name, get_implementation_name());
+            let test_name = format!("{}_{}_{}", dataset.size_name, config_name, "simd");
             let erasure = Erasure::new(*data_shards, *parity_shards, dataset.data.len());
 
-            // 预先编码数据 - 检查是否支持此配置
+            // Pre-encode data - check if this configuration is supported
             match erasure.encode_data(&dataset.data) {
                 Ok(encoded_shards) => {
-                    let mut group = c.benchmark_group("decode_comparison");
+                    let mut group = c.benchmark_group("decode_analysis");
                     group.throughput(Throughput::Bytes(dataset.data.len() as u64));
                     group.sample_size(20);
                     group.measurement_time(Duration::from_secs(10));
 
                     group.bench_with_input(
-                        BenchmarkId::new("implementation", &test_name),
+                        BenchmarkId::new("simd_decode", &test_name),
                         &(&encoded_shards, *data_shards, *parity_shards),
                         |b, (shards, data_shards, parity_shards)| {
                             let erasure = Erasure::new(*data_shards, *parity_shards, dataset.data.len());
                             b.iter(|| {
-                                // 模拟最大可恢复的数据丢失
+                                // Simulate maximum recoverable data loss
                                 let mut shards_opt: Vec<Option<Vec<u8>>> =
                                     shards.iter().map(|shard| Some(shard.to_vec())).collect();
 
-                                // 丢失等于奇偶校验分片数量的分片
+                                // Lose up to parity_shards number of shards
                                 for item in shards_opt.iter_mut().take(*parity_shards) {
                                     *item = None;
                                 }
@@ -131,33 +130,33 @@ fn bench_decode_comparison(c: &mut Criterion) {
                     group.finish();
                 }
                 Err(e) => {
-                    println!("⚠️  跳过解码测试 {} - 配置不支持: {}", test_name, e);
+                    println!("⚠️  Skipping decode test {} - configuration not supported: {}", test_name, e);
                 }
             }
         }
     }
 }
 
-/// 分片大小敏感性测试
-fn bench_shard_size_sensitivity(c: &mut Criterion) {
+/// Shard size sensitivity analysis for SIMD optimization
+fn bench_shard_size_analysis(c: &mut Criterion) {
     let data_shards = 4;
     let parity_shards = 2;
 
-    // 测试不同的分片大小，特别关注SIMD的临界点
+    // Test different shard sizes, focusing on SIMD optimization thresholds
     let shard_sizes = vec![32, 64, 128, 256, 512, 1024, 2048, 4096, 8192];
 
-    let mut group = c.benchmark_group("shard_size_sensitivity");
+    let mut group = c.benchmark_group("shard_size_analysis");
     group.sample_size(15);
     group.measurement_time(Duration::from_secs(8));
 
     for shard_size in shard_sizes {
         let total_size = shard_size * data_shards;
         let data = (0..total_size).map(|i| (i % 256) as u8).collect::<Vec<u8>>();
-        let test_name = format!("{}B_shard_{}", shard_size, get_implementation_name());
+        let test_name = format!("{}B_shard_simd", shard_size);
 
         group.throughput(Throughput::Bytes(total_size as u64));
 
-        // 检查此分片大小是否支持
+        // Check if this shard size is supported
         let erasure = Erasure::new(data_shards, parity_shards, data.len());
         match erasure.encode_data(&data) {
             Ok(_) => {
@@ -170,15 +169,15 @@ fn bench_shard_size_sensitivity(c: &mut Criterion) {
                 });
             }
             Err(e) => {
-                println!("⚠️  跳过分片大小测试 {} - 不支持: {}", test_name, e);
+                println!("⚠️  Skipping shard size test {} - not supported: {}", test_name, e);
             }
         }
     }
     group.finish();
 }
 
-/// 高负载并发测试
-fn bench_concurrent_load(c: &mut Criterion) {
+/// High-load concurrent performance analysis
+fn bench_concurrent_analysis(c: &mut Criterion) {
     use std::sync::Arc;
     use std::thread;
 
@@ -186,14 +185,14 @@ fn bench_concurrent_load(c: &mut Criterion) {
     let data = Arc::new((0..data_size).map(|i| (i % 256) as u8).collect::<Vec<u8>>());
     let erasure = Arc::new(Erasure::new(4, 2, data_size));
 
-    let mut group = c.benchmark_group("concurrent_load");
+    let mut group = c.benchmark_group("concurrent_analysis");
     group.throughput(Throughput::Bytes(data_size as u64));
     group.sample_size(10);
     group.measurement_time(Duration::from_secs(15));
 
-    let test_name = format!("1MB_concurrent_{}", get_implementation_name());
+    let test_name = "1MB_concurrent_simd";
 
-    group.bench_function(&test_name, |b| {
+    group.bench_function(test_name, |b| {
         b.iter(|| {
             let handles: Vec<_> = (0..4)
                 .map(|_| {
@@ -214,42 +213,44 @@ fn bench_concurrent_load(c: &mut Criterion) {
     group.finish();
 }
 
-/// 错误恢复能力测试
-fn bench_error_recovery_performance(c: &mut Criterion) {
-    let data_size = 256 * 1024; // 256KB
+/// Error recovery performance analysis
+fn bench_error_recovery_analysis(c: &mut Criterion) {
+    let data_size = 512 * 1024; // 512KB
     let data = (0..data_size).map(|i| (i % 256) as u8).collect::<Vec<u8>>();
 
-    let configs = vec![
-        (4, 2, 1), // 丢失1个分片
-        (4, 2, 2), // 丢失2个分片（最大可恢复）
-        (6, 3, 2), // 丢失2个分片
-        (6, 3, 3), // 丢失3个分片（最大可恢复）
-        (8, 4, 3), // 丢失3个分片
-        (8, 4, 4), // 丢失4个分片（最大可恢复）
+    // Test different error recovery scenarios
+    let scenarios = vec![
+        (4, 2, 1, "single_loss"),     // Lose 1 shard
+        (4, 2, 2, "double_loss"),     // Lose 2 shards (maximum)
+        (6, 3, 1, "single_loss_6_3"), // Lose 1 shard with 6+3
+        (6, 3, 3, "triple_loss_6_3"), // Lose 3 shards (maximum)
+        (8, 4, 2, "double_loss_8_4"), // Lose 2 shards with 8+4
+        (8, 4, 4, "quad_loss_8_4"),   // Lose 4 shards (maximum)
     ];
 
-    let mut group = c.benchmark_group("error_recovery");
+    let mut group = c.benchmark_group("error_recovery_analysis");
     group.throughput(Throughput::Bytes(data_size as u64));
     group.sample_size(15);
-    group.measurement_time(Duration::from_secs(8));
+    group.measurement_time(Duration::from_secs(10));
 
-    for (data_shards, parity_shards, lost_shards) in configs {
+    for (data_shards, parity_shards, loss_count, scenario_name) in scenarios {
         let erasure = Erasure::new(data_shards, parity_shards, data_size);
-        let test_name = format!("{}+{}_lost{}_{}", data_shards, parity_shards, lost_shards, get_implementation_name());
 
-        // 检查此配置是否支持
         match erasure.encode_data(&data) {
             Ok(encoded_shards) => {
+                let test_name = format!("{}+{}_{}", data_shards, parity_shards, scenario_name);
+
                 group.bench_with_input(
                     BenchmarkId::new("recovery", &test_name),
-                    &(&encoded_shards, data_shards, parity_shards, lost_shards),
-                    |b, (shards, data_shards, parity_shards, lost_shards)| {
+                    &(&encoded_shards, data_shards, parity_shards, loss_count),
+                    |b, (shards, data_shards, parity_shards, loss_count)| {
                         let erasure = Erasure::new(*data_shards, *parity_shards, data_size);
                         b.iter(|| {
+                            // Simulate specific number of shard losses
                             let mut shards_opt: Vec<Option<Vec<u8>>> = shards.iter().map(|shard| Some(shard.to_vec())).collect();
 
-                            // 丢失指定数量的分片
-                            for item in shards_opt.iter_mut().take(*lost_shards) {
+                            // Lose the specified number of shards
+                            for item in shards_opt.iter_mut().take(*loss_count) {
                                 *item = None;
                             }
 
@@ -260,71 +261,57 @@ fn bench_error_recovery_performance(c: &mut Criterion) {
                 );
             }
             Err(e) => {
-                println!("⚠️  跳过错误恢复测试 {} - 配置不支持: {}", test_name, e);
+                println!("⚠️  Skipping recovery test {}: {}", scenario_name, e);
             }
         }
     }
     group.finish();
 }
 
-/// 内存效率测试
-fn bench_memory_efficiency(c: &mut Criterion) {
-    let data_shards = 4;
-    let parity_shards = 2;
-    let data_size = 1024 * 1024; // 1MB
+/// Memory efficiency analysis
+fn bench_memory_analysis(c: &mut Criterion) {
+    let data_sizes = vec![64 * 1024, 256 * 1024, 1024 * 1024]; // 64KB, 256KB, 1MB
+    let config = (4, 2); // 4+2 configuration
 
-    let mut group = c.benchmark_group("memory_efficiency");
-    group.throughput(Throughput::Bytes(data_size as u64));
-    group.sample_size(10);
+    let mut group = c.benchmark_group("memory_analysis");
+    group.sample_size(15);
     group.measurement_time(Duration::from_secs(8));
 
-    let test_name = format!("memory_pattern_{}", get_implementation_name());
+    for data_size in data_sizes {
+        let data = (0..data_size).map(|i| (i % 256) as u8).collect::<Vec<u8>>();
+        let size_name = format!("{}KB", data_size / 1024);
 
-    // 测试连续多次编码对内存的影响
-    group.bench_function(format!("{}_continuous", test_name), |b| {
-        let erasure = Erasure::new(data_shards, parity_shards, data_size);
-        b.iter(|| {
-            for i in 0..10 {
-                let data = vec![(i % 256) as u8; data_size];
-                let shards = erasure.encode_data(black_box(&data)).unwrap();
+        group.throughput(Throughput::Bytes(data_size as u64));
+
+        // Test instance reuse vs new instance creation
+        group.bench_with_input(BenchmarkId::new("reuse_instance", &size_name), &data, |b, data| {
+            let erasure = Erasure::new(config.0, config.1, data.len());
+            b.iter(|| {
+                let shards = erasure.encode_data(black_box(data)).unwrap();
                 black_box(shards);
-            }
+            });
         });
-    });
 
-    // 测试大量小编码任务
-    group.bench_function(format!("{}_small_chunks", test_name), |b| {
-        let chunk_size = 1024; // 1KB chunks
-        let erasure = Erasure::new(data_shards, parity_shards, chunk_size);
-        b.iter(|| {
-            for i in 0..1024 {
-                let data = vec![(i % 256) as u8; chunk_size];
-                let shards = erasure.encode_data(black_box(&data)).unwrap();
+        group.bench_with_input(BenchmarkId::new("new_instance", &size_name), &data, |b, data| {
+            b.iter(|| {
+                let erasure = Erasure::new(config.0, config.1, data.len());
+                let shards = erasure.encode_data(black_box(data)).unwrap();
                 black_box(shards);
-            }
+            });
         });
-    });
-
+    }
     group.finish();
 }
 
-/// 获取当前实现的名称
-fn get_implementation_name() -> &'static str {
-    #[cfg(feature = "reed-solomon-simd")]
-    return "hybrid";
-
-    #[cfg(not(feature = "reed-solomon-simd"))]
-    return "erasure";
-}
-
+// Benchmark group configuration
 criterion_group!(
     benches,
-    bench_encode_comparison,
-    bench_decode_comparison,
-    bench_shard_size_sensitivity,
-    bench_concurrent_load,
-    bench_error_recovery_performance,
-    bench_memory_efficiency
+    bench_encode_analysis,
+    bench_decode_analysis,
+    bench_shard_size_analysis,
+    bench_concurrent_analysis,
+    bench_error_recovery_analysis,
+    bench_memory_analysis
 );
 
 criterion_main!(benches);
diff --git a/ecstore/benches/erasure_benchmark.rs b/ecstore/benches/erasure_benchmark.rs
index a2d0fcba..eec595db 100644
--- a/ecstore/benches/erasure_benchmark.rs
+++ b/ecstore/benches/erasure_benchmark.rs
@@ -1,25 +1,23 @@
-//! Reed-Solomon erasure coding performance benchmarks.
+//! Reed-Solomon SIMD erasure coding performance benchmarks.
 //!
-//! This benchmark compares the performance of different Reed-Solomon implementations:
-//! - Default (Pure erasure): Stable reed-solomon-erasure implementation
-//! - `reed-solomon-simd` feature: SIMD mode with optimized performance
+//! This benchmark tests the performance of the high-performance SIMD Reed-Solomon implementation.
 //!
 //! ## Running Benchmarks
 //!
 //! ```bash
-//! # 运行所有基准测试
+//! # Run all benchmarks
 //! cargo bench
 //!
-//! # 运行特定的基准测试
+//! # Run specific benchmark
 //! cargo bench --bench erasure_benchmark
 //!
-//! # 生成HTML报告
+//! # Generate HTML report
 //! cargo bench --bench erasure_benchmark -- --output-format html
 //!
-//! # 只测试编码性能
+//! # Test encoding performance only
 //! cargo bench encode
 //!
-//! # 只测试解码性能
+//! # Test decoding performance only
 //! cargo bench decode
 //! ```
 //!
@@ -29,24 +27,24 @@
 //! - Different data sizes: 1KB, 64KB, 1MB, 16MB
 //! - Different erasure coding configurations: (4,2), (6,3), (8,4)
 //! - Both encoding and decoding operations
-//! - Small vs large shard scenarios for SIMD optimization
+//! - SIMD optimization for different shard sizes
 
 use criterion::{BenchmarkId, Criterion, Throughput, black_box, criterion_group, criterion_main};
 use ecstore::erasure_coding::{Erasure, calc_shard_size};
 use std::time::Duration;
 
-/// 基准测试配置结构体
+/// Benchmark configuration structure
 #[derive(Clone, Debug)]
 struct BenchConfig {
-    /// 数据分片数量
+    /// Number of data shards
     data_shards: usize,
-    /// 奇偶校验分片数量
+    /// Number of parity shards
     parity_shards: usize,
-    /// 测试数据大小（字节）
+    /// Test data size (bytes)
     data_size: usize,
-    /// 块大小（字节）
+    /// Block size (bytes)
     block_size: usize,
-    /// 配置名称
+    /// Configuration name
     name: String,
 }
 
@@ -62,27 +60,27 @@ impl BenchConfig {
     }
 }
 
-/// 生成测试数据
+/// Generate test data
 fn generate_test_data(size: usize) -> Vec<u8> {
     (0..size).map(|i| (i % 256) as u8).collect()
 }
 
-/// 基准测试: 编码性能对比
+/// Benchmark: Encoding performance
 fn bench_encode_performance(c: &mut Criterion) {
     let configs = vec![
-        // 小数据量测试 - 1KB
+        // Small data tests - 1KB
         BenchConfig::new(4, 2, 1024, 1024),
         BenchConfig::new(6, 3, 1024, 1024),
         BenchConfig::new(8, 4, 1024, 1024),
-        // 中等数据量测试 - 64KB
+        // Medium data tests - 64KB
         BenchConfig::new(4, 2, 64 * 1024, 64 * 1024),
         BenchConfig::new(6, 3, 64 * 1024, 64 * 1024),
         BenchConfig::new(8, 4, 64 * 1024, 64 * 1024),
-        // 大数据量测试 - 1MB
+        // Large data tests - 1MB
         BenchConfig::new(4, 2, 1024 * 1024, 1024 * 1024),
         BenchConfig::new(6, 3, 1024 * 1024, 1024 * 1024),
         BenchConfig::new(8, 4, 1024 * 1024, 1024 * 1024),
-        // 超大数据量测试 - 16MB
+        // Extra large data tests - 16MB
         BenchConfig::new(4, 2, 16 * 1024 * 1024, 16 * 1024 * 1024),
         BenchConfig::new(6, 3, 16 * 1024 * 1024, 16 * 1024 * 1024),
     ];
@@ -90,13 +88,13 @@ fn bench_encode_performance(c: &mut Criterion) {
     for config in configs {
         let data = generate_test_data(config.data_size);
 
-        // 测试当前默认实现（通常是SIMD）
-        let mut group = c.benchmark_group("encode_current");
+        // Test SIMD encoding performance
+        let mut group = c.benchmark_group("encode_simd");
         group.throughput(Throughput::Bytes(config.data_size as u64));
         group.sample_size(10);
         group.measurement_time(Duration::from_secs(5));
 
-        group.bench_with_input(BenchmarkId::new("current_impl", &config.name), &(&data, &config), |b, (data, config)| {
+        group.bench_with_input(BenchmarkId::new("simd_impl", &config.name), &(&data, &config), |b, (data, config)| {
             let erasure = Erasure::new(config.data_shards, config.parity_shards, config.block_size);
             b.iter(|| {
                 let shards = erasure.encode_data(black_box(data)).unwrap();
@@ -105,99 +103,55 @@ fn bench_encode_performance(c: &mut Criterion) {
         });
         group.finish();
 
-        // 如果SIMD feature启用，测试专用的erasure实现对比
-        #[cfg(feature = "reed-solomon-simd")]
-        {
-            use ecstore::erasure_coding::ReedSolomonEncoder;
+        // Test direct SIMD implementation for large shards (>= 512 bytes)
+        let shard_size = calc_shard_size(config.data_size, config.data_shards);
+        if shard_size >= 512 {
+            let mut simd_group = c.benchmark_group("encode_simd_direct");
+            simd_group.throughput(Throughput::Bytes(config.data_size as u64));
+            simd_group.sample_size(10);
+            simd_group.measurement_time(Duration::from_secs(5));
 
-            let mut erasure_group = c.benchmark_group("encode_erasure_only");
-            erasure_group.throughput(Throughput::Bytes(config.data_size as u64));
-            erasure_group.sample_size(10);
-            erasure_group.measurement_time(Duration::from_secs(5));
+            simd_group.bench_with_input(BenchmarkId::new("simd_direct", &config.name), &(&data, &config), |b, (data, config)| {
+                b.iter(|| {
+                    // Direct SIMD implementation
+                    let per_shard_size = calc_shard_size(data.len(), config.data_shards);
+                    match reed_solomon_simd::ReedSolomonEncoder::new(config.data_shards, config.parity_shards, per_shard_size) {
+                        Ok(mut encoder) => {
+                            // Create properly sized buffer and fill with data
+                            let mut buffer = vec![0u8; per_shard_size * config.data_shards];
+                            let copy_len = data.len().min(buffer.len());
+                            buffer[..copy_len].copy_from_slice(&data[..copy_len]);
 
-            erasure_group.bench_with_input(
-                BenchmarkId::new("erasure_impl", &config.name),
-                &(&data, &config),
-                |b, (data, config)| {
-                    let encoder = ReedSolomonEncoder::new(config.data_shards, config.parity_shards).unwrap();
-                    b.iter(|| {
-                        // 创建编码所需的数据结构
-                        let per_shard_size = calc_shard_size(data.len(), config.data_shards);
-                        let total_size = per_shard_size * (config.data_shards + config.parity_shards);
-                        let mut buffer = vec![0u8; total_size];
-                        buffer[..data.len()].copy_from_slice(data);
-
-                        let slices: smallvec::SmallVec<[&mut [u8]; 16]> = buffer.chunks_exact_mut(per_shard_size).collect();
-
-                        encoder.encode(black_box(slices)).unwrap();
-                        black_box(&buffer);
-                    });
-                },
-            );
-            erasure_group.finish();
-        }
-
-        // 如果使用SIMD feature，测试直接SIMD实现对比
-        #[cfg(feature = "reed-solomon-simd")]
-        {
-            // 只对大shard测试SIMD（小于512字节的shard SIMD性能不佳）
-            let shard_size = calc_shard_size(config.data_size, config.data_shards);
-            if shard_size >= 512 {
-                let mut simd_group = c.benchmark_group("encode_simd_direct");
-                simd_group.throughput(Throughput::Bytes(config.data_size as u64));
-                simd_group.sample_size(10);
-                simd_group.measurement_time(Duration::from_secs(5));
-
-                simd_group.bench_with_input(
-                    BenchmarkId::new("simd_impl", &config.name),
-                    &(&data, &config),
-                    |b, (data, config)| {
-                        b.iter(|| {
-                            // 直接使用SIMD实现
-                            let per_shard_size = calc_shard_size(data.len(), config.data_shards);
-                            match reed_solomon_simd::ReedSolomonEncoder::new(
-                                config.data_shards,
-                                config.parity_shards,
-                                per_shard_size,
-                            ) {
-                                Ok(mut encoder) => {
-                                    // 创建正确大小的缓冲区，并填充数据
-                                    let mut buffer = vec![0u8; per_shard_size * config.data_shards];
-                                    let copy_len = data.len().min(buffer.len());
-                                    buffer[..copy_len].copy_from_slice(&data[..copy_len]);
-
-                                    // 按正确的分片大小添加数据分片
-                                    for chunk in buffer.chunks_exact(per_shard_size) {
-                                        encoder.add_original_shard(black_box(chunk)).unwrap();
-                                    }
-
-                                    let result = encoder.encode().unwrap();
-                                    black_box(result);
-                                }
-                                Err(_) => {
-                                    // SIMD不支持此配置，跳过
-                                    black_box(());
-                                }
+                            // Add data shards with correct shard size
+                            for chunk in buffer.chunks_exact(per_shard_size) {
+                                encoder.add_original_shard(black_box(chunk)).unwrap();
                             }
-                        });
-                    },
-                );
-                simd_group.finish();
-            }
+
+                            let result = encoder.encode().unwrap();
+                            black_box(result);
+                        }
+                        Err(_) => {
+                            // SIMD doesn't support this configuration, skip
+                            black_box(());
+                        }
+                    }
+                });
+            });
+            simd_group.finish();
         }
     }
 }
 
-/// 基准测试: 解码性能对比
+/// Benchmark: Decoding performance
 fn bench_decode_performance(c: &mut Criterion) {
     let configs = vec![
-        // 中等数据量测试 - 64KB
+        // Medium data tests - 64KB
         BenchConfig::new(4, 2, 64 * 1024, 64 * 1024),
         BenchConfig::new(6, 3, 64 * 1024, 64 * 1024),
-        // 大数据量测试 - 1MB
+        // Large data tests - 1MB
         BenchConfig::new(4, 2, 1024 * 1024, 1024 * 1024),
         BenchConfig::new(6, 3, 1024 * 1024, 1024 * 1024),
-        // 超大数据量测试 - 16MB
+        // Extra large data tests - 16MB
         BenchConfig::new(4, 2, 16 * 1024 * 1024, 16 * 1024 * 1024),
     ];
 
@@ -205,25 +159,25 @@ fn bench_decode_performance(c: &mut Criterion) {
         let data = generate_test_data(config.data_size);
         let erasure = Erasure::new(config.data_shards, config.parity_shards, config.block_size);
 
-        // 预先编码数据
+        // Pre-encode data
         let encoded_shards = erasure.encode_data(&data).unwrap();
 
-        // 测试当前默认实现的解码性能
-        let mut group = c.benchmark_group("decode_current");
+        // Test SIMD decoding performance
+        let mut group = c.benchmark_group("decode_simd");
         group.throughput(Throughput::Bytes(config.data_size as u64));
         group.sample_size(10);
         group.measurement_time(Duration::from_secs(5));
 
         group.bench_with_input(
-            BenchmarkId::new("current_impl", &config.name),
+            BenchmarkId::new("simd_impl", &config.name),
             &(&encoded_shards, &config),
             |b, (shards, config)| {
                 let erasure = Erasure::new(config.data_shards, config.parity_shards, config.block_size);
                 b.iter(|| {
-                    // 模拟数据丢失 - 丢失一个数据分片和一个奇偶分片
+                    // Simulate data loss - lose one data shard and one parity shard
                     let mut shards_opt: Vec<Option<Vec<u8>>> = shards.iter().map(|shard| Some(shard.to_vec())).collect();
 
-                    // 丢失最后一个数据分片和第一个奇偶分片
+                    // Lose last data shard and first parity shard
                     shards_opt[config.data_shards - 1] = None;
                     shards_opt[config.data_shards] = None;
 
@@ -234,58 +188,52 @@ fn bench_decode_performance(c: &mut Criterion) {
         );
         group.finish();
 
-        // 如果使用混合模式（默认），测试SIMD解码性能
-        #[cfg(not(feature = "reed-solomon-erasure"))]
-        {
-            let shard_size = calc_shard_size(config.data_size, config.data_shards);
-            if shard_size >= 512 {
-                let mut simd_group = c.benchmark_group("decode_simd_direct");
-                simd_group.throughput(Throughput::Bytes(config.data_size as u64));
-                simd_group.sample_size(10);
-                simd_group.measurement_time(Duration::from_secs(5));
+        // Test direct SIMD decoding for large shards
+        let shard_size = calc_shard_size(config.data_size, config.data_shards);
+        if shard_size >= 512 {
+            let mut simd_group = c.benchmark_group("decode_simd_direct");
+            simd_group.throughput(Throughput::Bytes(config.data_size as u64));
+            simd_group.sample_size(10);
+            simd_group.measurement_time(Duration::from_secs(5));
 
-                simd_group.bench_with_input(
-                    BenchmarkId::new("simd_impl", &config.name),
-                    &(&encoded_shards, &config),
-                    |b, (shards, config)| {
-                        b.iter(|| {
-                            let per_shard_size = calc_shard_size(config.data_size, config.data_shards);
-                            match reed_solomon_simd::ReedSolomonDecoder::new(
-                                config.data_shards,
-                                config.parity_shards,
-                                per_shard_size,
-                            ) {
-                                Ok(mut decoder) => {
-                                    // 添加可用的分片（除了丢失的）
-                                    for (i, shard) in shards.iter().enumerate() {
-                                        if i != config.data_shards - 1 && i != config.data_shards {
-                                            if i < config.data_shards {
-                                                decoder.add_original_shard(i, black_box(shard)).unwrap();
-                                            } else {
-                                                let recovery_idx = i - config.data_shards;
-                                                decoder.add_recovery_shard(recovery_idx, black_box(shard)).unwrap();
-                                            }
+            simd_group.bench_with_input(
+                BenchmarkId::new("simd_direct", &config.name),
+                &(&encoded_shards, &config),
+                |b, (shards, config)| {
+                    b.iter(|| {
+                        let per_shard_size = calc_shard_size(config.data_size, config.data_shards);
+                        match reed_solomon_simd::ReedSolomonDecoder::new(config.data_shards, config.parity_shards, per_shard_size)
+                        {
+                            Ok(mut decoder) => {
+                                // Add available shards (except lost ones)
+                                for (i, shard) in shards.iter().enumerate() {
+                                    if i != config.data_shards - 1 && i != config.data_shards {
+                                        if i < config.data_shards {
+                                            decoder.add_original_shard(i, black_box(shard)).unwrap();
+                                        } else {
+                                            let recovery_idx = i - config.data_shards;
+                                            decoder.add_recovery_shard(recovery_idx, black_box(shard)).unwrap();
                                         }
                                     }
+                                }
 
-                                    let result = decoder.decode().unwrap();
-                                    black_box(result);
-                                }
-                                Err(_) => {
-                                    // SIMD不支持此配置，跳过
-                                    black_box(());
-                                }
+                                let result = decoder.decode().unwrap();
+                                black_box(result);
                             }
-                        });
-                    },
-                );
-                simd_group.finish();
-            }
+                            Err(_) => {
+                                // SIMD doesn't support this configuration, skip
+                                black_box(());
+                            }
+                        }
+                    });
+                },
+            );
+            simd_group.finish();
         }
     }
 }
 
-/// 基准测试: 不同分片大小对性能的影响
+/// Benchmark: Impact of different shard sizes on performance
 fn bench_shard_size_impact(c: &mut Criterion) {
     let shard_sizes = vec![64, 128, 256, 512, 1024, 2048, 4096, 8192];
     let data_shards = 4;
@@ -301,8 +249,8 @@ fn bench_shard_size_impact(c: &mut Criterion) {
 
         group.throughput(Throughput::Bytes(total_data_size as u64));
 
-        // 测试当前实现
-        group.bench_with_input(BenchmarkId::new("current", format!("shard_{}B", shard_size)), &data, |b, data| {
+        // Test SIMD implementation
+        group.bench_with_input(BenchmarkId::new("simd", format!("shard_{}B", shard_size)), &data, |b, data| {
             let erasure = Erasure::new(data_shards, parity_shards, total_data_size);
             b.iter(|| {
                 let shards = erasure.encode_data(black_box(data)).unwrap();
@@ -313,19 +261,19 @@ fn bench_shard_size_impact(c: &mut Criterion) {
     group.finish();
 }
 
-/// 基准测试: 编码配置对性能的影响
+/// Benchmark: Impact of coding configurations on performance
 fn bench_coding_configurations(c: &mut Criterion) {
     let configs = vec![
-        (2, 1),  // 最小冗余
-        (3, 2),  // 中等冗余
-        (4, 2),  // 常用配置
-        (6, 3),  // 50%冗余
-        (8, 4),  // 50%冗余，更多分片
-        (10, 5), // 50%冗余，大量分片
-        (12, 6), // 50%冗余，更大量分片
+        (2, 1),  // Minimal redundancy
+        (3, 2),  // Medium redundancy
+        (4, 2),  // Common configuration
+        (6, 3),  // 50% redundancy
+        (8, 4),  // 50% redundancy, more shards
+        (10, 5), // 50% redundancy, many shards
+        (12, 6), // 50% redundancy, very many shards
     ];
 
-    let data_size = 1024 * 1024; // 1MB测试数据
+    let data_size = 1024 * 1024; // 1MB test data
     let data = generate_test_data(data_size);
 
     let mut group = c.benchmark_group("coding_configurations");
@@ -347,17 +295,17 @@ fn bench_coding_configurations(c: &mut Criterion) {
     group.finish();
 }
 
-/// 基准测试: 内存使用模式
+/// Benchmark: Memory usage patterns
 fn bench_memory_patterns(c: &mut Criterion) {
     let data_shards = 4;
     let parity_shards = 2;
-    let block_size = 1024 * 1024; // 1MB块
+    let block_size = 1024 * 1024; // 1MB block
 
     let mut group = c.benchmark_group("memory_patterns");
     group.sample_size(10);
     group.measurement_time(Duration::from_secs(5));
 
-    // 测试重复使用同一个Erasure实例
+    // Test reusing the same Erasure instance
     group.bench_function("reuse_erasure_instance", |b| {
         let erasure = Erasure::new(data_shards, parity_shards, block_size);
         let data = generate_test_data(block_size);
@@ -368,7 +316,7 @@ fn bench_memory_patterns(c: &mut Criterion) {
         });
     });
 
-    // 测试每次创建新的Erasure实例
+    // Test creating new Erasure instance each time
     group.bench_function("new_erasure_instance", |b| {
         let data = generate_test_data(block_size);
 
@@ -382,7 +330,7 @@ fn bench_memory_patterns(c: &mut Criterion) {
     group.finish();
 }
 
-// 基准测试组配置
+// Benchmark group configuration
 criterion_group!(
     benches,
     bench_encode_performance,
diff --git a/ecstore/run_benchmarks.sh b/ecstore/run_benchmarks.sh
index f4b091be..ddf58fb9 100755
--- a/ecstore/run_benchmarks.sh
+++ b/ecstore/run_benchmarks.sh
@@ -1,54 +1,48 @@
 #!/bin/bash
 
-# Reed-Solomon 实现性能比较脚本
-# 
-# 这个脚本将运行不同的基准测试来比较SIMD模式和纯Erasure模式的性能
-# 
-# 使用方法:
-#   ./run_benchmarks.sh [quick|full|comparison]
-#
-#   quick      - 快速测试主要场景
-#   full       - 完整基准测试套件
-#   comparison - 专门对比两种实现模式
+# Reed-Solomon SIMD 性能基准测试脚本
+# 使用高性能 SIMD 实现进行纠删码性能测试
 
 set -e
 
-# 颜色输出
+# ANSI 颜色码
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 BLUE='\033[0;34m'
+PURPLE='\033[0;35m'
 NC='\033[0m' # No Color
 
-# 输出带颜色的信息
+# 打印带颜色的消息
 print_info() {
-    echo -e "${BLUE}[INFO]${NC} $1"
+    echo -e "${BLUE}ℹ️  $1${NC}"
 }
 
 print_success() {
-    echo -e "${GREEN}[SUCCESS]${NC} $1"
+    echo -e "${GREEN}✅ $1${NC}"
 }
 
 print_warning() {
-    echo -e "${YELLOW}[WARNING]${NC} $1"
+    echo -e "${YELLOW}⚠️  $1${NC}"
 }
 
 print_error() {
-    echo -e "${RED}[ERROR]${NC} $1"
+    echo -e "${RED}❌ $1${NC}"
 }
 
-# 检查是否安装了必要工具
+# 检查系统要求
 check_requirements() {
     print_info "检查系统要求..."
     
+    # 检查 Rust
     if ! command -v cargo &> /dev/null; then
-        print_error "cargo 未安装，请先安装 Rust 工具链"
+        print_error "Cargo 未找到，请确保已安装 Rust"
         exit 1
     fi
     
-    # 检查是否安装了 criterion
-    if ! grep -q "criterion" Cargo.toml; then
-        print_error "Cargo.toml 中未找到 criterion 依赖"
+    # 检查 criterion
+    if ! cargo --list | grep -q "bench"; then
+        print_error "未找到基准测试支持，请确保使用的是支持基准测试的 Rust 版本"
         exit 1
     fi
     
@@ -62,28 +56,15 @@ cleanup() {
     print_success "清理完成"
 }
 
-# 运行纯 Erasure 模式基准测试
-run_erasure_benchmark() {
-    print_info "🏛️ 开始运行纯 Erasure 模式基准测试..."
-    echo "================================================"
-    
-    cargo bench --bench comparison_benchmark \
-        --features reed-solomon-erasure \
-        -- --save-baseline erasure_baseline
-    
-    print_success "纯 Erasure 模式基准测试完成"
-}
-
-# 运行SIMD模式基准测试
+# 运行 SIMD 模式基准测试
 run_simd_benchmark() {
-    print_info "🎯 开始运行SIMD模式基准测试..."
+    print_info "🎯 开始运行 SIMD 模式基准测试..."
     echo "================================================"
     
     cargo bench --bench comparison_benchmark \
-        --features reed-solomon-simd \
         -- --save-baseline simd_baseline
     
-    print_success "SIMD模式基准测试完成"
+    print_success "SIMD 模式基准测试完成"
 }
 
 # 运行完整的基准测试套件
@@ -91,33 +72,42 @@ run_full_benchmark() {
     print_info "🚀 开始运行完整基准测试套件..."
     echo "================================================"
     
-    # 运行详细的基准测试（使用默认纯Erasure模式）
+    # 运行详细的基准测试
     cargo bench --bench erasure_benchmark
     
     print_success "完整基准测试套件完成"
 }
 
-# 运行性能对比测试
-run_comparison_benchmark() {
-    print_info "📊 开始运行性能对比测试..."
+# 运行性能测试
+run_performance_test() {
+    print_info "📊 开始运行性能测试..."
     echo "================================================"
     
-    print_info "步骤 1: 测试纯 Erasure 模式..."
+    print_info "步骤 1: 运行编码基准测试..."
     cargo bench --bench comparison_benchmark \
-        --features reed-solomon-erasure \
-        -- --save-baseline erasure_baseline
+        -- encode --save-baseline encode_baseline
     
-    print_info "步骤 2: 测试SIMD模式并与 Erasure 模式对比..."
+    print_info "步骤 2: 运行解码基准测试..."
     cargo bench --bench comparison_benchmark \
-        --features reed-solomon-simd \
-        -- --baseline erasure_baseline
+        -- decode --save-baseline decode_baseline
     
-    print_success "性能对比测试完成"
+    print_success "性能测试完成"
+}
+
+# 运行大数据集测试
+run_large_data_test() {
+    print_info "🗂️ 开始运行大数据集测试..."
+    echo "================================================"
+    
+    cargo bench --bench erasure_benchmark \
+        -- large_data --save-baseline large_data_baseline
+    
+    print_success "大数据集测试完成"
 }
 
 # 生成比较报告
 generate_comparison_report() {
-    print_info "📊 生成性能比较报告..."
+    print_info "📊 生成性能报告..."
     
     if [ -d "target/criterion" ]; then
         print_info "基准测试结果已保存到 target/criterion/ 目录"
@@ -138,49 +128,48 @@ generate_comparison_report() {
 run_quick_test() {
     print_info "🏃 运行快速性能测试..."
     
-    print_info "测试纯 Erasure 模式..."
+    print_info "测试 SIMD 编码性能..."
     cargo bench --bench comparison_benchmark \
-        --features reed-solomon-erasure \
-        -- encode_comparison --quick
+        -- encode --quick
     
-    print_info "测试SIMD模式..."
+    print_info "测试 SIMD 解码性能..."
     cargo bench --bench comparison_benchmark \
-        --features reed-solomon-simd \
-        -- encode_comparison --quick
+        -- decode --quick
     
     print_success "快速测试完成"
 }
 
 # 显示帮助信息
 show_help() {
-    echo "Reed-Solomon 性能基准测试脚本"
+    echo "Reed-Solomon SIMD 性能基准测试脚本"
     echo ""
     echo "实现模式："
-    echo "  🏛️ 纯 Erasure 模式（默认）- 稳定兼容的 reed-solomon-erasure 实现"
-    echo "  🎯 SIMD模式              - 高性能SIMD优化实现"
+    echo "  🎯 SIMD 模式 - 高性能 SIMD 优化的 reed-solomon-simd 实现"
     echo ""
     echo "使用方法:"
     echo "  $0 [command]"
     echo ""
     echo "命令:"
     echo "  quick        运行快速性能测试"
-    echo "  full         运行完整基准测试套件（默认Erasure模式）"
-    echo "  comparison   运行详细的实现模式对比测试"
-    echo "  erasure      只测试纯 Erasure 模式"
-    echo "  simd         只测试SIMD模式"
+    echo "  full         运行完整基准测试套件"
+    echo "  performance  运行详细的性能测试"
+    echo "  simd         运行 SIMD 模式测试"
+    echo "  large        运行大数据集测试"
     echo "  clean        清理测试结果"
     echo "  help         显示此帮助信息"
     echo ""
     echo "示例:"
-    echo "  $0 quick              # 快速测试两种模式"
-    echo "  $0 comparison         # 详细对比测试"
-    echo "  $0 full              # 完整测试套件（默认Erasure模式）"
-    echo "  $0 simd              # 只测试SIMD模式"
-    echo "  $0 erasure           # 只测试纯 Erasure 模式"
+    echo "  $0 quick              # 快速性能测试"
+    echo "  $0 performance        # 详细性能测试"
+    echo "  $0 full              # 完整测试套件"
+    echo "  $0 simd              # SIMD 模式测试"
+    echo "  $0 large             # 大数据集测试"
     echo ""
-    echo "模式说明:"
-    echo "  Erasure模式: 使用reed-solomon-erasure实现，稳定可靠"
-    echo "  SIMD模式: 使用reed-solomon-simd实现，高性能优化"
+    echo "实现特性:"
+    echo "  - 使用 reed-solomon-simd 高性能 SIMD 实现"
+    echo "  - 支持编码器/解码器实例缓存"
+    echo "  - 优化的内存管理和线程安全"
+    echo "  - 跨平台 SIMD 指令支持"
 }
 
 # 显示测试配置信息
@@ -196,22 +185,22 @@ show_test_info() {
     if [ -f "/proc/cpuinfo" ]; then
         echo "  - CPU 型号: $(grep 'model name' /proc/cpuinfo | head -1 | cut -d: -f2 | xargs)"
         if grep -q "avx2" /proc/cpuinfo; then
-            echo "  - SIMD 支持: AVX2 ✅ (SIMD模式将利用SIMD优化)"
+            echo "  - SIMD 支持: AVX2 ✅ (将使用高级 SIMD 优化)"
         elif grep -q "sse4" /proc/cpuinfo; then
-            echo "  - SIMD 支持: SSE4 ✅ (SIMD模式将利用SIMD优化)"
+            echo "  - SIMD 支持: SSE4 ✅ (将使用 SIMD 优化)"
         else
-            echo "  - SIMD 支持: 未检测到高级 SIMD 特性"
+            echo "  - SIMD 支持: 基础 SIMD 特性"
         fi
     fi
     
-    echo "  - 默认模式: 纯Erasure模式 (稳定可靠)"
-    echo "  - 高性能模式: SIMD模式 (性能优化)"
+    echo "  - 实现: reed-solomon-simd (高性能 SIMD 优化)"
+    echo "  - 特性: 实例缓存、线程安全、跨平台 SIMD"
     echo ""
 }
 
 # 主函数
 main() {
-    print_info "🧪 Reed-Solomon 实现性能基准测试"
+    print_info "🧪 Reed-Solomon SIMD 实现性能基准测试"
     echo "================================================"
     
     check_requirements
@@ -227,14 +216,9 @@ main() {
             run_full_benchmark
             generate_comparison_report
             ;;
-        "comparison")
+        "performance")
             cleanup
-            run_comparison_benchmark
-            generate_comparison_report
-            ;;
-        "erasure")
-            cleanup
-            run_erasure_benchmark
+            run_performance_test
             generate_comparison_report
             ;;
         "simd")
@@ -242,6 +226,11 @@ main() {
             run_simd_benchmark
             generate_comparison_report
             ;;
+        "large")
+            cleanup
+            run_large_data_test
+            generate_comparison_report
+            ;;
         "clean")
             cleanup
             ;;
@@ -257,10 +246,7 @@ main() {
     esac
     
     print_success "✨ 基准测试执行完成!"
-    print_info "💡 提示: 推荐使用默认的纯Erasure模式，对于高性能需求可考虑SIMD模式"
 }
 
-# 如果直接运行此脚本，调用主函数
-if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
-    main "$@"
-fi 
\ No newline at end of file
+# 启动脚本
+main "$@" 
\ No newline at end of file
diff --git a/ecstore/src/admin_server_info.rs b/ecstore/src/admin_server_info.rs
index 7304ae05..231926d1 100644
--- a/ecstore/src/admin_server_info.rs
+++ b/ecstore/src/admin_server_info.rs
@@ -93,7 +93,7 @@ async fn is_server_resolvable(endpoint: &Endpoint) -> Result<()> {
     // 构造 PingRequest
     let request = Request::new(PingRequest {
         version: 1,
-        body: finished_data.to_vec(),
+        body: bytes::Bytes::copy_from_slice(finished_data),
     });
 
     // 发送请求并获取响应
diff --git a/ecstore/src/bitrot.rs b/ecstore/src/bitrot.rs
index fa2f5922..7fefab48 100644
--- a/ecstore/src/bitrot.rs
+++ b/ecstore/src/bitrot.rs
@@ -28,7 +28,7 @@ pub async fn create_bitrot_reader(
     checksum_algo: HashAlgorithm,
 ) -> disk::error::Result<Option<BitrotReader<Box<dyn AsyncRead + Send + Sync + Unpin>>>> {
     // Calculate the total length to read, including the checksum overhead
-    let length = offset.div_ceil(shard_size) * checksum_algo.size() + length;
+    let length = length.div_ceil(shard_size) * checksum_algo.size() + length;
 
     if let Some(data) = inline_data {
         // Use inline data
@@ -68,14 +68,20 @@ pub async fn create_bitrot_writer(
     disk: Option<&DiskStore>,
     volume: &str,
     path: &str,
-    length: usize,
+    length: i64,
     shard_size: usize,
     checksum_algo: HashAlgorithm,
 ) -> disk::error::Result<BitrotWriterWrapper> {
     let writer = if is_inline_buffer {
         CustomWriter::new_inline_buffer()
     } else if let Some(disk) = disk {
-        let length = length.div_ceil(shard_size) * checksum_algo.size() + length;
+        let length = if length > 0 {
+            let length = length as usize;
+            (length.div_ceil(shard_size) * checksum_algo.size() + length) as i64
+        } else {
+            0
+        };
+
         let file = disk.create_file("", volume, path, length).await?;
         CustomWriter::new_tokio_writer(file)
     } else {
diff --git a/ecstore/src/bucket/metadata.rs b/ecstore/src/bucket/metadata.rs
index ac42d9f4..69a6e487 100644
--- a/ecstore/src/bucket/metadata.rs
+++ b/ecstore/src/bucket/metadata.rs
@@ -45,7 +45,7 @@ pub const BUCKET_TARGETS_FILE: &str = "bucket-targets.json";
 pub struct BucketMetadata {
     pub name: String,
     pub created: OffsetDateTime,
-    pub lock_enabled: bool, // 虽然标记为不使用，但可能需要保留
+    pub lock_enabled: bool, // While marked as unused, it may need to be retained
     pub policy_config_json: Vec<u8>,
     pub notification_config_xml: Vec<u8>,
     pub lifecycle_config_xml: Vec<u8>,
diff --git a/ecstore/src/bucket/metadata_sys.rs b/ecstore/src/bucket/metadata_sys.rs
index 42824c37..f06a49fb 100644
--- a/ecstore/src/bucket/metadata_sys.rs
+++ b/ecstore/src/bucket/metadata_sys.rs
@@ -443,7 +443,6 @@ impl BucketMetadataSys {
         let bm = match self.get_config(bucket).await {
             Ok((res, _)) => res,
             Err(err) => {
-                warn!("get_object_lock_config err {:?}", &err);
                 return if err == Error::ConfigNotFound {
                     Err(BucketMetadataError::BucketObjectLockConfigNotFound.into())
                 } else {
diff --git a/ecstore/src/cache_value/metacache_set.rs b/ecstore/src/cache_value/metacache_set.rs
index a99c16cd..7f6e895c 100644
--- a/ecstore/src/cache_value/metacache_set.rs
+++ b/ecstore/src/cache_value/metacache_set.rs
@@ -1,7 +1,7 @@
 use crate::disk::error::DiskError;
 use crate::disk::{self, DiskAPI, DiskStore, WalkDirOptions};
 use futures::future::join_all;
-use rustfs_filemeta::{MetaCacheEntries, MetaCacheEntry, MetacacheReader};
+use rustfs_filemeta::{MetaCacheEntries, MetaCacheEntry, MetacacheReader, is_io_eof};
 use std::{future::Future, pin::Pin, sync::Arc};
 use tokio::{spawn, sync::broadcast::Receiver as B_Receiver};
 use tracing::error;
@@ -50,7 +50,6 @@ impl Clone for ListPathRawOptions {
 }
 
 pub async fn list_path_raw(mut rx: B_Receiver<bool>, opts: ListPathRawOptions) -> disk::error::Result<()> {
-    // println!("list_path_raw {},{}", &opts.bucket, &opts.path);
     if opts.disks.is_empty() {
         return Err(DiskError::other("list_path_raw: 0 drives provided"));
     }
@@ -59,12 +58,13 @@ pub async fn list_path_raw(mut rx: B_Receiver<bool>, opts: ListPathRawOptions) -
     let mut readers = Vec::with_capacity(opts.disks.len());
     let fds = Arc::new(opts.fallback_disks.clone());
 
+    let (cancel_tx, cancel_rx) = tokio::sync::broadcast::channel::<bool>(1);
+
     for disk in opts.disks.iter() {
         let opdisk = disk.clone();
         let opts_clone = opts.clone();
         let fds_clone = fds.clone();
-        // let (m_tx, m_rx) = mpsc::channel::<MetaCacheEntry>(100);
-        // readers.push(m_rx);
+        let mut cancel_rx_clone = cancel_rx.resubscribe();
         let (rd, mut wr) = tokio::io::duplex(64);
         readers.push(MetacacheReader::new(rd));
         jobs.push(spawn(async move {
@@ -92,7 +92,13 @@ pub async fn list_path_raw(mut rx: B_Receiver<bool>, opts: ListPathRawOptions) -
                 need_fallback = true;
             }
 
+            if cancel_rx_clone.try_recv().is_ok() {
+                // warn!("list_path_raw: cancel_rx_clone.try_recv().await.is_ok()");
+                return Ok(());
+            }
+
             while need_fallback {
+                // warn!("list_path_raw: while need_fallback start");
                 let disk = match fds_clone.iter().find(|d| d.is_some()) {
                     Some(d) => {
                         if let Some(disk) = d.clone() {
@@ -130,6 +136,7 @@ pub async fn list_path_raw(mut rx: B_Receiver<bool>, opts: ListPathRawOptions) -
                 }
             }
 
+            // warn!("list_path_raw: while need_fallback done");
             Ok(())
         }));
     }
@@ -143,9 +150,15 @@ pub async fn list_path_raw(mut rx: B_Receiver<bool>, opts: ListPathRawOptions) -
         loop {
             let mut current = MetaCacheEntry::default();
 
+            // warn!(
+            //     "list_path_raw: loop start, bucket: {}, path: {}, current: {:?}",
+            //     opts.bucket, opts.path, &current.name
+            // );
+
             if rx.try_recv().is_ok() {
                 return Err(DiskError::other("canceled"));
             }
+
             let mut top_entries: Vec<Option<MetaCacheEntry>> = vec![None; readers.len()];
 
             let mut at_eof = 0;
@@ -168,31 +181,47 @@ pub async fn list_path_raw(mut rx: B_Receiver<bool>, opts: ListPathRawOptions) -
                         } else {
                             // eof
                             at_eof += 1;
-
+                            // warn!("list_path_raw: peek eof, disk: {}", i);
                             continue;
                         }
                     }
                     Err(err) => {
                         if err == rustfs_filemeta::Error::Unexpected {
                             at_eof += 1;
+                            // warn!("list_path_raw: peek err eof, disk: {}", i);
                             continue;
-                        } else if err == rustfs_filemeta::Error::FileNotFound {
+                        }
+
+                        // warn!("list_path_raw: peek err00, err: {:?}", err);
+
+                        if is_io_eof(&err) {
+                            at_eof += 1;
+                            // warn!("list_path_raw: peek eof, disk: {}", i);
+                            continue;
+                        }
+
+                        if err == rustfs_filemeta::Error::FileNotFound {
                             at_eof += 1;
                             fnf += 1;
+                            // warn!("list_path_raw: peek fnf, disk: {}", i);
                             continue;
                         } else if err == rustfs_filemeta::Error::VolumeNotFound {
                             at_eof += 1;
                             fnf += 1;
                             vnf += 1;
+                            // warn!("list_path_raw: peek vnf, disk: {}", i);
                             continue;
                         } else {
                             has_err += 1;
                             errs[i] = Some(err.into());
+                            // warn!("list_path_raw: peek err, disk: {}", i);
                             continue;
                         }
                     }
                 };
 
+                // warn!("list_path_raw: loop entry: {:?}, disk: {}", &entry.name, i);
+
                 // If no current, add it.
                 if current.name.is_empty() {
                     top_entries[i] = Some(entry.clone());
@@ -228,10 +257,12 @@ pub async fn list_path_raw(mut rx: B_Receiver<bool>, opts: ListPathRawOptions) -
             }
 
             if vnf > 0 && vnf >= (readers.len() - opts.min_disks) {
+                // warn!("list_path_raw: vnf > 0 && vnf >= (readers.len() - opts.min_disks) break");
                 return Err(DiskError::VolumeNotFound);
             }
 
             if fnf > 0 && fnf >= (readers.len() - opts.min_disks) {
+                // warn!("list_path_raw: fnf > 0 && fnf >= (readers.len() - opts.min_disks) break");
                 return Err(DiskError::FileNotFound);
             }
 
@@ -250,6 +281,10 @@ pub async fn list_path_raw(mut rx: B_Receiver<bool>, opts: ListPathRawOptions) -
                     _ => {}
                 });
 
+                error!(
+                    "list_path_raw: has_err > 0 && has_err > opts.disks.len() - opts.min_disks break, err: {:?}",
+                    &combined_err.join(", ")
+                );
                 return Err(DiskError::other(combined_err.join(", ")));
             }
 
@@ -263,6 +298,7 @@ pub async fn list_path_raw(mut rx: B_Receiver<bool>, opts: ListPathRawOptions) -
                     }
                 }
 
+                // error!("list_path_raw: at_eof + has_err == readers.len() break {:?}", &errs);
                 break;
             }
 
@@ -272,12 +308,16 @@ pub async fn list_path_raw(mut rx: B_Receiver<bool>, opts: ListPathRawOptions) -
                 }
 
                 if let Some(agreed_fn) = opts.agreed.as_ref() {
+                    // warn!("list_path_raw: agreed_fn start, current: {:?}", &current.name);
                     agreed_fn(current).await;
+                    // warn!("list_path_raw: agreed_fn done");
                 }
 
                 continue;
             }
 
+            // warn!("list_path_raw: skip start, current: {:?}", &current.name);
+
             for (i, r) in readers.iter_mut().enumerate() {
                 if top_entries[i].is_some() {
                     let _ = r.skip(1).await;
@@ -291,7 +331,12 @@ pub async fn list_path_raw(mut rx: B_Receiver<bool>, opts: ListPathRawOptions) -
         Ok(())
     });
 
-    jobs.push(revjob);
+    if let Err(err) = revjob.await.map_err(std::io::Error::other)? {
+        error!("list_path_raw: revjob err {:?}", err);
+        let _ = cancel_tx.send(true);
+
+        return Err(err);
+    }
 
     let results = join_all(jobs).await;
     for result in results {
@@ -300,5 +345,6 @@ pub async fn list_path_raw(mut rx: B_Receiver<bool>, opts: ListPathRawOptions) -
         }
     }
 
+    // warn!("list_path_raw: done");
     Ok(())
 }
diff --git a/ecstore/src/cmd/bucket_replication.rs b/ecstore/src/cmd/bucket_replication.rs
index 42c46a00..648f97ac 100644
--- a/ecstore/src/cmd/bucket_replication.rs
+++ b/ecstore/src/cmd/bucket_replication.rs
@@ -6,7 +6,7 @@ use crate::bucket::metadata_sys::get_replication_config;
 use crate::bucket::versioning_sys::BucketVersioningSys;
 use crate::error::Error;
 use crate::new_object_layer_fn;
-use crate::peer::RemotePeerS3Client;
+use crate::rpc::RemotePeerS3Client;
 use crate::store;
 use crate::store_api::ObjectIO;
 use crate::store_api::ObjectInfo;
@@ -26,8 +26,6 @@ use futures::stream::FuturesUnordered;
 use http::HeaderMap;
 use http::Method;
 use lazy_static::lazy_static;
-use std::str::FromStr;
-use std::sync::Arc;
 // use std::time::SystemTime;
 use once_cell::sync::Lazy;
 use regex::Regex;
@@ -44,6 +42,8 @@ use std::collections::HashMap;
 use std::collections::HashSet;
 use std::fmt;
 use std::iter::Iterator;
+use std::str::FromStr;
+use std::sync::Arc;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::Ordering;
 use std::vec;
@@ -512,8 +512,8 @@ pub async fn get_heal_replicate_object_info(
 
     let mut result = ReplicateObjectInfo {
         name: oi.name.clone(),
-        size: oi.size as i64,
-        actual_size: asz as i64,
+        size: oi.size,
+        actual_size: asz,
         bucket: oi.bucket.clone(),
         //version_id: oi.version_id.clone(),
         version_id: oi
@@ -815,8 +815,8 @@ impl ReplicationPool {
             vsender.pop(); // Dropping the sender will close the channel
         }
         self.workers_sender = vsender;
-        warn!("self sender size is {:?}", self.workers_sender.len());
-        warn!("self sender size is {:?}", self.workers_sender.len());
+        // warn!("self sender size is {:?}", self.workers_sender.len());
+        // warn!("self sender size is {:?}", self.workers_sender.len());
     }
 
     async fn resize_failed_workers(&self, _count: usize) {
@@ -1759,13 +1759,13 @@ pub async fn schedule_replication(oi: ObjectInfo, o: Arc<store::ECStore>, dsc: R
     let replication_timestamp = Utc::now(); // Placeholder for timestamp parsing
     let replication_state = oi.replication_state();
 
-    let actual_size = oi.actual_size.unwrap_or(0);
+    let actual_size = oi.actual_size;
     //let ssec = oi.user_defined.contains_key("ssec");
     let ssec = false;
 
     let ri = ReplicateObjectInfo {
         name: oi.name,
-        size: oi.size as i64,
+        size: oi.size,
         bucket: oi.bucket,
         version_id: oi
             .version_id
@@ -2019,8 +2019,8 @@ impl ReplicateObjectInfo {
             mod_time: Some(
                 OffsetDateTime::from_unix_timestamp(self.mod_time.timestamp()).unwrap_or_else(|_| OffsetDateTime::now_utc()),
             ),
-            size: self.size as usize,
-            actual_size: Some(self.actual_size as usize),
+            size: self.size,
+            actual_size: self.actual_size,
             is_dir: false,
             user_defined: None, // 可以按需从别处导入
             parity_blocks: 0,
@@ -2319,7 +2319,7 @@ impl ReplicateObjectInfo {
 
         // 设置对象大小
         //rinfo.size = object_info.actual_size.unwrap_or(0);
-        rinfo.size = object_info.actual_size.map_or(0, |v| v as i64);
+        rinfo.size = object_info.actual_size;
         //rinfo.replication_action = object_info.
 
         rinfo.replication_status = ReplicationStatusType::Completed;
diff --git a/ecstore/src/cmd/bucket_targets.rs b/ecstore/src/cmd/bucket_targets.rs
index b343a487..621cd2cf 100644
--- a/ecstore/src/cmd/bucket_targets.rs
+++ b/ecstore/src/cmd/bucket_targets.rs
@@ -4,11 +4,11 @@ use crate::{
     StorageAPI,
     bucket::{metadata_sys, target::BucketTarget},
     endpoints::Node,
-    peer::{PeerS3Client, RemotePeerS3Client},
+    rpc::{PeerS3Client, RemotePeerS3Client},
 };
 use crate::{
     bucket::{self, target::BucketTargets},
-    new_object_layer_fn, peer, store_api,
+    new_object_layer_fn, store_api,
 };
 //use tokio::sync::RwLock;
 use aws_sdk_s3::Client as S3Client;
@@ -24,7 +24,7 @@ use tokio::sync::RwLock;
 
 pub struct TClient {
     pub s3cli: S3Client,
-    pub remote_peer_client: peer::RemotePeerS3Client,
+    pub remote_peer_client: RemotePeerS3Client,
     pub arn: String,
 }
 impl TClient {
@@ -444,7 +444,7 @@ impl BucketTargetSys {
             grid_host: "".to_string(),
         };
 
-        let cli = peer::RemotePeerS3Client::new(Some(node), None);
+        let cli = RemotePeerS3Client::new(Some(node), None);
 
         match cli
             .get_bucket_info(&tgt.target_bucket, &store_api::BucketOptions::default())
diff --git a/ecstore/src/compress.rs b/ecstore/src/compress.rs
new file mode 100644
index 00000000..efbad502
--- /dev/null
+++ b/ecstore/src/compress.rs
@@ -0,0 +1,115 @@
+use rustfs_utils::string::has_pattern;
+use rustfs_utils::string::has_string_suffix_in_slice;
+use std::env;
+use tracing::error;
+
+pub const MIN_COMPRESSIBLE_SIZE: usize = 4096;
+
+// 环境变量名称，用于控制是否启用压缩
+pub const ENV_COMPRESSION_ENABLED: &str = "RUSTFS_COMPRESSION_ENABLED";
+
+// Some standard object extensions which we strictly dis-allow for compression.
+pub const STANDARD_EXCLUDE_COMPRESS_EXTENSIONS: &[&str] = &[
+    ".gz", ".bz2", ".rar", ".zip", ".7z", ".xz", ".mp4", ".mkv", ".mov", ".jpg", ".png", ".gif",
+];
+
+// Some standard content-types which we strictly dis-allow for compression.
+pub const STANDARD_EXCLUDE_COMPRESS_CONTENT_TYPES: &[&str] = &[
+    "video/*",
+    "audio/*",
+    "application/zip",
+    "application/x-gzip",
+    "application/x-zip-compressed",
+    "application/x-compress",
+    "application/x-spoon",
+];
+
+pub fn is_compressible(headers: &http::HeaderMap, object_name: &str) -> bool {
+    // 检查环境变量是否启用压缩，默认关闭
+    if let Ok(compression_enabled) = env::var(ENV_COMPRESSION_ENABLED) {
+        if compression_enabled.to_lowercase() != "true" {
+            error!("Compression is disabled by environment variable");
+            return false;
+        }
+    } else {
+        // 环境变量未设置时默认关闭
+        return false;
+    }
+
+    let content_type = headers.get("content-type").and_then(|s| s.to_str().ok()).unwrap_or("");
+
+    // TODO: crypto request return false
+
+    if has_string_suffix_in_slice(object_name, STANDARD_EXCLUDE_COMPRESS_EXTENSIONS) {
+        error!("object_name: {} is not compressible", object_name);
+        return false;
+    }
+
+    if !content_type.is_empty() && has_pattern(STANDARD_EXCLUDE_COMPRESS_CONTENT_TYPES, content_type) {
+        error!("content_type: {} is not compressible", content_type);
+        return false;
+    }
+    true
+
+    // TODO: check from config
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use temp_env;
+
+    #[test]
+    fn test_is_compressible() {
+        use http::HeaderMap;
+
+        let headers = HeaderMap::new();
+
+        // 测试环境变量控制
+        temp_env::with_var(ENV_COMPRESSION_ENABLED, Some("false"), || {
+            assert!(!is_compressible(&headers, "file.txt"));
+        });
+
+        temp_env::with_var(ENV_COMPRESSION_ENABLED, Some("true"), || {
+            assert!(is_compressible(&headers, "file.txt"));
+        });
+
+        temp_env::with_var_unset(ENV_COMPRESSION_ENABLED, || {
+            assert!(!is_compressible(&headers, "file.txt"));
+        });
+
+        temp_env::with_var(ENV_COMPRESSION_ENABLED, Some("true"), || {
+            let mut headers = HeaderMap::new();
+            // 测试不可压缩的扩展名
+            headers.insert("content-type", "text/plain".parse().unwrap());
+            assert!(!is_compressible(&headers, "file.gz"));
+            assert!(!is_compressible(&headers, "file.zip"));
+            assert!(!is_compressible(&headers, "file.mp4"));
+            assert!(!is_compressible(&headers, "file.jpg"));
+
+            // 测试不可压缩的内容类型
+            headers.insert("content-type", "video/mp4".parse().unwrap());
+            assert!(!is_compressible(&headers, "file.txt"));
+
+            headers.insert("content-type", "audio/mpeg".parse().unwrap());
+            assert!(!is_compressible(&headers, "file.txt"));
+
+            headers.insert("content-type", "application/zip".parse().unwrap());
+            assert!(!is_compressible(&headers, "file.txt"));
+
+            headers.insert("content-type", "application/x-gzip".parse().unwrap());
+            assert!(!is_compressible(&headers, "file.txt"));
+
+            // 测试可压缩的情况
+            headers.insert("content-type", "text/plain".parse().unwrap());
+            assert!(is_compressible(&headers, "file.txt"));
+            assert!(is_compressible(&headers, "file.log"));
+
+            headers.insert("content-type", "text/html".parse().unwrap());
+            assert!(is_compressible(&headers, "file.html"));
+
+            headers.insert("content-type", "application/json".parse().unwrap());
+            assert!(is_compressible(&headers, "file.json"));
+        });
+    }
+}
diff --git a/ecstore/src/config/com.rs b/ecstore/src/config/com.rs
index ac9daf56..7ba9e512 100644
--- a/ecstore/src/config/com.rs
+++ b/ecstore/src/config/com.rs
@@ -41,6 +41,7 @@ pub async fn read_config_with_metadata<S: StorageAPI>(
             if err == Error::FileNotFound || matches!(err, Error::ObjectNotFound(_, _)) {
                 Error::ConfigNotFound
             } else {
+                warn!("read_config_with_metadata: err: {:?}, file: {}", err, file);
                 err
             }
         })?;
@@ -92,9 +93,13 @@ pub async fn delete_config<S: StorageAPI>(api: Arc<S>, file: &str) -> Result<()>
 }
 
 pub async fn save_config_with_opts<S: StorageAPI>(api: Arc<S>, file: &str, data: Vec<u8>, opts: &ObjectOptions) -> Result<()> {
-    let _ = api
+    if let Err(err) = api
         .put_object(RUSTFS_META_BUCKET, file, &mut PutObjReader::from_vec(data), opts)
-        .await?;
+        .await
+    {
+        error!("save_config_with_opts: err: {:?}, file: {}", err, file);
+        return Err(err);
+    }
     Ok(())
 }
 
@@ -110,59 +115,62 @@ async fn new_and_save_server_config<S: StorageAPI>(api: Arc<S>) -> Result<Config
     Ok(cfg)
 }
 
-pub async fn read_config_without_migrate<S: StorageAPI>(api: Arc<S>) -> Result<Config> {
-    let config_file = format!("{}{}{}", CONFIG_PREFIX, SLASH_SEPARATOR, CONFIG_FILE);
-    let data = match read_config(api.clone(), config_file.as_str()).await {
-        Ok(res) => res,
-        Err(err) => {
-            return if err == Error::ConfigNotFound {
-                warn!("config not found, start to init");
-                let cfg = new_and_save_server_config(api).await?;
-                warn!("config init done");
-                Ok(cfg)
-            } else {
-                error!("read config err {:?}", &err);
-                Err(err)
-            };
-        }
-    };
+fn get_config_file() -> String {
+    format!("{}{}{}", CONFIG_PREFIX, SLASH_SEPARATOR, CONFIG_FILE)
+}
 
-    read_server_config(api, data.as_slice()).await
+/// Handle the situation where the configuration file does not exist, create and save a new configuration
+async fn handle_missing_config<S: StorageAPI>(api: Arc<S>, context: &str) -> Result<Config> {
+    warn!("Configuration not found ({}): Start initializing new configuration", context);
+    let cfg = new_and_save_server_config(api).await?;
+    warn!("Configuration initialization complete ({})", context);
+    Ok(cfg)
+}
+
+/// Handle configuration file read errors
+fn handle_config_read_error(err: Error, file_path: &str) -> Result<Config> {
+    error!("Read configuration failed (path: '{}'): {:?}", file_path, err);
+    Err(err)
+}
+
+pub async fn read_config_without_migrate<S: StorageAPI>(api: Arc<S>) -> Result<Config> {
+    let config_file = get_config_file();
+
+    // Try to read the configuration file
+    match read_config(api.clone(), &config_file).await {
+        Ok(data) => read_server_config(api, &data).await,
+        Err(Error::ConfigNotFound) => handle_missing_config(api, "Read the main configuration").await,
+        Err(err) => handle_config_read_error(err, &config_file),
+    }
 }
 
 async fn read_server_config<S: StorageAPI>(api: Arc<S>, data: &[u8]) -> Result<Config> {
-    let cfg = {
-        if data.is_empty() {
-            let config_file = format!("{}{}{}", CONFIG_PREFIX, SLASH_SEPARATOR, CONFIG_FILE);
-            let cfg_data = match read_config(api.clone(), config_file.as_str()).await {
-                Ok(res) => res,
-                Err(err) => {
-                    return if err == Error::ConfigNotFound {
-                        warn!("config not found init start");
-                        let cfg = new_and_save_server_config(api).await?;
-                        warn!("config not found init done");
-                        Ok(cfg)
-                    } else {
-                        error!("read config err {:?}", &err);
-                        Err(err)
-                    };
-                }
-            };
-            // TODO: decrypt
+    // If the provided data is empty, try to read from the file again
+    if data.is_empty() {
+        let config_file = get_config_file();
+        warn!("Received empty configuration data, try to reread from '{}'", config_file);
 
-            Config::unmarshal(cfg_data.as_slice())?
-        } else {
-            Config::unmarshal(data)?
+        // Try to read the configuration again
+        match read_config(api.clone(), &config_file).await {
+            Ok(cfg_data) => {
+                // TODO: decrypt
+                let cfg = Config::unmarshal(&cfg_data)?;
+                return Ok(cfg.merge());
+            }
+            Err(Error::ConfigNotFound) => return handle_missing_config(api, "Read alternate configuration").await,
+            Err(err) => return handle_config_read_error(err, &config_file),
         }
-    };
+    }
 
+    // Process non-empty configuration data
+    let cfg = Config::unmarshal(data)?;
     Ok(cfg.merge())
 }
 
-async fn save_server_config<S: StorageAPI>(api: Arc<S>, cfg: &Config) -> Result<()> {
+pub async fn save_server_config<S: StorageAPI>(api: Arc<S>, cfg: &Config) -> Result<()> {
     let data = cfg.marshal()?;
 
-    let config_file = format!("{}{}{}", CONFIG_PREFIX, SLASH_SEPARATOR, CONFIG_FILE);
+    let config_file = get_config_file();
 
     save_config(api, &config_file, data).await
 }
diff --git a/ecstore/src/config/mod.rs b/ecstore/src/config/mod.rs
index aeb20bec..24e8eb40 100644
--- a/ecstore/src/config/mod.rs
+++ b/ecstore/src/config/mod.rs
@@ -18,6 +18,14 @@ lazy_static! {
     pub static ref GLOBAL_ConfigSys: ConfigSys = ConfigSys::new();
 }
 
+/// Standard config keys and values.
+pub const ENABLE_KEY: &str = "enable";
+pub const COMMENT_KEY: &str = "comment";
+
+/// Enable values
+pub const ENABLE_ON: &str = "on";
+pub const ENABLE_OFF: &str = "off";
+
 pub const ENV_ACCESS_KEY: &str = "RUSTFS_ACCESS_KEY";
 pub const ENV_SECRET_KEY: &str = "RUSTFS_SECRET_KEY";
 pub const ENV_ROOT_USER: &str = "RUSTFS_ROOT_USER";
@@ -56,7 +64,7 @@ pub struct KV {
 }
 
 #[derive(Debug, Deserialize, Serialize, Clone)]
-pub struct KVS(Vec<KV>);
+pub struct KVS(pub Vec<KV>);
 
 impl Default for KVS {
     fn default() -> Self {
@@ -83,7 +91,7 @@ impl KVS {
 }
 
 #[derive(Debug, Clone)]
-pub struct Config(HashMap<String, HashMap<String, KVS>>);
+pub struct Config(pub HashMap<String, HashMap<String, KVS>>);
 
 impl Default for Config {
     fn default() -> Self {
@@ -99,8 +107,8 @@ impl Config {
         cfg
     }
 
-    pub fn get_value(&self, subsys: &str, key: &str) -> Option<KVS> {
-        if let Some(m) = self.0.get(subsys) {
+    pub fn get_value(&self, sub_sys: &str, key: &str) -> Option<KVS> {
+        if let Some(m) = self.0.get(sub_sys) {
             m.get(key).cloned()
         } else {
             None
diff --git a/ecstore/src/config/storageclass.rs b/ecstore/src/config/storageclass.rs
index e0dc6252..0a7a9bab 100644
--- a/ecstore/src/config/storageclass.rs
+++ b/ecstore/src/config/storageclass.rs
@@ -6,7 +6,8 @@ use serde::{Deserialize, Serialize};
 use std::env;
 use tracing::warn;
 
-// default_parity_count 默认配置，根据磁盘总数分配校验磁盘数量
+/// Default parity count for a given drive count
+/// The default configuration allocates the number of check disks based on the total number of disks
 pub fn default_parity_count(drive: usize) -> usize {
     match drive {
         1 => 0,
@@ -112,7 +113,13 @@ impl Config {
         }
     }
 
-    pub fn should_inline(&self, shard_size: usize, versioned: bool) -> bool {
+    pub fn should_inline(&self, shard_size: i64, versioned: bool) -> bool {
+        if shard_size < 0 {
+            return false;
+        }
+
+        let shard_size = shard_size as usize;
+
         let mut inline_block = DEFAULT_INLINE_BLOCK;
         if self.initialized {
             inline_block = self.inline_block;
diff --git a/ecstore/src/disk/error.rs b/ecstore/src/disk/error.rs
index 427a8608..c3dab9a1 100644
--- a/ecstore/src/disk/error.rs
+++ b/ecstore/src/disk/error.rs
@@ -124,7 +124,7 @@ pub enum DiskError {
     #[error("erasure read quorum")]
     ErasureReadQuorum,
 
-    #[error("io error")]
+    #[error("io error {0}")]
     Io(io::Error),
 }
 
diff --git a/ecstore/src/disk/fs.rs b/ecstore/src/disk/fs.rs
index 79378eec..07475e07 100644
--- a/ecstore/src/disk/fs.rs
+++ b/ecstore/src/disk/fs.rs
@@ -109,7 +109,7 @@ pub async fn access(path: impl AsRef<Path>) -> io::Result<()> {
 }
 
 pub fn access_std(path: impl AsRef<Path>) -> io::Result<()> {
-    std::fs::metadata(path)?;
+    tokio::task::block_in_place(|| std::fs::metadata(path))?;
     Ok(())
 }
 
@@ -118,7 +118,7 @@ pub async fn lstat(path: impl AsRef<Path>) -> io::Result<Metadata> {
 }
 
 pub fn lstat_std(path: impl AsRef<Path>) -> io::Result<Metadata> {
-    std::fs::metadata(path)
+    tokio::task::block_in_place(|| std::fs::metadata(path))
 }
 
 pub async fn make_dir_all(path: impl AsRef<Path>) -> io::Result<()> {
@@ -146,21 +146,27 @@ pub async fn remove_all(path: impl AsRef<Path>) -> io::Result<()> {
 
 #[tracing::instrument(level = "debug", skip_all)]
 pub fn remove_std(path: impl AsRef<Path>) -> io::Result<()> {
-    let meta = std::fs::metadata(path.as_ref())?;
-    if meta.is_dir() {
-        std::fs::remove_dir(path.as_ref())
-    } else {
-        std::fs::remove_file(path.as_ref())
-    }
+    let path = path.as_ref();
+    tokio::task::block_in_place(|| {
+        let meta = std::fs::metadata(path)?;
+        if meta.is_dir() {
+            std::fs::remove_dir(path)
+        } else {
+            std::fs::remove_file(path)
+        }
+    })
 }
 
 pub fn remove_all_std(path: impl AsRef<Path>) -> io::Result<()> {
-    let meta = std::fs::metadata(path.as_ref())?;
-    if meta.is_dir() {
-        std::fs::remove_dir_all(path.as_ref())
-    } else {
-        std::fs::remove_file(path.as_ref())
-    }
+    let path = path.as_ref();
+    tokio::task::block_in_place(|| {
+        let meta = std::fs::metadata(path)?;
+        if meta.is_dir() {
+            std::fs::remove_dir_all(path)
+        } else {
+            std::fs::remove_file(path)
+        }
+    })
 }
 
 pub async fn mkdir(path: impl AsRef<Path>) -> io::Result<()> {
@@ -172,7 +178,7 @@ pub async fn rename(from: impl AsRef<Path>, to: impl AsRef<Path>) -> io::Result<
 }
 
 pub fn rename_std(from: impl AsRef<Path>, to: impl AsRef<Path>) -> io::Result<()> {
-    std::fs::rename(from, to)
+    tokio::task::block_in_place(|| std::fs::rename(from, to))
 }
 
 #[tracing::instrument(level = "debug", skip_all)]
diff --git a/ecstore/src/disk/local.rs b/ecstore/src/disk/local.rs
index 3c8cae26..a5d3d053 100644
--- a/ecstore/src/disk/local.rs
+++ b/ecstore/src/disk/local.rs
@@ -38,6 +38,7 @@ use rustfs_utils::path::{
 };
 
 use crate::erasure_coding::bitrot_verify;
+use bytes::Bytes;
 use common::defer;
 use path_absolutize::Absolutize;
 use rustfs_filemeta::{
@@ -67,7 +68,7 @@ use uuid::Uuid;
 #[derive(Debug)]
 pub struct FormatInfo {
     pub id: Option<Uuid>,
-    pub data: Vec<u8>,
+    pub data: Bytes,
     pub file_info: Option<Metadata>,
     pub last_check: Option<OffsetDateTime>,
 }
@@ -82,6 +83,12 @@ impl FormatInfo {
     }
 }
 
+/// A helper enum to handle internal buffer types for writing data.
+pub enum InternalBuf<'a> {
+    Ref(&'a [u8]),
+    Owned(Bytes),
+}
+
 pub struct LocalDisk {
     pub root: PathBuf,
     pub format_path: PathBuf,
@@ -131,7 +138,7 @@ impl LocalDisk {
         let mut format_last_check = None;
 
         if !format_data.is_empty() {
-            let s = format_data.as_slice();
+            let s = format_data.as_ref();
             let fm = FormatV3::try_from(s).map_err(Error::other)?;
             let (set_idx, disk_idx) = fm.find_disk_index_by_disk_id(fm.erasure.this)?;
 
@@ -595,8 +602,14 @@ impl LocalDisk {
 
         let volume_dir = self.get_bucket_path(volume)?;
 
-        self.write_all_private(volume, format!("{}/{}", path, STORAGE_FORMAT_FILE).as_str(), &buf, true, volume_dir)
-            .await?;
+        self.write_all_private(
+            volume,
+            format!("{}/{}", path, STORAGE_FORMAT_FILE).as_str(),
+            buf.into(),
+            true,
+            &volume_dir,
+        )
+        .await?;
 
         Ok(())
     }
@@ -609,13 +622,14 @@ impl LocalDisk {
         let tmp_volume_dir = self.get_bucket_path(super::RUSTFS_META_TMP_BUCKET)?;
         let tmp_file_path = tmp_volume_dir.join(Path::new(Uuid::new_v4().to_string().as_str()));
 
-        self.write_all_internal(&tmp_file_path, buf, sync, tmp_volume_dir).await?;
+        self.write_all_internal(&tmp_file_path, InternalBuf::Ref(buf), sync, &tmp_volume_dir)
+            .await?;
 
         rename_all(tmp_file_path, file_path, volume_dir).await
     }
 
     // write_all_public for trail
-    async fn write_all_public(&self, volume: &str, path: &str, data: Vec<u8>) -> Result<()> {
+    async fn write_all_public(&self, volume: &str, path: &str, data: Bytes) -> Result<()> {
         if volume == RUSTFS_META_BUCKET && path == super::FORMAT_CONFIG_FILE {
             let mut format_info = self.format_info.write().await;
             format_info.data.clone_from(&data);
@@ -623,47 +637,55 @@ impl LocalDisk {
 
         let volume_dir = self.get_bucket_path(volume)?;
 
-        self.write_all_private(volume, path, &data, true, volume_dir).await?;
+        self.write_all_private(volume, path, data, true, &volume_dir).await?;
 
         Ok(())
     }
 
     // write_all_private with check_path_length
     #[tracing::instrument(level = "debug", skip_all)]
-    pub async fn write_all_private(
-        &self,
-        volume: &str,
-        path: &str,
-        buf: &[u8],
-        sync: bool,
-        skip_parent: impl AsRef<Path>,
-    ) -> Result<()> {
+    pub async fn write_all_private(&self, volume: &str, path: &str, buf: Bytes, sync: bool, skip_parent: &Path) -> Result<()> {
         let volume_dir = self.get_bucket_path(volume)?;
         let file_path = volume_dir.join(Path::new(&path));
         check_path_length(file_path.to_string_lossy().as_ref())?;
 
-        self.write_all_internal(file_path, buf, sync, skip_parent).await
+        self.write_all_internal(&file_path, InternalBuf::Owned(buf), sync, skip_parent)
+            .await
     }
     // write_all_internal do write file
     pub async fn write_all_internal(
         &self,
-        file_path: impl AsRef<Path>,
-        data: impl AsRef<[u8]>,
+        file_path: &Path,
+        data: InternalBuf<'_>,
         sync: bool,
-        skip_parent: impl AsRef<Path>,
+        skip_parent: &Path,
     ) -> Result<()> {
         let flags = O_CREATE | O_WRONLY | O_TRUNC;
 
         let mut f = {
             if sync {
                 // TODO: suport sync
-                self.open_file(file_path.as_ref(), flags, skip_parent.as_ref()).await?
+                self.open_file(file_path, flags, skip_parent).await?
             } else {
-                self.open_file(file_path.as_ref(), flags, skip_parent.as_ref()).await?
+                self.open_file(file_path, flags, skip_parent).await?
             }
         };
 
-        f.write_all(data.as_ref()).await.map_err(to_file_error)?;
+        match data {
+            InternalBuf::Ref(buf) => {
+                f.write_all(buf).await.map_err(to_file_error)?;
+            }
+            InternalBuf::Owned(buf) => {
+                // Reduce one copy by using the owned buffer directly.
+                // It may be more efficient for larger writes.
+                let mut f = f.into_std().await;
+                let task = tokio::task::spawn_blocking(move || {
+                    use std::io::Write as _;
+                    f.write_all(buf.as_ref()).map_err(to_file_error)
+                });
+                task.await??;
+            }
+        }
 
         Ok(())
     }
@@ -703,7 +725,7 @@ impl LocalDisk {
         let meta = file.metadata().await.map_err(to_file_error)?;
         let file_size = meta.len() as usize;
 
-        bitrot_verify(Box::new(file), file_size, part_size, algo, sum.to_vec(), shard_size)
+        bitrot_verify(Box::new(file), file_size, part_size, algo, bytes::Bytes::copy_from_slice(sum), shard_size)
             .await
             .map_err(to_file_error)?;
 
@@ -751,7 +773,7 @@ impl LocalDisk {
             Ok(res) => res,
             Err(e) => {
                 if e != DiskError::VolumeNotFound && e != Error::FileNotFound {
-                    info!("scan list_dir {}, err {:?}", &current, &e);
+                    debug!("scan list_dir {}, err {:?}", &current, &e);
                 }
 
                 if opts.report_notfound && e == Error::FileNotFound && current == &opts.base_dir {
@@ -821,13 +843,14 @@ impl LocalDisk {
                 let name = decode_dir_object(format!("{}/{}", &current, &name).as_str());
 
                 out.write_obj(&MetaCacheEntry {
-                    name,
+                    name: name.clone(),
                     metadata,
                     ..Default::default()
                 })
                 .await?;
                 *objs_returned += 1;
 
+                // warn!("scan list_dir {}, write_obj done, name: {:?}", &current, &name);
                 return Ok(());
             }
         }
@@ -848,6 +871,7 @@ impl LocalDisk {
 
         for entry in entries.iter() {
             if opts.limit > 0 && *objs_returned >= opts.limit {
+                // warn!("scan list_dir {}, limit reached 2", &current);
                 return Ok(());
             }
 
@@ -923,6 +947,7 @@ impl LocalDisk {
 
         while let Some(dir) = dir_stack.pop() {
             if opts.limit > 0 && *objs_returned >= opts.limit {
+                // warn!("scan list_dir {}, limit reached 3", &current);
                 return Ok(());
             }
 
@@ -943,6 +968,7 @@ impl LocalDisk {
             }
         }
 
+        // warn!("scan list_dir {}, done", &current);
         Ok(())
     }
 }
@@ -952,13 +978,13 @@ fn is_root_path(path: impl AsRef<Path>) -> bool {
 }
 
 // 过滤 std::io::ErrorKind::NotFound
-pub async fn read_file_exists(path: impl AsRef<Path>) -> Result<(Vec<u8>, Option<Metadata>)> {
+pub async fn read_file_exists(path: impl AsRef<Path>) -> Result<(Bytes, Option<Metadata>)> {
     let p = path.as_ref();
     let (data, meta) = match read_file_all(&p).await {
         Ok((data, meta)) => (data, Some(meta)),
         Err(e) => {
             if e == Error::FileNotFound {
-                (Vec::new(), None)
+                (Bytes::new(), None)
             } else {
                 return Err(e);
             }
@@ -973,13 +999,13 @@ pub async fn read_file_exists(path: impl AsRef<Path>) -> Result<(Vec<u8>, Option
     Ok((data, meta))
 }
 
-pub async fn read_file_all(path: impl AsRef<Path>) -> Result<(Vec<u8>, Metadata)> {
+pub async fn read_file_all(path: impl AsRef<Path>) -> Result<(Bytes, Metadata)> {
     let p = path.as_ref();
     let meta = read_file_metadata(&path).await?;
 
     let data = fs::read(&p).await.map_err(to_file_error)?;
 
-    Ok((data, meta))
+    Ok((data.into(), meta))
 }
 
 pub async fn read_file_metadata(p: impl AsRef<Path>) -> Result<Metadata> {
@@ -1103,7 +1129,7 @@ impl DiskAPI for LocalDisk {
 
         format_info.id = Some(disk_id);
         format_info.file_info = Some(file_meta);
-        format_info.data = b;
+        format_info.data = b.into();
         format_info.last_check = Some(OffsetDateTime::now_utc());
 
         Ok(Some(disk_id))
@@ -1111,7 +1137,7 @@ impl DiskAPI for LocalDisk {
 
     #[tracing::instrument(skip(self))]
     async fn set_disk_id(&self, id: Option<Uuid>) -> Result<()> {
-        // 本地不需要设置
+        // No setup is required locally
         // TODO: add check_id_store
         let mut format_info = self.format_info.write().await;
         format_info.id = id;
@@ -1119,7 +1145,7 @@ impl DiskAPI for LocalDisk {
     }
 
     #[tracing::instrument(skip(self))]
-    async fn read_all(&self, volume: &str, path: &str) -> Result<Vec<u8>> {
+    async fn read_all(&self, volume: &str, path: &str) -> Result<Bytes> {
         if volume == RUSTFS_META_BUCKET && path == super::FORMAT_CONFIG_FILE {
             let format_info = self.format_info.read().await;
             if !format_info.data.is_empty() {
@@ -1134,7 +1160,7 @@ impl DiskAPI for LocalDisk {
     }
 
     #[tracing::instrument(level = "debug", skip_all)]
-    async fn write_all(&self, volume: &str, path: &str, data: Vec<u8>) -> Result<()> {
+    async fn write_all(&self, volume: &str, path: &str, data: Bytes) -> Result<()> {
         self.write_all_public(volume, path, data).await
     }
 
@@ -1179,7 +1205,7 @@ impl DiskAPI for LocalDisk {
             let err = self
                 .bitrot_verify(
                     &part_path,
-                    erasure.shard_file_size(part.size),
+                    erasure.shard_file_size(part.size as i64) as usize,
                     checksum_info.algorithm,
                     &checksum_info.hash,
                     erasure.shard_size(),
@@ -1220,7 +1246,7 @@ impl DiskAPI for LocalDisk {
                         resp.results[i] = CHECK_PART_FILE_NOT_FOUND;
                         continue;
                     }
-                    if (st.len() as usize) < fi.erasure.shard_file_size(part.size) {
+                    if (st.len() as i64) < fi.erasure.shard_file_size(part.size as i64) {
                         resp.results[i] = CHECK_PART_FILE_CORRUPT;
                         continue;
                     }
@@ -1250,7 +1276,7 @@ impl DiskAPI for LocalDisk {
     }
 
     #[tracing::instrument(level = "debug", skip(self))]
-    async fn rename_part(&self, src_volume: &str, src_path: &str, dst_volume: &str, dst_path: &str, meta: Vec<u8>) -> Result<()> {
+    async fn rename_part(&self, src_volume: &str, src_path: &str, dst_volume: &str, dst_path: &str, meta: Bytes) -> Result<()> {
         let src_volume_dir = self.get_bucket_path(src_volume)?;
         let dst_volume_dir = self.get_bucket_path(dst_volume)?;
         if !skip_access_checks(src_volume) {
@@ -1372,9 +1398,7 @@ impl DiskAPI for LocalDisk {
     }
 
     #[tracing::instrument(level = "debug", skip(self))]
-    async fn create_file(&self, origvolume: &str, volume: &str, path: &str, _file_size: usize) -> Result<FileWriter> {
-        // warn!("disk create_file: origvolume: {}, volume: {}, path: {}", origvolume, volume, path);
-
+    async fn create_file(&self, origvolume: &str, volume: &str, path: &str, _file_size: i64) -> Result<FileWriter> {
         if !origvolume.is_empty() {
             let origvolume_dir = self.get_bucket_path(origvolume)?;
             if !skip_access_checks(origvolume) {
@@ -1405,8 +1429,6 @@ impl DiskAPI for LocalDisk {
     #[tracing::instrument(level = "debug", skip(self))]
     // async fn append_file(&self, volume: &str, path: &str, mut r: DuplexStream) -> Result<File> {
     async fn append_file(&self, volume: &str, path: &str) -> Result<FileWriter> {
-        warn!("disk append_file:  volume: {}, path: {}", volume, path);
-
         let volume_dir = self.get_bucket_path(volume)?;
         if !skip_access_checks(volume) {
             access(&volume_dir)
@@ -1471,7 +1493,9 @@ impl DiskAPI for LocalDisk {
             return Err(DiskError::FileCorrupt);
         }
 
-        f.seek(SeekFrom::Start(offset as u64)).await?;
+        if offset > 0 {
+            f.seek(SeekFrom::Start(offset as u64)).await?;
+        }
 
         Ok(Box::new(f))
     }
@@ -1667,7 +1691,7 @@ impl DiskAPI for LocalDisk {
 
         let new_dst_buf = xlmeta.marshal_msg()?;
 
-        self.write_all(src_volume, format!("{}/{}", &src_path, STORAGE_FORMAT_FILE).as_str(), new_dst_buf)
+        self.write_all(src_volume, format!("{}/{}", &src_path, STORAGE_FORMAT_FILE).as_str(), new_dst_buf.into())
             .await?;
         if let Some((src_data_path, dst_data_path)) = has_data_dir_path.as_ref() {
             let no_inline = fi.data.is_none() && fi.size > 0;
@@ -1690,7 +1714,7 @@ impl DiskAPI for LocalDisk {
                     .write_all_private(
                         dst_volume,
                         format!("{}/{}/{}", &dst_path, &old_data_dir.to_string(), STORAGE_FORMAT_FILE).as_str(),
-                        &dst_buf,
+                        dst_buf.into(),
                         true,
                         &skip_parent,
                     )
@@ -1833,11 +1857,11 @@ impl DiskAPI for LocalDisk {
                     }
                 })?;
 
-            if !FileMeta::is_xl2_v1_format(buf.as_slice()) {
+            if !FileMeta::is_xl2_v1_format(buf.as_ref()) {
                 return Err(DiskError::FileVersionNotFound);
             }
 
-            let mut xl_meta = FileMeta::load(buf.as_slice())?;
+            let mut xl_meta = FileMeta::load(buf.as_ref())?;
 
             xl_meta.update_object_version(fi)?;
 
@@ -1869,7 +1893,7 @@ impl DiskAPI for LocalDisk {
 
         let fm_data = meta.marshal_msg()?;
 
-        self.write_all(volume, format!("{}/{}", path, STORAGE_FORMAT_FILE).as_str(), fm_data)
+        self.write_all(volume, format!("{}/{}", path, STORAGE_FORMAT_FILE).as_str(), fm_data.into())
             .await?;
 
         Ok(())
@@ -2043,7 +2067,7 @@ impl DiskAPI for LocalDisk {
                     }
 
                     res.exists = true;
-                    res.data = data;
+                    res.data = data.into();
                     res.mod_time = match meta.modified() {
                         Ok(md) => Some(OffsetDateTime::from(md)),
                         Err(_) => {
@@ -2206,7 +2230,7 @@ impl DiskAPI for LocalDisk {
                     let mut obj_deleted = false;
                     for info in obj_infos.iter() {
                         let done = ScannerMetrics::time(ScannerMetric::ApplyVersion);
-                        let sz: usize;
+                        let sz: i64;
                         (obj_deleted, sz) = item.apply_actions(info, &mut size_s).await;
                         done();
 
@@ -2227,7 +2251,7 @@ impl DiskAPI for LocalDisk {
                             size_s.versions += 1;
                         }
 
-                        size_s.total_size += sz;
+                        size_s.total_size += sz as usize;
 
                         if info.delete_marker {
                             continue;
@@ -2428,8 +2452,8 @@ mod test {
         disk.make_volume("test-volume").await.unwrap();
 
         // Test write and read operations
-        let test_data = vec![1, 2, 3, 4, 5];
-        disk.write_all("test-volume", "test-file.txt", test_data.clone())
+        let test_data: Vec<u8> = vec![1, 2, 3, 4, 5];
+        disk.write_all("test-volume", "test-file.txt", test_data.clone().into())
             .await
             .unwrap();
 
@@ -2554,7 +2578,7 @@ mod test {
         // Valid format info
         let valid_format_info = FormatInfo {
             id: Some(Uuid::new_v4()),
-            data: vec![1, 2, 3],
+            data: vec![1, 2, 3].into(),
             file_info: Some(fs::metadata(".").await.unwrap()),
             last_check: Some(now),
         };
@@ -2563,7 +2587,7 @@ mod test {
         // Invalid format info (missing id)
         let invalid_format_info = FormatInfo {
             id: None,
-            data: vec![1, 2, 3],
+            data: vec![1, 2, 3].into(),
             file_info: Some(fs::metadata(".").await.unwrap()),
             last_check: Some(now),
         };
@@ -2573,7 +2597,7 @@ mod test {
         let old_time = OffsetDateTime::now_utc() - time::Duration::seconds(10);
         let old_format_info = FormatInfo {
             id: Some(Uuid::new_v4()),
-            data: vec![1, 2, 3],
+            data: vec![1, 2, 3].into(),
             file_info: Some(fs::metadata(".").await.unwrap()),
             last_check: Some(old_time),
         };
@@ -2594,7 +2618,7 @@ mod test {
 
         // Test existing file
         let (data, metadata) = read_file_exists(test_file).await.unwrap();
-        assert_eq!(data, b"test content");
+        assert_eq!(data.as_ref(), b"test content");
         assert!(metadata.is_some());
 
         // Clean up
@@ -2611,7 +2635,7 @@ mod test {
 
         // Test reading file
         let (data, metadata) = read_file_all(test_file).await.unwrap();
-        assert_eq!(data, test_content);
+        assert_eq!(data.as_ref(), test_content);
         assert!(metadata.is_file());
         assert_eq!(metadata.len(), test_content.len() as u64);
 
diff --git a/ecstore/src/disk/mod.rs b/ecstore/src/disk/mod.rs
index a6369808..0763de5b 100644
--- a/ecstore/src/disk/mod.rs
+++ b/ecstore/src/disk/mod.rs
@@ -6,7 +6,6 @@ pub mod format;
 pub mod fs;
 pub mod local;
 pub mod os;
-pub mod remote;
 
 pub const RUSTFS_META_BUCKET: &str = ".rustfs.sys";
 pub const RUSTFS_META_MULTIPART_BUCKET: &str = ".rustfs.sys/multipart";
@@ -22,12 +21,13 @@ use crate::heal::{
     data_usage_cache::{DataUsageCache, DataUsageEntry},
     heal_commands::{HealScanMode, HealingTracker},
 };
+use crate::rpc::RemoteDisk;
+use bytes::Bytes;
 use endpoint::Endpoint;
 use error::DiskError;
 use error::{Error, Result};
 use local::LocalDisk;
 use madmin::info_commands::DiskMetrics;
-use remote::RemoteDisk;
 use rustfs_filemeta::{FileInfo, RawFileInfo};
 use serde::{Deserialize, Serialize};
 use std::{fmt::Debug, path::PathBuf, sync::Arc};
@@ -36,7 +36,6 @@ use tokio::{
     io::{AsyncRead, AsyncWrite},
     sync::mpsc::Sender,
 };
-use tracing::warn;
 use uuid::Uuid;
 
 pub type DiskStore = Arc<Disk>;
@@ -303,7 +302,7 @@ impl DiskAPI for Disk {
     }
 
     #[tracing::instrument(skip(self))]
-    async fn create_file(&self, _origvolume: &str, volume: &str, path: &str, _file_size: usize) -> Result<FileWriter> {
+    async fn create_file(&self, _origvolume: &str, volume: &str, path: &str, _file_size: i64) -> Result<FileWriter> {
         match self {
             Disk::Local(local_disk) => local_disk.create_file(_origvolume, volume, path, _file_size).await,
             Disk::Remote(remote_disk) => remote_disk.create_file(_origvolume, volume, path, _file_size).await,
@@ -319,7 +318,7 @@ impl DiskAPI for Disk {
     }
 
     #[tracing::instrument(skip(self))]
-    async fn rename_part(&self, src_volume: &str, src_path: &str, dst_volume: &str, dst_path: &str, meta: Vec<u8>) -> Result<()> {
+    async fn rename_part(&self, src_volume: &str, src_path: &str, dst_volume: &str, dst_path: &str, meta: Bytes) -> Result<()> {
         match self {
             Disk::Local(local_disk) => local_disk.rename_part(src_volume, src_path, dst_volume, dst_path, meta).await,
             Disk::Remote(remote_disk) => {
@@ -363,7 +362,7 @@ impl DiskAPI for Disk {
     }
 
     #[tracing::instrument(skip(self))]
-    async fn write_all(&self, volume: &str, path: &str, data: Vec<u8>) -> Result<()> {
+    async fn write_all(&self, volume: &str, path: &str, data: Bytes) -> Result<()> {
         match self {
             Disk::Local(local_disk) => local_disk.write_all(volume, path, data).await,
             Disk::Remote(remote_disk) => remote_disk.write_all(volume, path, data).await,
@@ -371,7 +370,7 @@ impl DiskAPI for Disk {
     }
 
     #[tracing::instrument(skip(self))]
-    async fn read_all(&self, volume: &str, path: &str) -> Result<Vec<u8>> {
+    async fn read_all(&self, volume: &str, path: &str) -> Result<Bytes> {
         match self {
             Disk::Local(local_disk) => local_disk.read_all(volume, path).await,
             Disk::Remote(remote_disk) => remote_disk.read_all(volume, path).await,
@@ -490,10 +489,10 @@ pub trait DiskAPI: Debug + Send + Sync + 'static {
     async fn read_file(&self, volume: &str, path: &str) -> Result<FileReader>;
     async fn read_file_stream(&self, volume: &str, path: &str, offset: usize, length: usize) -> Result<FileReader>;
     async fn append_file(&self, volume: &str, path: &str) -> Result<FileWriter>;
-    async fn create_file(&self, origvolume: &str, volume: &str, path: &str, file_size: usize) -> Result<FileWriter>;
+    async fn create_file(&self, origvolume: &str, volume: &str, path: &str, file_size: i64) -> Result<FileWriter>;
     // ReadFileStream
     async fn rename_file(&self, src_volume: &str, src_path: &str, dst_volume: &str, dst_path: &str) -> Result<()>;
-    async fn rename_part(&self, src_volume: &str, src_path: &str, dst_volume: &str, dst_path: &str, meta: Vec<u8>) -> Result<()>;
+    async fn rename_part(&self, src_volume: &str, src_path: &str, dst_volume: &str, dst_path: &str, meta: Bytes) -> Result<()>;
     async fn delete(&self, volume: &str, path: &str, opt: DeleteOptions) -> Result<()>;
     // VerifyFile
     async fn verify_file(&self, volume: &str, path: &str, fi: &FileInfo) -> Result<CheckPartsResp>;
@@ -503,8 +502,8 @@ pub trait DiskAPI: Debug + Send + Sync + 'static {
     // ReadParts
     async fn read_multiple(&self, req: ReadMultipleReq) -> Result<Vec<ReadMultipleResp>>;
     // CleanAbandonedData
-    async fn write_all(&self, volume: &str, path: &str, data: Vec<u8>) -> Result<()>;
-    async fn read_all(&self, volume: &str, path: &str) -> Result<Vec<u8>>;
+    async fn write_all(&self, volume: &str, path: &str, data: Bytes) -> Result<()>;
+    async fn read_all(&self, volume: &str, path: &str) -> Result<Bytes>;
     async fn disk_info(&self, opts: &DiskInfoOptions) -> Result<DiskInfo>;
     async fn ns_scanner(
         &self,
diff --git a/ecstore/src/endpoints.rs b/ecstore/src/endpoints.rs
index db390a13..1a4b5fd5 100644
--- a/ecstore/src/endpoints.rs
+++ b/ecstore/src/endpoints.rs
@@ -680,7 +680,7 @@ mod test {
             ),
             (
                 vec!["ftp://server/d1", "http://server/d2", "http://server/d3", "http://server/d4"],
-                Some(Error::other("'ftp://server/d1': io error")),
+                Some(Error::other("'ftp://server/d1': io error invalid URL endpoint format")),
                 10,
             ),
             (
@@ -719,7 +719,13 @@ mod test {
                 (None, Ok(_)) => {}
                 (Some(e), Ok(_)) => panic!("{}: error: expected = {}, got = <nil>", test_case.2, e),
                 (Some(e), Err(e2)) => {
-                    assert_eq!(e.to_string(), e2.to_string(), "{}: error: expected = {}, got = {}", test_case.2, e, e2)
+                    assert!(
+                        e2.to_string().starts_with(&e.to_string()),
+                        "{}: error: expected = {}, got = {}",
+                        test_case.2,
+                        e,
+                        e2
+                    )
                 }
             }
         }
diff --git a/ecstore/src/erasure_coding/bitrot.rs b/ecstore/src/erasure_coding/bitrot.rs
index a53165d7..a020711e 100644
--- a/ecstore/src/erasure_coding/bitrot.rs
+++ b/ecstore/src/erasure_coding/bitrot.rs
@@ -1,6 +1,9 @@
+use bytes::Bytes;
 use pin_project_lite::pin_project;
-use rustfs_utils::{HashAlgorithm, read_full, write_all};
-use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite};
+use rustfs_utils::HashAlgorithm;
+use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
+use tracing::error;
+use uuid::Uuid;
 
 pin_project! {
     /// BitrotReader reads (hash+data) blocks from an async reader and verifies hash integrity.
@@ -11,10 +14,11 @@ pin_project! {
         shard_size: usize,
         buf: Vec<u8>,
         hash_buf: Vec<u8>,
-        hash_read: usize,
-        data_buf: Vec<u8>,
-        data_read: usize,
-        hash_checked: bool,
+        // hash_read: usize,
+        // data_buf: Vec<u8>,
+        // data_read: usize,
+        // hash_checked: bool,
+        id: Uuid,
     }
 }
 
@@ -31,10 +35,11 @@ where
             shard_size,
             buf: Vec::new(),
             hash_buf: vec![0u8; hash_size],
-            hash_read: 0,
-            data_buf: Vec::new(),
-            data_read: 0,
-            hash_checked: false,
+            // hash_read: 0,
+            // data_buf: Vec::new(),
+            // data_read: 0,
+            // hash_checked: false,
+            id: Uuid::new_v4(),
         }
     }
 
@@ -50,30 +55,31 @@ where
 
         let hash_size = self.hash_algo.size();
         // Read hash
-        let mut hash_buf = vec![0u8; hash_size];
+
         if hash_size > 0 {
-            self.inner.read_exact(&mut hash_buf).await?;
+            self.inner.read_exact(&mut self.hash_buf).await.map_err(|e| {
+                error!("bitrot reader read hash error: {}", e);
+                e
+            })?;
         }
 
-        let data_len = read_full(&mut self.inner, out).await?;
-
-        // // Read data
-        // let mut data_len = 0;
-        // while data_len < out.len() {
-        //     let n = self.inner.read(&mut out[data_len..]).await?;
-        //     if n == 0 {
-        //         break;
-        //     }
-        //     data_len += n;
-        //     // Only read up to one shard_size block
-        //     if data_len >= self.shard_size {
-        //         break;
-        //     }
-        // }
+        // Read data
+        let mut data_len = 0;
+        while data_len < out.len() {
+            let n = self.inner.read(&mut out[data_len..]).await.map_err(|e| {
+                error!("bitrot reader read data error: {}", e);
+                e
+            })?;
+            if n == 0 {
+                break;
+            }
+            data_len += n;
+        }
 
         if hash_size > 0 {
             let actual_hash = self.hash_algo.hash_encode(&out[..data_len]);
-            if actual_hash != hash_buf {
+            if actual_hash.as_ref() != self.hash_buf.as_slice() {
+                error!("bitrot reader hash mismatch, id={} data_len={}, out_len={}", self.id, data_len, out.len());
                 return Err(std::io::Error::new(std::io::ErrorKind::InvalidData, "bitrot hash mismatch"));
             }
         }
@@ -139,27 +145,25 @@ where
 
         if hash_algo.size() > 0 {
             let hash = hash_algo.hash_encode(buf);
-            self.buf.extend_from_slice(&hash);
+            self.buf.extend_from_slice(hash.as_ref());
         }
 
         self.buf.extend_from_slice(buf);
 
-        // Write hash+data in one call
-        let mut n = write_all(&mut self.inner, &self.buf).await?;
+        self.inner.write_all(&self.buf).await?;
 
-        if n < hash_algo.size() {
-            return Err(std::io::Error::new(
-                std::io::ErrorKind::WriteZero,
-                "short write: not enough bytes written",
-            ));
-        }
+        // self.inner.flush().await?;
 
-        n -= hash_algo.size();
+        let n = buf.len();
 
         self.buf.clear();
 
         Ok(n)
     }
+
+    pub async fn shutdown(&mut self) -> std::io::Result<()> {
+        self.inner.shutdown().await
+    }
 }
 
 pub fn bitrot_shard_file_size(size: usize, shard_size: usize, algo: HashAlgorithm) -> usize {
@@ -174,7 +178,7 @@ pub async fn bitrot_verify<R: AsyncRead + Unpin + Send>(
     want_size: usize,
     part_size: usize,
     algo: HashAlgorithm,
-    _want: Vec<u8>,
+    _want: Bytes, // FIXME: useless parameter?
     mut shard_size: usize,
 ) -> std::io::Result<()> {
     let mut hash_buf = vec![0; algo.size()];
@@ -196,7 +200,7 @@ pub async fn bitrot_verify<R: AsyncRead + Unpin + Send>(
         let read = r.read_exact(&mut buf).await?;
 
         let actual_hash = algo.hash_encode(&buf);
-        if actual_hash != hash_buf[0..n] {
+        if actual_hash.as_ref() != &hash_buf[0..n] {
             return Err(std::io::Error::other("bitrot hash mismatch"));
         }
 
@@ -329,6 +333,10 @@ impl BitrotWriterWrapper {
         self.bitrot_writer.write(buf).await
     }
 
+    pub async fn shutdown(&mut self) -> std::io::Result<()> {
+        self.bitrot_writer.shutdown().await
+    }
+
     /// Extract the inline buffer data, consuming the wrapper
     pub fn into_inline_data(self) -> Option<Vec<u8>> {
         match self.writer_type {
diff --git a/ecstore/src/erasure_coding/decode.rs b/ecstore/src/erasure_coding/decode.rs
index fb7aa91a..ae00edbd 100644
--- a/ecstore/src/erasure_coding/decode.rs
+++ b/ecstore/src/erasure_coding/decode.rs
@@ -30,7 +30,7 @@ where
     // readers传入前应处理disk错误，确保每个reader达到可用数量的BitrotReader
     pub fn new(readers: Vec<Option<BitrotReader<R>>>, e: Erasure, offset: usize, total_length: usize) -> Self {
         let shard_size = e.shard_size();
-        let shard_file_size = e.shard_file_size(total_length);
+        let shard_file_size = e.shard_file_size(total_length as i64) as usize;
 
         let offset = (offset / e.block_size) * shard_size;
 
@@ -67,36 +67,34 @@ where
         }
 
         // 使用并发读取所有分片
+        let mut read_futs = Vec::with_capacity(self.readers.len());
 
-        let read_futs: Vec<_> = self
-            .readers
-            .iter_mut()
-            .enumerate()
-            .map(|(i, opt_reader)| {
-                if let Some(reader) = opt_reader.as_mut() {
+        for (i, opt_reader) in self.readers.iter_mut().enumerate() {
+            let future = if let Some(reader) = opt_reader.as_mut() {
+                Box::pin(async move {
                     let mut buf = vec![0u8; shard_size];
-                    // 需要move i, buf
-                    Some(async move {
-                        match reader.read(&mut buf).await {
-                            Ok(n) => {
-                                buf.truncate(n);
-                                (i, Ok(buf))
-                            }
-                            Err(e) => (i, Err(Error::from(e))),
+                    match reader.read(&mut buf).await {
+                        Ok(n) => {
+                            buf.truncate(n);
+                            (i, Ok(buf))
                         }
-                    })
-                } else {
-                    None
-                }
-            })
-            .collect();
+                        Err(e) => (i, Err(Error::from(e))),
+                    }
+                }) as std::pin::Pin<Box<dyn std::future::Future<Output = (usize, Result<Vec<u8>, Error>)> + Send>>
+            } else {
+                // reader是None时返回FileNotFound错误
+                Box::pin(async move { (i, Err(Error::FileNotFound)) })
+                    as std::pin::Pin<Box<dyn std::future::Future<Output = (usize, Result<Vec<u8>, Error>)> + Send>>
+            };
+            read_futs.push(future);
+        }
 
-        // 过滤掉None，join_all
-        let mut results = join_all(read_futs.into_iter().flatten()).await;
+        let results = join_all(read_futs).await;
 
         let mut shards: Vec<Option<Vec<u8>>> = vec![None; self.readers.len()];
         let mut errs = vec![None; self.readers.len()];
-        for (i, shard) in results.drain(..) {
+
+        for (i, shard) in results.into_iter() {
             match shard {
                 Ok(data) => {
                     if !data.is_empty() {
@@ -104,7 +102,7 @@ where
                     }
                 }
                 Err(e) => {
-                    error!("Error reading shard {}: {}", i, e);
+                    // error!("Error reading shard {}: {}", i, e);
                     errs[i] = Some(e);
                 }
             }
@@ -142,6 +140,7 @@ where
     W: tokio::io::AsyncWrite + Send + Sync + Unpin,
 {
     if get_data_block_len(en_blocks, data_blocks) < length {
+        error!("write_data_blocks get_data_block_len < length");
         return Err(io::Error::new(ErrorKind::UnexpectedEof, "Not enough data blocks to write"));
     }
 
@@ -150,6 +149,7 @@ where
 
     for block_op in &en_blocks[..data_blocks] {
         if block_op.is_none() {
+            error!("write_data_blocks block_op.is_none()");
             return Err(io::Error::new(ErrorKind::UnexpectedEof, "Missing data block"));
         }
 
@@ -164,7 +164,10 @@ where
         offset = 0;
 
         if write_left < block.len() {
-            writer.write_all(&block_slice[..write_left]).await?;
+            writer.write_all(&block_slice[..write_left]).await.map_err(|e| {
+                error!("write_data_blocks write_all err: {}", e);
+                e
+            })?;
 
             total_written += write_left;
             break;
@@ -172,7 +175,10 @@ where
 
         let n = block_slice.len();
 
-        writer.write_all(block_slice).await?;
+        writer.write_all(block_slice).await.map_err(|e| {
+            error!("write_data_blocks write_all2 err: {}", e);
+            e
+        })?;
 
         write_left -= n;
 
@@ -228,6 +234,7 @@ impl Erasure {
             };
 
             if block_length == 0 {
+                // error!("erasure decode decode block_length == 0");
                 break;
             }
 
@@ -242,12 +249,14 @@ impl Erasure {
             }
 
             if !reader.can_decode(&shards) {
+                error!("erasure decode can_decode errs: {:?}", &errs);
                 ret_err = Some(Error::ErasureReadQuorum.into());
                 break;
             }
 
             // Decode the shards
             if let Err(e) = self.decode_data(&mut shards) {
+                error!("erasure decode decode_data err: {:?}", e);
                 ret_err = Some(e);
                 break;
             }
@@ -255,6 +264,7 @@ impl Erasure {
             let n = match write_data_blocks(writer, &shards, self.data_shards, block_offset, block_length).await {
                 Ok(n) => n,
                 Err(e) => {
+                    error!("erasure decode write_data_blocks err: {:?}", e);
                     ret_err = Some(e);
                     break;
                 }
diff --git a/ecstore/src/erasure_coding/encode.rs b/ecstore/src/erasure_coding/encode.rs
index a8da5a1a..dda42075 100644
--- a/ecstore/src/erasure_coding/encode.rs
+++ b/ecstore/src/erasure_coding/encode.rs
@@ -4,10 +4,13 @@ use crate::disk::error::Error;
 use crate::disk::error_reduce::count_errs;
 use crate::disk::error_reduce::{OBJECT_OP_IGNORED_ERRS, reduce_write_quorum_errs};
 use bytes::Bytes;
+use futures::StreamExt;
+use futures::stream::FuturesUnordered;
 use std::sync::Arc;
 use std::vec;
 use tokio::io::AsyncRead;
 use tokio::sync::mpsc;
+use tracing::error;
 
 pub(crate) struct MultiWriter<'a> {
     writers: &'a mut [Option<BitrotWriterWrapper>],
@@ -25,33 +28,41 @@ impl<'a> MultiWriter<'a> {
         }
     }
 
-    #[allow(clippy::needless_range_loop)]
-    pub async fn write(&mut self, data: Vec<Bytes>) -> std::io::Result<()> {
-        for i in 0..self.writers.len() {
-            if self.errs[i].is_some() {
-                continue; // Skip if we already have an error for this writer
-            }
-
-            let writer_opt = &mut self.writers[i];
-            let shard = &data[i];
-
-            if let Some(writer) = writer_opt {
+    async fn write_shard(writer_opt: &mut Option<BitrotWriterWrapper>, err: &mut Option<Error>, shard: &Bytes) {
+        match writer_opt {
+            Some(writer) => {
                 match writer.write(shard).await {
                     Ok(n) => {
                         if n < shard.len() {
-                            self.errs[i] = Some(Error::ShortWrite);
-                            self.writers[i] = None; // Mark as failed
+                            *err = Some(Error::ShortWrite);
+                            *writer_opt = None; // Mark as failed
                         } else {
-                            self.errs[i] = None;
+                            *err = None;
                         }
                     }
                     Err(e) => {
-                        self.errs[i] = Some(Error::from(e));
+                        *err = Some(Error::from(e));
                     }
                 }
-            } else {
-                self.errs[i] = Some(Error::DiskNotFound);
             }
+            None => {
+                *err = Some(Error::DiskNotFound);
+            }
+        }
+    }
+
+    pub async fn write(&mut self, data: Vec<Bytes>) -> std::io::Result<()> {
+        assert_eq!(data.len(), self.writers.len());
+
+        {
+            let mut futures = FuturesUnordered::new();
+            for ((writer_opt, err), shard) in self.writers.iter_mut().zip(self.errs.iter_mut()).zip(data.iter()) {
+                if err.is_some() {
+                    continue; // Skip if we already have an error for this writer
+                }
+                futures.push(Self::write_shard(writer_opt, err, shard));
+            }
+            while let Some(()) = futures.next().await {}
         }
 
         let nil_count = self.errs.iter().filter(|&e| e.is_none()).count();
@@ -60,6 +71,13 @@ impl<'a> MultiWriter<'a> {
         }
 
         if let Some(write_err) = reduce_write_quorum_errs(&self.errs, OBJECT_OP_IGNORED_ERRS, self.write_quorum) {
+            error!(
+                "reduce_write_quorum_errs: {:?}, offline-disks={}/{}, errs={:?}",
+                write_err,
+                count_errs(&self.errs, &Error::DiskNotFound),
+                self.writers.len(),
+                self.errs
+            );
             return Err(std::io::Error::other(format!(
                 "Failed to write data: {} (offline-disks={}/{})",
                 write_err,
@@ -79,6 +97,13 @@ impl<'a> MultiWriter<'a> {
                 .join(", ")
         )))
     }
+
+    pub async fn _shutdown(&mut self) -> std::io::Result<()> {
+        for writer in self.writers.iter_mut().flatten() {
+            writer.shutdown().await?;
+        }
+        Ok(())
+    }
 }
 
 impl Erasure {
@@ -96,8 +121,8 @@ impl Erasure {
         let task = tokio::spawn(async move {
             let block_size = self.block_size;
             let mut total = 0;
+            let mut buf = vec![0u8; block_size];
             loop {
-                let mut buf = vec![0u8; block_size];
                 match rustfs_utils::read_full(&mut reader, &mut buf).await {
                     Ok(n) if n > 0 => {
                         total += n;
@@ -114,7 +139,6 @@ impl Erasure {
                         return Err(e);
                     }
                 }
-                buf.clear();
             }
 
             Ok((reader, total))
@@ -130,7 +154,7 @@ impl Erasure {
         }
 
         let (reader, total) = task.await??;
-
+        // writers.shutdown().await?;
         Ok((reader, total))
     }
 }
diff --git a/ecstore/src/erasure_coding/erasure.rs b/ecstore/src/erasure_coding/erasure.rs
index 716dff35..89de1224 100644
--- a/ecstore/src/erasure_coding/erasure.rs
+++ b/ecstore/src/erasure_coding/erasure.rs
@@ -1,27 +1,15 @@
-//! Erasure coding implementation supporting multiple Reed-Solomon backends.
+//! Erasure coding implementation using Reed-Solomon SIMD backend.
 //!
-//! This module provides erasure coding functionality with support for two different
-//! Reed-Solomon implementations:
+//! This module provides erasure coding functionality with high-performance SIMD
+//! Reed-Solomon implementation:
 //!
-//! ## Reed-Solomon Implementations
+//! ## Reed-Solomon Implementation
 //!
-//! ### Pure Erasure Mode (Default)
-//! - **Stability**: Pure erasure implementation, mature and well-tested
-//! - **Performance**: Good performance with consistent behavior
-//! - **Compatibility**: Works with any shard size
-//! - **Use case**: Default behavior, recommended for most production use cases
-//!
-//! ### SIMD Mode (`reed-solomon-simd` feature)
+//! ### SIMD Mode (Only)
 //! - **Performance**: Uses SIMD optimization for high-performance encoding/decoding
 //! - **Compatibility**: Works with any shard size through SIMD implementation
 //! - **Reliability**: High-performance SIMD implementation for large data processing
-//! - **Use case**: Use when maximum performance is needed for large data processing
-//!
-//! ## Feature Flags
-//!
-//! - Default: Use pure reed-solomon-erasure implementation (stable and reliable)
-//! - `reed-solomon-simd`: Use SIMD mode for optimal performance
-//! - `reed-solomon-erasure`: Explicitly enable pure erasure mode (same as default)
+//! - **Use case**: Optimized for maximum performance in large data processing scenarios
 //!
 //! ## Example
 //!
@@ -35,8 +23,6 @@
 //! ```
 
 use bytes::{Bytes, BytesMut};
-use reed_solomon_erasure::galois_8::ReedSolomon as ReedSolomonErasure;
-#[cfg(feature = "reed-solomon-simd")]
 use reed_solomon_simd;
 use smallvec::SmallVec;
 use std::io;
@@ -44,38 +30,23 @@ use tokio::io::AsyncRead;
 use tracing::warn;
 use uuid::Uuid;
 
-/// Reed-Solomon encoder variants supporting different implementations.
-#[allow(clippy::large_enum_variant)]
-pub enum ReedSolomonEncoder {
-    /// SIMD mode: High-performance SIMD implementation (when reed-solomon-simd feature is enabled)
-    #[cfg(feature = "reed-solomon-simd")]
-    SIMD {
-        data_shards: usize,
-        parity_shards: usize,
-        // 使用RwLock确保线程安全，实现Send + Sync
-        encoder_cache: std::sync::RwLock<Option<reed_solomon_simd::ReedSolomonEncoder>>,
-        decoder_cache: std::sync::RwLock<Option<reed_solomon_simd::ReedSolomonDecoder>>,
-    },
-    /// Pure erasure mode: default and when reed-solomon-erasure feature is specified
-    Erasure(Box<ReedSolomonErasure>),
+/// Reed-Solomon encoder using SIMD implementation.
+pub struct ReedSolomonEncoder {
+    data_shards: usize,
+    parity_shards: usize,
+    // 使用RwLock确保线程安全，实现Send + Sync
+    encoder_cache: std::sync::RwLock<Option<reed_solomon_simd::ReedSolomonEncoder>>,
+    decoder_cache: std::sync::RwLock<Option<reed_solomon_simd::ReedSolomonDecoder>>,
 }
 
 impl Clone for ReedSolomonEncoder {
     fn clone(&self) -> Self {
-        match self {
-            #[cfg(feature = "reed-solomon-simd")]
-            ReedSolomonEncoder::SIMD {
-                data_shards,
-                parity_shards,
-                ..
-            } => ReedSolomonEncoder::SIMD {
-                data_shards: *data_shards,
-                parity_shards: *parity_shards,
-                // 为新实例创建空的缓存，不共享缓存
-                encoder_cache: std::sync::RwLock::new(None),
-                decoder_cache: std::sync::RwLock::new(None),
-            },
-            ReedSolomonEncoder::Erasure(encoder) => ReedSolomonEncoder::Erasure(encoder.clone()),
+        Self {
+            data_shards: self.data_shards,
+            parity_shards: self.parity_shards,
+            // 为新实例创建空的缓存，不共享缓存
+            encoder_cache: std::sync::RwLock::new(None),
+            decoder_cache: std::sync::RwLock::new(None),
         }
     }
 }
@@ -83,81 +54,50 @@ impl Clone for ReedSolomonEncoder {
 impl ReedSolomonEncoder {
     /// Create a new Reed-Solomon encoder with specified data and parity shards.
     pub fn new(data_shards: usize, parity_shards: usize) -> io::Result<Self> {
-        #[cfg(feature = "reed-solomon-simd")]
-        {
-            // SIMD mode when reed-solomon-simd feature is enabled
-            Ok(ReedSolomonEncoder::SIMD {
-                data_shards,
-                parity_shards,
-                encoder_cache: std::sync::RwLock::new(None),
-                decoder_cache: std::sync::RwLock::new(None),
-            })
-        }
-
-        #[cfg(not(feature = "reed-solomon-simd"))]
-        {
-            // Pure erasure mode when reed-solomon-simd feature is not enabled (default or reed-solomon-erasure)
-            let encoder = ReedSolomonErasure::new(data_shards, parity_shards)
-                .map_err(|e| io::Error::other(format!("Failed to create erasure encoder: {:?}", e)))?;
-            Ok(ReedSolomonEncoder::Erasure(Box::new(encoder)))
-        }
+        Ok(ReedSolomonEncoder {
+            data_shards,
+            parity_shards,
+            encoder_cache: std::sync::RwLock::new(None),
+            decoder_cache: std::sync::RwLock::new(None),
+        })
     }
 
     /// Encode data shards with parity.
     pub fn encode(&self, shards: SmallVec<[&mut [u8]; 16]>) -> io::Result<()> {
-        match self {
-            #[cfg(feature = "reed-solomon-simd")]
-            ReedSolomonEncoder::SIMD {
-                data_shards,
-                parity_shards,
-                encoder_cache,
-                ..
-            } => {
-                let mut shards_vec: Vec<&mut [u8]> = shards.into_vec();
-                if shards_vec.is_empty() {
-                    return Ok(());
-                }
+        let mut shards_vec: Vec<&mut [u8]> = shards.into_vec();
+        if shards_vec.is_empty() {
+            return Ok(());
+        }
 
-                // 使用 SIMD 进行编码
-                let simd_result = self.encode_with_simd(*data_shards, *parity_shards, encoder_cache, &mut shards_vec);
+        // 使用 SIMD 进行编码
+        let simd_result = self.encode_with_simd(&mut shards_vec);
 
-                match simd_result {
-                    Ok(()) => Ok(()),
-                    Err(simd_error) => {
-                        warn!("SIMD encoding failed: {}", simd_error);
-                        Err(simd_error)
-                    }
-                }
+        match simd_result {
+            Ok(()) => Ok(()),
+            Err(simd_error) => {
+                warn!("SIMD encoding failed: {}", simd_error);
+                Err(simd_error)
             }
-            ReedSolomonEncoder::Erasure(encoder) => encoder
-                .encode(shards)
-                .map_err(|e| io::Error::other(format!("Erasure encode error: {:?}", e))),
         }
     }
 
-    #[cfg(feature = "reed-solomon-simd")]
-    fn encode_with_simd(
-        &self,
-        data_shards: usize,
-        parity_shards: usize,
-        encoder_cache: &std::sync::RwLock<Option<reed_solomon_simd::ReedSolomonEncoder>>,
-        shards_vec: &mut [&mut [u8]],
-    ) -> io::Result<()> {
+    fn encode_with_simd(&self, shards_vec: &mut [&mut [u8]]) -> io::Result<()> {
         let shard_len = shards_vec[0].len();
 
         // 获取或创建encoder
         let mut encoder = {
-            let mut cache_guard = encoder_cache
+            let mut cache_guard = self
+                .encoder_cache
                 .write()
                 .map_err(|_| io::Error::other("Failed to acquire encoder cache lock"))?;
 
             match cache_guard.take() {
                 Some(mut cached_encoder) => {
                     // 使用reset方法重置现有encoder以适应新的参数
-                    if let Err(e) = cached_encoder.reset(data_shards, parity_shards, shard_len) {
+                    if let Err(e) = cached_encoder.reset(self.data_shards, self.parity_shards, shard_len) {
                         warn!("Failed to reset SIMD encoder: {:?}, creating new one", e);
                         // 如果reset失败，创建新的encoder
-                        reed_solomon_simd::ReedSolomonEncoder::new(data_shards, parity_shards, shard_len)
+                        reed_solomon_simd::ReedSolomonEncoder::new(self.data_shards, self.parity_shards, shard_len)
                             .map_err(|e| io::Error::other(format!("Failed to create SIMD encoder: {:?}", e)))?
                     } else {
                         cached_encoder
@@ -165,14 +105,14 @@ impl ReedSolomonEncoder {
                 }
                 None => {
                     // 第一次使用，创建新encoder
-                    reed_solomon_simd::ReedSolomonEncoder::new(data_shards, parity_shards, shard_len)
+                    reed_solomon_simd::ReedSolomonEncoder::new(self.data_shards, self.parity_shards, shard_len)
                         .map_err(|e| io::Error::other(format!("Failed to create SIMD encoder: {:?}", e)))?
                 }
             }
         };
 
         // 添加原始shards
-        for (i, shard) in shards_vec.iter().enumerate().take(data_shards) {
+        for (i, shard) in shards_vec.iter().enumerate().take(self.data_shards) {
             encoder
                 .add_original_shard(shard)
                 .map_err(|e| io::Error::other(format!("Failed to add shard {}: {:?}", i, e)))?;
@@ -185,15 +125,16 @@ impl ReedSolomonEncoder {
 
         // 将恢复shards复制到输出缓冲区
         for (i, recovery_shard) in result.recovery_iter().enumerate() {
-            if i + data_shards < shards_vec.len() {
-                shards_vec[i + data_shards].copy_from_slice(recovery_shard);
+            if i + self.data_shards < shards_vec.len() {
+                shards_vec[i + self.data_shards].copy_from_slice(recovery_shard);
             }
         }
 
         // 将encoder放回缓存（在result被drop后encoder自动重置，可以重用）
         drop(result); // 显式drop result，确保encoder被重置
 
-        *encoder_cache
+        *self
+            .encoder_cache
             .write()
             .map_err(|_| io::Error::other("Failed to return encoder to cache"))? = Some(encoder);
 
@@ -202,39 +143,19 @@ impl ReedSolomonEncoder {
 
     /// Reconstruct missing shards.
     pub fn reconstruct(&self, shards: &mut [Option<Vec<u8>>]) -> io::Result<()> {
-        match self {
-            #[cfg(feature = "reed-solomon-simd")]
-            ReedSolomonEncoder::SIMD {
-                data_shards,
-                parity_shards,
-                decoder_cache,
-                ..
-            } => {
-                // 使用 SIMD 进行重构
-                let simd_result = self.reconstruct_with_simd(*data_shards, *parity_shards, decoder_cache, shards);
+        // 使用 SIMD 进行重构
+        let simd_result = self.reconstruct_with_simd(shards);
 
-                match simd_result {
-                    Ok(()) => Ok(()),
-                    Err(simd_error) => {
-                        warn!("SIMD reconstruction failed: {}", simd_error);
-                        Err(simd_error)
-                    }
-                }
+        match simd_result {
+            Ok(()) => Ok(()),
+            Err(simd_error) => {
+                warn!("SIMD reconstruction failed: {}", simd_error);
+                Err(simd_error)
             }
-            ReedSolomonEncoder::Erasure(encoder) => encoder
-                .reconstruct(shards)
-                .map_err(|e| io::Error::other(format!("Erasure reconstruct error: {:?}", e))),
         }
     }
 
-    #[cfg(feature = "reed-solomon-simd")]
-    fn reconstruct_with_simd(
-        &self,
-        data_shards: usize,
-        parity_shards: usize,
-        decoder_cache: &std::sync::RwLock<Option<reed_solomon_simd::ReedSolomonDecoder>>,
-        shards: &mut [Option<Vec<u8>>],
-    ) -> io::Result<()> {
+    fn reconstruct_with_simd(&self, shards: &mut [Option<Vec<u8>>]) -> io::Result<()> {
         // Find a valid shard to determine length
         let shard_len = shards
             .iter()
@@ -243,17 +164,18 @@ impl ReedSolomonEncoder {
 
         // 获取或创建decoder
         let mut decoder = {
-            let mut cache_guard = decoder_cache
+            let mut cache_guard = self
+                .decoder_cache
                 .write()
                 .map_err(|_| io::Error::other("Failed to acquire decoder cache lock"))?;
 
             match cache_guard.take() {
                 Some(mut cached_decoder) => {
                     // 使用reset方法重置现有decoder
-                    if let Err(e) = cached_decoder.reset(data_shards, parity_shards, shard_len) {
+                    if let Err(e) = cached_decoder.reset(self.data_shards, self.parity_shards, shard_len) {
                         warn!("Failed to reset SIMD decoder: {:?}, creating new one", e);
                         // 如果reset失败，创建新的decoder
-                        reed_solomon_simd::ReedSolomonDecoder::new(data_shards, parity_shards, shard_len)
+                        reed_solomon_simd::ReedSolomonDecoder::new(self.data_shards, self.parity_shards, shard_len)
                             .map_err(|e| io::Error::other(format!("Failed to create SIMD decoder: {:?}", e)))?
                     } else {
                         cached_decoder
@@ -261,7 +183,7 @@ impl ReedSolomonEncoder {
                 }
                 None => {
                     // 第一次使用，创建新decoder
-                    reed_solomon_simd::ReedSolomonDecoder::new(data_shards, parity_shards, shard_len)
+                    reed_solomon_simd::ReedSolomonDecoder::new(self.data_shards, self.parity_shards, shard_len)
                         .map_err(|e| io::Error::other(format!("Failed to create SIMD decoder: {:?}", e)))?
                 }
             }
@@ -270,12 +192,12 @@ impl ReedSolomonEncoder {
         // Add available shards (both data and parity)
         for (i, shard_opt) in shards.iter().enumerate() {
             if let Some(shard) = shard_opt {
-                if i < data_shards {
+                if i < self.data_shards {
                     decoder
                         .add_original_shard(i, shard)
                         .map_err(|e| io::Error::other(format!("Failed to add original shard for reconstruction: {:?}", e)))?;
                 } else {
-                    let recovery_idx = i - data_shards;
+                    let recovery_idx = i - self.data_shards;
                     decoder
                         .add_recovery_shard(recovery_idx, shard)
                         .map_err(|e| io::Error::other(format!("Failed to add recovery shard for reconstruction: {:?}", e)))?;
@@ -289,7 +211,7 @@ impl ReedSolomonEncoder {
 
         // Fill in missing data shards from reconstruction result
         for (i, shard_opt) in shards.iter_mut().enumerate() {
-            if shard_opt.is_none() && i < data_shards {
+            if shard_opt.is_none() && i < self.data_shards {
                 for (restored_index, restored_data) in result.restored_original_iter() {
                     if restored_index == i {
                         *shard_opt = Some(restored_data.to_vec());
@@ -302,7 +224,8 @@ impl ReedSolomonEncoder {
         // 将decoder放回缓存（在result被drop后decoder自动重置，可以重用）
         drop(result); // 显式drop result，确保decoder被重置
 
-        *decoder_cache
+        *self
+            .decoder_cache
             .write()
             .map_err(|_| io::Error::other("Failed to return decoder to cache"))? = Some(decoder);
 
@@ -469,22 +392,27 @@ impl Erasure {
     }
     /// Calculate the total erasure file size for a given original size.
     // Returns the final erasure size from the original size
-    pub fn shard_file_size(&self, total_length: usize) -> usize {
+    pub fn shard_file_size(&self, total_length: i64) -> i64 {
         if total_length == 0 {
             return 0;
         }
+        if total_length < 0 {
+            return total_length;
+        }
+
+        let total_length = total_length as usize;
 
         let num_shards = total_length / self.block_size;
         let last_block_size = total_length % self.block_size;
         let last_shard_size = calc_shard_size(last_block_size, self.data_shards);
-        num_shards * self.shard_size() + last_shard_size
+        (num_shards * self.shard_size() + last_shard_size) as i64
     }
 
     /// Calculate the offset in the erasure file where reading begins.
     // Returns the offset in the erasure file where reading begins
     pub fn shard_file_offset(&self, start_offset: usize, length: usize, total_length: usize) -> usize {
         let shard_size = self.shard_size();
-        let shard_file_size = self.shard_file_size(total_length);
+        let shard_file_size = self.shard_file_size(total_length as i64) as usize;
         let end_shard = (start_offset + length) / self.block_size;
         let mut till_offset = end_shard * shard_size + shard_size;
         if till_offset > shard_file_size {
@@ -550,6 +478,13 @@ mod tests {
 
     use super::*;
 
+    #[test]
+    fn test_shard_file_size_cases2() {
+        let erasure = Erasure::new(12, 4, 1024 * 1024);
+
+        assert_eq!(erasure.shard_file_size(1572864), 131074);
+    }
+
     #[test]
     fn test_shard_file_size_cases() {
         let erasure = Erasure::new(4, 2, 8);
@@ -572,25 +507,18 @@ mod tests {
         assert_eq!(erasure.shard_file_size(1248739), 312186); // 1248739/8=156092, last=3, 3 div_ceil 4=1, 156092*2+1=312185
 
         assert_eq!(erasure.shard_file_size(43), 12); // 43/8=5, last=3, 3 div_ceil 4=1, 5*2+1=11
+
+        assert_eq!(erasure.shard_file_size(1572864), 393216); // 43/8=5, last=3, 3 div_ceil 4=1, 5*2+1=11
     }
 
     #[test]
     fn test_encode_decode_roundtrip() {
         let data_shards = 4;
         let parity_shards = 2;
-
-        // Use different block sizes based on feature
-        #[cfg(not(feature = "reed-solomon-simd"))]
-        let block_size = 8; // Pure erasure mode (default)
-        #[cfg(feature = "reed-solomon-simd")]
-        let block_size = 1024; // SIMD mode - SIMD with fallback
-
+        let block_size = 1024; // SIMD mode
         let erasure = Erasure::new(data_shards, parity_shards, block_size);
 
-        // Use different test data based on feature
-        #[cfg(not(feature = "reed-solomon-simd"))]
-        let test_data = b"hello world".to_vec(); // Small data for erasure (default)
-        #[cfg(feature = "reed-solomon-simd")]
+        // Use sufficient test data for SIMD optimization
         let test_data = b"SIMD mode test data for encoding and decoding roundtrip verification with sufficient length to ensure shard size requirements are met for proper SIMD optimization.".repeat(20); // ~3KB for SIMD
 
         let data = &test_data;
@@ -618,13 +546,7 @@ mod tests {
     fn test_encode_decode_large_1m() {
         let data_shards = 4;
         let parity_shards = 2;
-
-        // Use different block sizes based on feature
-        #[cfg(feature = "reed-solomon-simd")]
         let block_size = 512 * 3; // SIMD mode
-        #[cfg(not(feature = "reed-solomon-simd"))]
-        let block_size = 8192; // Pure erasure mode (default)
-
         let erasure = Erasure::new(data_shards, parity_shards, block_size);
 
         // Generate 1MB test data
@@ -672,9 +594,14 @@ mod tests {
 
     #[test]
     fn test_shard_file_offset() {
-        let erasure = Erasure::new(4, 2, 8);
-        let offset = erasure.shard_file_offset(0, 16, 32);
+        let erasure = Erasure::new(8, 8, 1024 * 1024);
+        let offset = erasure.shard_file_offset(0, 86, 86);
+        println!("offset={}", offset);
         assert!(offset > 0);
+
+        let total_length = erasure.shard_file_size(86);
+        println!("total_length={}", total_length);
+        assert!(total_length > 0);
     }
 
     #[tokio::test]
@@ -685,16 +612,10 @@ mod tests {
 
         let data_shards = 4;
         let parity_shards = 2;
-
-        // Use different block sizes based on feature
-        #[cfg(feature = "reed-solomon-simd")]
         let block_size = 1024; // SIMD mode
-        #[cfg(not(feature = "reed-solomon-simd"))]
-        let block_size = 8; // Pure erasure mode (default)
-
         let erasure = Arc::new(Erasure::new(data_shards, parity_shards, block_size));
 
-        // Use test data suitable for both modes
+        // Use test data suitable for SIMD mode
         let data =
             b"Async error test data with sufficient length to meet requirements for proper testing and validation.".repeat(20); // ~2KB
 
@@ -728,13 +649,7 @@ mod tests {
 
         let data_shards = 4;
         let parity_shards = 2;
-
-        // Use different block sizes based on feature
-        #[cfg(feature = "reed-solomon-simd")]
         let block_size = 1024; // SIMD mode
-        #[cfg(not(feature = "reed-solomon-simd"))]
-        let block_size = 8; // Pure erasure mode (default)
-
         let erasure = Arc::new(Erasure::new(data_shards, parity_shards, block_size));
 
         // Use test data that fits in exactly one block to avoid multi-block complexity
@@ -742,8 +657,6 @@ mod tests {
             b"Channel async callback test data with sufficient length to ensure proper operation and validation requirements."
                 .repeat(8); // ~1KB
 
-        // let data = b"callback".to_vec(); // 8 bytes to fit exactly in one 8-byte block
-
         let data_clone = data.clone(); // Clone for later comparison
         let mut reader = Cursor::new(data);
         let (tx, mut rx) = mpsc::channel::<Vec<Bytes>>(8);
@@ -782,8 +695,7 @@ mod tests {
         assert_eq!(&recovered, &data_clone);
     }
 
-    // Tests specifically for SIMD mode
-    #[cfg(feature = "reed-solomon-simd")]
+    // SIMD mode specific tests
     mod simd_tests {
         use super::*;
 
@@ -1152,47 +1064,4 @@ mod tests {
             assert_eq!(&recovered, &data_clone);
         }
     }
-
-    // Comparative tests between different implementations
-    #[cfg(not(feature = "reed-solomon-simd"))]
-    mod comparative_tests {
-        use super::*;
-
-        #[test]
-        fn test_implementation_consistency() {
-            let data_shards = 4;
-            let parity_shards = 2;
-            let block_size = 2048; // Large enough for SIMD requirements
-
-            // Create test data that ensures each shard is >= 512 bytes (SIMD minimum)
-            let test_data = b"This is test data for comparing reed-solomon-simd and reed-solomon-erasure implementations to ensure they produce consistent results when given the same input parameters and data. This data needs to be sufficiently large to meet SIMD requirements.";
-            let data = test_data.repeat(50); // Create much larger data: ~13KB total, ~3.25KB per shard
-
-            // Test with erasure implementation (default)
-            let erasure_erasure = Erasure::new(data_shards, parity_shards, block_size);
-            let erasure_shards = erasure_erasure.encode_data(&data).unwrap();
-
-            // Test data integrity with erasure
-            let mut erasure_shards_opt: Vec<Option<Vec<u8>>> = erasure_shards.iter().map(|shard| Some(shard.to_vec())).collect();
-
-            // Lose some shards
-            erasure_shards_opt[1] = None; // Data shard
-            erasure_shards_opt[4] = None; // Parity shard
-
-            erasure_erasure.decode_data(&mut erasure_shards_opt).unwrap();
-
-            let mut erasure_recovered = Vec::new();
-            for shard in erasure_shards_opt.iter().take(data_shards) {
-                erasure_recovered.extend_from_slice(shard.as_ref().unwrap());
-            }
-            erasure_recovered.truncate(data.len());
-
-            // Verify erasure implementation works correctly
-            assert_eq!(&erasure_recovered, &data, "Erasure implementation failed to recover data correctly");
-
-            println!("✅ Both implementations are available and working correctly");
-            println!("✅ Default (reed-solomon-erasure): Data recovery successful");
-            println!("✅ SIMD tests are available as separate test suite");
-        }
-    }
 }
diff --git a/ecstore/src/global.rs b/ecstore/src/global.rs
index 34c6b4ac..dcd260a8 100644
--- a/ecstore/src/global.rs
+++ b/ecstore/src/global.rs
@@ -1,12 +1,3 @@
-use lazy_static::lazy_static;
-use std::{
-    collections::HashMap,
-    sync::{Arc, OnceLock},
-    time::SystemTime,
-};
-use tokio::sync::{OnceCell, RwLock};
-use uuid::Uuid;
-
 use crate::heal::mrf::MRFState;
 use crate::{
     bucket::lifecycle::bucket_lifecycle_ops::LifecycleSys,
@@ -17,6 +8,15 @@ use crate::{
     store::ECStore,
     tier::tier::TierConfigMgr,
 };
+use lazy_static::lazy_static;
+use policy::auth::Credentials;
+use std::{
+    collections::HashMap,
+    sync::{Arc, OnceLock},
+    time::SystemTime,
+};
+use tokio::sync::{OnceCell, RwLock};
+use uuid::Uuid;
 
 pub const DISK_ASSUME_UNKNOWN_SIZE: u64 = 1 << 30;
 pub const DISK_MIN_INODES: u64 = 1000;
@@ -50,6 +50,38 @@ pub static ref GLOBAL_LocalNodeName: String = "127.0.0.1:9000".to_string();
 pub static ref GLOBAL_LocalNodeNameHex: String = rustfs_utils::crypto::hex(GLOBAL_LocalNodeName.as_bytes());
 pub static ref GLOBAL_NodeNamesHex: HashMap<String, ()> = HashMap::new();}
 
+static GLOBAL_ACTIVE_CRED: OnceLock<Credentials> = OnceLock::new();
+
+pub fn init_global_action_cred(ak: Option<String>, sk: Option<String>) {
+    let ak = {
+        if let Some(k) = ak {
+            k
+        } else {
+            rustfs_utils::string::gen_access_key(20).unwrap_or_default()
+        }
+    };
+
+    let sk = {
+        if let Some(k) = sk {
+            k
+        } else {
+            rustfs_utils::string::gen_secret_key(32).unwrap_or_default()
+        }
+    };
+
+    GLOBAL_ACTIVE_CRED
+        .set(Credentials {
+            access_key: ak,
+            secret_key: sk,
+            ..Default::default()
+        })
+        .unwrap();
+}
+
+pub fn get_global_action_cred() -> Option<Credentials> {
+    GLOBAL_ACTIVE_CRED.get().cloned()
+}
+
 /// Get the global rustfs port
 pub fn global_rustfs_port() -> u16 {
     if let Some(p) = GLOBAL_RUSTFS_PORT.get() {
diff --git a/ecstore/src/heal/data_scanner.rs b/ecstore/src/heal/data_scanner.rs
index 80c01021..82de2d2f 100644
--- a/ecstore/src/heal/data_scanner.rs
+++ b/ecstore/src/heal/data_scanner.rs
@@ -63,8 +63,8 @@ use crate::{
         heal_ops::{BG_HEALING_UUID, HealSource},
     },
     new_object_layer_fn,
-    peer::is_reserved_or_invalid_bucket,
     store::ECStore,
+    store_utils::is_reserved_or_invalid_bucket,
 };
 use crate::{disk::DiskAPI, store_api::ObjectInfo};
 use crate::{
@@ -612,7 +612,7 @@ impl ScannerItem {
             cumulative_size += obj_info.size;
         }
 
-        if cumulative_size >= SCANNER_EXCESS_OBJECT_VERSIONS_TOTAL_SIZE.load(Ordering::SeqCst) as usize {
+        if cumulative_size >= SCANNER_EXCESS_OBJECT_VERSIONS_TOTAL_SIZE.load(Ordering::SeqCst) as i64 {
             //todo
         }
 
@@ -718,7 +718,7 @@ impl ScannerItem {
         Ok(object_infos)
     }
 
-    pub async fn apply_actions(&mut self, oi: &ObjectInfo, _size_s: &mut SizeSummary) -> (bool, usize) {
+    pub async fn apply_actions(&mut self, oi: &ObjectInfo, _size_s: &mut SizeSummary) -> (bool, i64) {
         let done = ScannerMetrics::time(ScannerMetric::Ilm);
 
         let (action, size) = self.apply_lifecycle(oi).await;
@@ -807,21 +807,21 @@ impl ScannerItem {
             match tgt_status {
                 ReplicationStatusType::Pending => {
                     tgt_size_s.pending_count += 1;
-                    tgt_size_s.pending_size += oi.size;
+                    tgt_size_s.pending_size += oi.size as usize;
                     size_s.pending_count += 1;
-                    size_s.pending_size += oi.size;
+                    size_s.pending_size += oi.size as usize;
                 }
                 ReplicationStatusType::Failed => {
                     tgt_size_s.failed_count += 1;
-                    tgt_size_s.failed_size += oi.size;
+                    tgt_size_s.failed_size += oi.size as usize;
                     size_s.failed_count += 1;
-                    size_s.failed_size += oi.size;
+                    size_s.failed_size += oi.size as usize;
                 }
                 ReplicationStatusType::Completed | ReplicationStatusType::CompletedLegacy => {
                     tgt_size_s.replicated_count += 1;
-                    tgt_size_s.replicated_size += oi.size;
+                    tgt_size_s.replicated_size += oi.size as usize;
                     size_s.replicated_count += 1;
-                    size_s.replicated_size += oi.size;
+                    size_s.replicated_size += oi.size as usize;
                 }
                 _ => {}
             }
@@ -829,7 +829,7 @@ impl ScannerItem {
 
         if matches!(oi.replication_status, ReplicationStatusType::Replica) {
             size_s.replica_count += 1;
-            size_s.replica_size += oi.size;
+            size_s.replica_size += oi.size as usize;
         }
     }
 }
diff --git a/ecstore/src/heal/heal_commands.rs b/ecstore/src/heal/heal_commands.rs
index daa434a3..7dd798a9 100644
--- a/ecstore/src/heal/heal_commands.rs
+++ b/ecstore/src/heal/heal_commands.rs
@@ -232,7 +232,7 @@ impl HealingTracker {
 
         if let Some(disk) = &self.disk {
             let file_path = Path::new(BUCKET_META_PREFIX).join(HEALING_TRACKER_FILENAME);
-            disk.write_all(RUSTFS_META_BUCKET, file_path.to_str().unwrap(), htracker_bytes)
+            disk.write_all(RUSTFS_META_BUCKET, file_path.to_str().unwrap(), htracker_bytes.into())
                 .await?;
         }
         Ok(())
diff --git a/ecstore/src/lib.rs b/ecstore/src/lib.rs
index 9ca4dd0e..bca6aa68 100644
--- a/ecstore/src/lib.rs
+++ b/ecstore/src/lib.rs
@@ -1,9 +1,12 @@
+extern crate core;
+
 pub mod admin_server_info;
 pub mod bitrot;
 pub mod bucket;
 pub mod cache_value;
 mod chunk_stream;
 pub mod cmd;
+pub mod compress;
 pub mod config;
 pub mod disk;
 pub mod disks_layout;
@@ -14,17 +17,16 @@ pub mod global;
 pub mod heal;
 pub mod metrics_realtime;
 pub mod notification_sys;
-pub mod peer;
-pub mod peer_rest_client;
 pub mod pools;
 pub mod rebalance;
+pub mod rpc;
 pub mod set_disk;
 mod sets;
 pub mod store;
 pub mod store_api;
 mod store_init;
 pub mod store_list_objects;
-mod store_utils;
+pub mod store_utils;
 
 pub mod checksum;
 pub mod client;
diff --git a/ecstore/src/notification_sys.rs b/ecstore/src/notification_sys.rs
index ec71fc63..054c66cb 100644
--- a/ecstore/src/notification_sys.rs
+++ b/ecstore/src/notification_sys.rs
@@ -2,7 +2,7 @@ use crate::StorageAPI;
 use crate::admin_server_info::get_commit_id;
 use crate::error::{Error, Result};
 use crate::global::{GLOBAL_BOOT_TIME, get_global_endpoints};
-use crate::peer_rest_client::PeerRestClient;
+use crate::rpc::PeerRestClient;
 use crate::{endpoints::EndpointServerPools, new_object_layer_fn};
 use futures::future::join_all;
 use lazy_static::lazy_static;
@@ -143,7 +143,11 @@ impl NotificationSys {
     #[tracing::instrument(skip(self))]
     pub async fn load_rebalance_meta(&self, start: bool) {
         let mut futures = Vec::with_capacity(self.peer_clients.len());
-        for client in self.peer_clients.iter().flatten() {
+        for (i, client) in self.peer_clients.iter().flatten().enumerate() {
+            warn!(
+                "notification load_rebalance_meta start: {}, index: {}, client: {:?}",
+                start, i, client.host
+            );
             futures.push(client.load_rebalance_meta(start));
         }
 
@@ -158,11 +162,16 @@ impl NotificationSys {
     }
 
     pub async fn stop_rebalance(&self) {
+        warn!("notification stop_rebalance start");
         let Some(store) = new_object_layer_fn() else {
             error!("stop_rebalance: not init");
             return;
         };
 
+        // warn!("notification stop_rebalance load_rebalance_meta");
+        // self.load_rebalance_meta(false).await;
+        // warn!("notification stop_rebalance load_rebalance_meta done");
+
         let mut futures = Vec::with_capacity(self.peer_clients.len());
         for client in self.peer_clients.iter().flatten() {
             futures.push(client.stop_rebalance());
@@ -175,7 +184,9 @@ impl NotificationSys {
             }
         }
 
+        warn!("notification stop_rebalance stop_rebalance start");
         let _ = store.stop_rebalance().await;
+        warn!("notification stop_rebalance stop_rebalance done");
     }
 }
 
diff --git a/ecstore/src/pools.rs b/ecstore/src/pools.rs
index 18f05754..2951ef3e 100644
--- a/ecstore/src/pools.rs
+++ b/ecstore/src/pools.rs
@@ -24,7 +24,7 @@ use futures::future::BoxFuture;
 use http::HeaderMap;
 use rmp_serde::{Deserializer, Serializer};
 use rustfs_filemeta::{MetaCacheEntries, MetaCacheEntry, MetadataResolutionParams};
-use rustfs_rio::HashReader;
+use rustfs_rio::{HashReader, WarpReader};
 use rustfs_utils::path::{SLASH_SEPARATOR, encode_dir_object, path_join};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -33,7 +33,7 @@ use std::io::{Cursor, Write};
 use std::path::PathBuf;
 use std::sync::Arc;
 use time::{Duration, OffsetDateTime};
-use tokio::io::AsyncReadExt;
+use tokio::io::{AsyncReadExt, BufReader};
 use tokio::sync::broadcast::Receiver as B_Receiver;
 use tracing::{error, info, warn};
 
@@ -1254,6 +1254,7 @@ impl ECStore {
             }
 
             if let Err(err) = self
+                .clone()
                 .complete_multipart_upload(
                     &bucket,
                     &object_info.name,
@@ -1275,10 +1276,9 @@ impl ECStore {
             return Ok(());
         }
 
-        let mut data = PutObjReader::new(
-            HashReader::new(rd.stream, object_info.size as i64, object_info.size as i64, None, false)?,
-            object_info.size,
-        );
+        let reader = BufReader::new(rd.stream);
+        let hrd = HashReader::new(Box::new(WarpReader::new(reader)), object_info.size, object_info.size, None, false)?;
+        let mut data = PutObjReader::new(hrd);
 
         if let Err(err) = self
             .put_object(
diff --git a/ecstore/src/rebalance.rs b/ecstore/src/rebalance.rs
index 74d33903..e68f448f 100644
--- a/ecstore/src/rebalance.rs
+++ b/ecstore/src/rebalance.rs
@@ -1,7 +1,3 @@
-use std::io::Cursor;
-use std::sync::Arc;
-use std::time::SystemTime;
-
 use crate::StorageAPI;
 use crate::cache_value::metacache_set::{ListPathRawOptions, list_path_raw};
 use crate::config::com::{read_config_with_metadata, save_config_with_opts};
@@ -16,19 +12,21 @@ use crate::store_api::{CompletePart, GetObjectReader, ObjectIO, ObjectOptions, P
 use common::defer;
 use http::HeaderMap;
 use rustfs_filemeta::{FileInfo, MetaCacheEntries, MetaCacheEntry, MetadataResolutionParams};
-use rustfs_rio::HashReader;
+use rustfs_rio::{HashReader, WarpReader};
 use rustfs_utils::path::encode_dir_object;
 use serde::{Deserialize, Serialize};
-use tokio::io::AsyncReadExt;
+use std::io::Cursor;
+use std::sync::Arc;
+use time::OffsetDateTime;
+use tokio::io::{AsyncReadExt, BufReader};
 use tokio::sync::broadcast::{self, Receiver as B_Receiver};
 use tokio::time::{Duration, Instant};
 use tracing::{error, info, warn};
 use uuid::Uuid;
-use workers::workers::Workers;
 
 const REBAL_META_FMT: u16 = 1; // Replace with actual format value
 const REBAL_META_VER: u16 = 1; // Replace with actual version value
-const REBAL_META_NAME: &str = "rebalance_meta";
+const REBAL_META_NAME: &str = "rebalance.bin";
 
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]
 pub struct RebalanceStats {
@@ -64,7 +62,7 @@ impl RebalanceStats {
 
         self.num_versions += 1;
         let on_disk_size = if !fi.deleted {
-            fi.size as i64 * (fi.erasure.data_blocks + fi.erasure.parity_blocks) as i64 / fi.erasure.data_blocks as i64
+            fi.size * (fi.erasure.data_blocks + fi.erasure.parity_blocks) as i64 / fi.erasure.data_blocks as i64
         } else {
             0
         };
@@ -123,9 +121,9 @@ pub enum RebalSaveOpt {
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]
 pub struct RebalanceInfo {
     #[serde(rename = "startTs")]
-    pub start_time: Option<SystemTime>, // Time at which rebalance-start was issued
+    pub start_time: Option<OffsetDateTime>, // Time at which rebalance-start was issued
     #[serde(rename = "stopTs")]
-    pub end_time: Option<SystemTime>, // Time at which rebalance operation completed or rebalance-stop was called
+    pub end_time: Option<OffsetDateTime>, // Time at which rebalance operation completed or rebalance-stop was called
     #[serde(rename = "status")]
     pub status: RebalStatus, // Current state of rebalance operation
 }
@@ -137,14 +135,14 @@ pub struct DiskStat {
     pub available_space: u64,
 }
 
-#[derive(Debug, Default, Serialize, Deserialize)]
+#[derive(Debug, Default, Serialize, Deserialize, Clone)]
 pub struct RebalanceMeta {
     #[serde(skip)]
     pub cancel: Option<broadcast::Sender<bool>>, // To be invoked on rebalance-stop
     #[serde(skip)]
-    pub last_refreshed_at: Option<SystemTime>,
+    pub last_refreshed_at: Option<OffsetDateTime>,
     #[serde(rename = "stopTs")]
-    pub stopped_at: Option<SystemTime>, // Time when rebalance-stop was issued
+    pub stopped_at: Option<OffsetDateTime>, // Time when rebalance-stop was issued
     #[serde(rename = "id")]
     pub id: String, // ID of the ongoing rebalance operation
     #[serde(rename = "pf")]
@@ -164,29 +162,29 @@ impl RebalanceMeta {
     pub async fn load_with_opts<S: StorageAPI>(&mut self, store: Arc<S>, opts: ObjectOptions) -> Result<()> {
         let (data, _) = read_config_with_metadata(store, REBAL_META_NAME, &opts).await?;
         if data.is_empty() {
-            warn!("rebalanceMeta: no data");
+            warn!("rebalanceMeta load_with_opts: no data");
             return Ok(());
         }
         if data.len() <= 4 {
-            return Err(Error::other("rebalanceMeta: no data"));
+            return Err(Error::other("rebalanceMeta load_with_opts: no data"));
         }
 
         // Read header
         match u16::from_le_bytes([data[0], data[1]]) {
             REBAL_META_FMT => {}
-            fmt => return Err(Error::other(format!("rebalanceMeta: unknown format: {}", fmt))),
+            fmt => return Err(Error::other(format!("rebalanceMeta load_with_opts: unknown format: {}", fmt))),
         }
         match u16::from_le_bytes([data[2], data[3]]) {
             REBAL_META_VER => {}
-            ver => return Err(Error::other(format!("rebalanceMeta: unknown version: {}", ver))),
+            ver => return Err(Error::other(format!("rebalanceMeta load_with_opts: unknown version: {}", ver))),
         }
 
         let meta: Self = rmp_serde::from_read(Cursor::new(&data[4..]))?;
         *self = meta;
 
-        self.last_refreshed_at = Some(SystemTime::now());
+        self.last_refreshed_at = Some(OffsetDateTime::now_utc());
 
-        warn!("rebalanceMeta: loaded meta done");
+        warn!("rebalanceMeta load_with_opts: loaded meta done");
         Ok(())
     }
 
@@ -196,6 +194,7 @@ impl RebalanceMeta {
 
     pub async fn save_with_opts<S: StorageAPI>(&self, store: Arc<S>, opts: ObjectOptions) -> Result<()> {
         if self.pool_stats.is_empty() {
+            warn!("rebalanceMeta save_with_opts: no pool stats");
             return Ok(());
         }
 
@@ -218,7 +217,7 @@ impl ECStore {
     #[tracing::instrument(skip_all)]
     pub async fn load_rebalance_meta(&self) -> Result<()> {
         let mut meta = RebalanceMeta::new();
-        warn!("rebalanceMeta: load rebalance meta");
+        warn!("rebalanceMeta: store load rebalance meta");
         match meta.load(self.pools[0].clone()).await {
             Ok(_) => {
                 warn!("rebalanceMeta: rebalance meta loaded0");
@@ -244,7 +243,7 @@ impl ECStore {
                     return Err(err);
                 }
 
-                error!("rebalanceMeta: not found, rebalance not started");
+                warn!("rebalanceMeta: not found, rebalance not started");
             }
         }
 
@@ -255,9 +254,18 @@ impl ECStore {
     pub async fn update_rebalance_stats(&self) -> Result<()> {
         let mut ok = false;
 
+        let pool_stats = {
+            let rebalance_meta = self.rebalance_meta.read().await;
+            rebalance_meta.as_ref().map(|v| v.pool_stats.clone()).unwrap_or_default()
+        };
+
+        warn!("update_rebalance_stats: pool_stats: {:?}", &pool_stats);
+
         for i in 0..self.pools.len() {
-            if self.find_index(i).await.is_none() {
+            if pool_stats.get(i).is_none() {
+                warn!("update_rebalance_stats: pool {} not found", i);
                 let mut rebalance_meta = self.rebalance_meta.write().await;
+                warn!("update_rebalance_stats: pool {} not found, add", i);
                 if let Some(meta) = rebalance_meta.as_mut() {
                     meta.pool_stats.push(RebalanceStats::default());
                 }
@@ -267,23 +275,24 @@ impl ECStore {
         }
 
         if ok {
-            let mut rebalance_meta = self.rebalance_meta.write().await;
-            if let Some(meta) = rebalance_meta.as_mut() {
+            warn!("update_rebalance_stats: save rebalance meta");
+
+            let rebalance_meta = self.rebalance_meta.read().await;
+            if let Some(meta) = rebalance_meta.as_ref() {
                 meta.save(self.pools[0].clone()).await?;
             }
-            drop(rebalance_meta);
         }
 
         Ok(())
     }
 
-    async fn find_index(&self, index: usize) -> Option<usize> {
-        if let Some(meta) = self.rebalance_meta.read().await.as_ref() {
-            return meta.pool_stats.get(index).map(|_v| index);
-        }
+    // async fn find_index(&self, index: usize) -> Option<usize> {
+    //     if let Some(meta) = self.rebalance_meta.read().await.as_ref() {
+    //         return meta.pool_stats.get(index).map(|_v| index);
+    //     }
 
-        None
-    }
+    //     None
+    // }
 
     #[tracing::instrument(skip(self))]
     pub async fn init_rebalance_meta(&self, bucktes: Vec<String>) -> Result<String> {
@@ -310,7 +319,7 @@ impl ECStore {
 
         let mut pool_stats = Vec::with_capacity(self.pools.len());
 
-        let now = SystemTime::now();
+        let now = OffsetDateTime::now_utc();
 
         for disk_stat in disk_stats.iter() {
             let mut pool_stat = RebalanceStats {
@@ -369,20 +378,26 @@ impl ECStore {
 
     #[tracing::instrument(skip(self))]
     pub async fn next_rebal_bucket(&self, pool_index: usize) -> Result<Option<String>> {
+        warn!("next_rebal_bucket: pool_index: {}", pool_index);
         let rebalance_meta = self.rebalance_meta.read().await;
+        warn!("next_rebal_bucket: rebalance_meta: {:?}", rebalance_meta);
         if let Some(meta) = rebalance_meta.as_ref() {
             if let Some(pool_stat) = meta.pool_stats.get(pool_index) {
                 if pool_stat.info.status == RebalStatus::Completed || !pool_stat.participating {
+                    warn!("next_rebal_bucket: pool_index: {} completed or not participating", pool_index);
                     return Ok(None);
                 }
 
                 if pool_stat.buckets.is_empty() {
+                    warn!("next_rebal_bucket: pool_index: {} buckets is empty", pool_index);
                     return Ok(None);
                 }
+                warn!("next_rebal_bucket: pool_index: {} bucket: {}", pool_index, pool_stat.buckets[0]);
                 return Ok(Some(pool_stat.buckets[0].clone()));
             }
         }
 
+        warn!("next_rebal_bucket: pool_index: {} None", pool_index);
         Ok(None)
     }
 
@@ -392,18 +407,28 @@ impl ECStore {
         if let Some(meta) = rebalance_meta.as_mut() {
             if let Some(pool_stat) = meta.pool_stats.get_mut(pool_index) {
                 warn!("bucket_rebalance_done: buckets {:?}", &pool_stat.buckets);
-                if let Some(idx) = pool_stat.buckets.iter().position(|b| b.as_str() == bucket.as_str()) {
-                    warn!("bucket_rebalance_done: bucket {} rebalanced", &bucket);
-                    pool_stat.buckets.remove(idx);
-                    pool_stat.rebalanced_buckets.push(bucket);
 
+                // 使用 retain 来过滤掉要删除的 bucket
+                let mut found = false;
+                pool_stat.buckets.retain(|b| {
+                    if b.as_str() == bucket.as_str() {
+                        found = true;
+                        pool_stat.rebalanced_buckets.push(b.clone());
+                        false // 删除这个元素
+                    } else {
+                        true // 保留这个元素
+                    }
+                });
+
+                if found {
+                    warn!("bucket_rebalance_done: bucket {} rebalanced", &bucket);
                     return Ok(());
                 } else {
                     warn!("bucket_rebalance_done: bucket {} not found", bucket);
                 }
             }
         }
-
+        warn!("bucket_rebalance_done: bucket {} not found", bucket);
         Ok(())
     }
 
@@ -411,18 +436,28 @@ impl ECStore {
         let rebalance_meta = self.rebalance_meta.read().await;
         if let Some(ref meta) = *rebalance_meta {
             if meta.stopped_at.is_some() {
+                warn!("is_rebalance_started: rebalance stopped");
                 return false;
             }
 
+            meta.pool_stats.iter().enumerate().for_each(|(i, v)| {
+                warn!(
+                    "is_rebalance_started: pool_index: {}, participating: {:?}, status: {:?}",
+                    i, v.participating, v.info.status
+                );
+            });
+
             if meta
                 .pool_stats
                 .iter()
                 .any(|v| v.participating && v.info.status != RebalStatus::Completed)
             {
+                warn!("is_rebalance_started: rebalance started");
                 return true;
             }
         }
 
+        warn!("is_rebalance_started: rebalance not started");
         false
     }
 
@@ -462,10 +497,11 @@ impl ECStore {
 
         {
             let mut rebalance_meta = self.rebalance_meta.write().await;
+
             if let Some(meta) = rebalance_meta.as_mut() {
                 meta.cancel = Some(tx)
             } else {
-                error!("start_rebalance: rebalance_meta is None exit");
+                warn!("start_rebalance: rebalance_meta is None exit");
                 return;
             }
 
@@ -474,19 +510,25 @@ impl ECStore {
 
         let participants = {
             if let Some(ref meta) = *self.rebalance_meta.read().await {
-                if meta.stopped_at.is_some() {
-                    warn!("start_rebalance: rebalance already stopped exit");
-                    return;
-                }
+                // if meta.stopped_at.is_some() {
+                //     warn!("start_rebalance: rebalance already stopped exit");
+                //     return;
+                // }
 
                 let mut participants = vec![false; meta.pool_stats.len()];
                 for (i, pool_stat) in meta.pool_stats.iter().enumerate() {
-                    if pool_stat.info.status == RebalStatus::Started {
-                        participants[i] = pool_stat.participating;
+                    warn!("start_rebalance: pool {} status: {:?}", i, pool_stat.info.status);
+                    if pool_stat.info.status != RebalStatus::Started {
+                        warn!("start_rebalance: pool {} not started, skipping", i);
+                        continue;
                     }
+
+                    warn!("start_rebalance: pool {} participating: {:?}", i, pool_stat.participating);
+                    participants[i] = pool_stat.participating;
                 }
                 participants
             } else {
+                warn!("start_rebalance:2  rebalance_meta is None exit");
                 Vec::new()
             }
         };
@@ -497,11 +539,13 @@ impl ECStore {
                 continue;
             }
 
-            if get_global_endpoints()
-                .as_ref()
-                .get(idx)
-                .is_none_or(|v| v.endpoints.as_ref().first().is_none_or(|e| e.is_local))
-            {
+            if !get_global_endpoints().as_ref().get(idx).is_some_and(|v| {
+                warn!("start_rebalance: pool {} endpoints: {:?}", idx, v.endpoints);
+                v.endpoints.as_ref().first().is_some_and(|e| {
+                    warn!("start_rebalance: pool {} endpoint: {:?}, is_local: {}", idx, e, e.is_local);
+                    e.is_local
+                })
+            }) {
                 warn!("start_rebalance: pool {} is not local, skipping", idx);
                 continue;
             }
@@ -522,13 +566,13 @@ impl ECStore {
     }
 
     #[tracing::instrument(skip(self, rx))]
-    async fn rebalance_buckets(self: &Arc<Self>, rx: B_Receiver<bool>, pool_index: usize) -> Result<()> {
+    async fn rebalance_buckets(self: &Arc<Self>, mut rx: B_Receiver<bool>, pool_index: usize) -> Result<()> {
         let (done_tx, mut done_rx) = tokio::sync::mpsc::channel::<Result<()>>(1);
 
         // Save rebalance metadata periodically
         let store = self.clone();
         let save_task = tokio::spawn(async move {
-            let mut timer = tokio::time::interval_at(Instant::now() + Duration::from_secs(10), Duration::from_secs(10));
+            let mut timer = tokio::time::interval_at(Instant::now() + Duration::from_secs(30), Duration::from_secs(10));
             let mut msg: String;
             let mut quit = false;
 
@@ -537,14 +581,15 @@ impl ECStore {
                     //  TODO: cancel rebalance
                     Some(result) = done_rx.recv() => {
                         quit = true;
-                        let now = SystemTime::now();
-
+                        let now = OffsetDateTime::now_utc();
 
                         let state = match result {
                             Ok(_) => {
+                                warn!("rebalance_buckets: completed");
                                 msg = format!("Rebalance completed at {:?}", now);
                                 RebalStatus::Completed},
                             Err(err) => {
+                                warn!("rebalance_buckets: error: {:?}", err);
                                 // TODO: check stop
                                 if err.to_string().contains("canceled") {
                                     msg = format!("Rebalance stopped at {:?}", now);
@@ -557,9 +602,11 @@ impl ECStore {
                         };
 
                         {
+                            warn!("rebalance_buckets: save rebalance meta, pool_index: {}, state: {:?}", pool_index, state);
                             let mut rebalance_meta = store.rebalance_meta.write().await;
 
                             if let Some(rbm) = rebalance_meta.as_mut() {
+                                warn!("rebalance_buckets: save rebalance meta2, pool_index: {}, state: {:?}", pool_index, state);
                                 rbm.pool_stats[pool_index].info.status = state;
                                 rbm.pool_stats[pool_index].info.end_time = Some(now);
                             }
@@ -568,7 +615,7 @@ impl ECStore {
 
                     }
                     _ = timer.tick() => {
-                        let now = SystemTime::now();
+                        let now = OffsetDateTime::now_utc();
                         msg = format!("Saving rebalance metadata at {:?}", now);
                     }
                 }
@@ -576,7 +623,7 @@ impl ECStore {
                 if let Err(err) = store.save_rebalance_stats(pool_index, RebalSaveOpt::Stats).await {
                     error!("{} err: {:?}", msg, err);
                 } else {
-                    info!(msg);
+                    warn!(msg);
                 }
 
                 if quit {
@@ -588,30 +635,41 @@ impl ECStore {
             }
         });
 
-        warn!("Pool {} rebalancing is started", pool_index + 1);
+        warn!("Pool {} rebalancing is started", pool_index);
 
-        while let Some(bucket) = self.next_rebal_bucket(pool_index).await? {
-            warn!("Rebalancing bucket: start {}", bucket);
-
-            if let Err(err) = self.rebalance_bucket(rx.resubscribe(), bucket.clone(), pool_index).await {
-                if err.to_string().contains("not initialized") {
-                    warn!("rebalance_bucket: rebalance not initialized, continue");
-                    continue;
-                }
-                error!("Error rebalancing bucket {}: {:?}", bucket, err);
-                done_tx.send(Err(err)).await.ok();
+        loop {
+            if let Ok(true) = rx.try_recv() {
+                warn!("Pool {} rebalancing is stopped", pool_index);
+                done_tx.send(Err(Error::other("rebalance stopped canceled"))).await.ok();
                 break;
             }
 
-            warn!("Rebalance bucket: done {} ", bucket);
-            self.bucket_rebalance_done(pool_index, bucket).await?;
+            if let Some(bucket) = self.next_rebal_bucket(pool_index).await? {
+                warn!("Rebalancing bucket: start {}", bucket);
+
+                if let Err(err) = self.rebalance_bucket(rx.resubscribe(), bucket.clone(), pool_index).await {
+                    if err.to_string().contains("not initialized") {
+                        warn!("rebalance_bucket: rebalance not initialized, continue");
+                        continue;
+                    }
+                    error!("Error rebalancing bucket {}: {:?}", bucket, err);
+                    done_tx.send(Err(err)).await.ok();
+                    break;
+                }
+
+                warn!("Rebalance bucket: done {} ", bucket);
+                self.bucket_rebalance_done(pool_index, bucket).await?;
+            } else {
+                warn!("Rebalance bucket: no bucket to rebalance");
+                break;
+            }
         }
 
-        warn!("Pool {} rebalancing is done", pool_index + 1);
+        warn!("Pool {} rebalancing is done", pool_index);
 
         done_tx.send(Ok(())).await.ok();
         save_task.await.ok();
-
+        warn!("Pool {} rebalancing is done2", pool_index);
         Ok(())
     }
 
@@ -622,6 +680,7 @@ impl ECStore {
             if let Some(pool_stat) = meta.pool_stats.get_mut(pool_index) {
                 // Check if the pool's rebalance status is already completed
                 if pool_stat.info.status == RebalStatus::Completed {
+                    warn!("check_if_rebalance_done: pool {} is already completed", pool_index);
                     return true;
                 }
 
@@ -631,7 +690,8 @@ impl ECStore {
                 // Mark pool rebalance as done if within 5% of the PercentFreeGoal
                 if (pfi - meta.percent_free_goal).abs() <= 0.05 {
                     pool_stat.info.status = RebalStatus::Completed;
-                    pool_stat.info.end_time = Some(SystemTime::now());
+                    pool_stat.info.end_time = Some(OffsetDateTime::now_utc());
+                    warn!("check_if_rebalance_done: pool {} is completed, pfi: {}", pool_index, pfi);
                     return true;
                 }
             }
@@ -641,24 +701,30 @@ impl ECStore {
     }
 
     #[allow(unused_assignments)]
-    #[tracing::instrument(skip(self, wk, set))]
+    #[tracing::instrument(skip(self, set))]
     async fn rebalance_entry(
-        &self,
+        self: Arc<Self>,
         bucket: String,
         pool_index: usize,
         entry: MetaCacheEntry,
         set: Arc<SetDisks>,
-        wk: Arc<Workers>,
+        // wk: Arc<Workers>,
     ) {
-        defer!(|| async {
-            wk.give().await;
-        });
+        warn!("rebalance_entry: start rebalance_entry");
+
+        // defer!(|| async {
+        //     warn!("rebalance_entry: defer give worker start");
+        //     wk.give().await;
+        //     warn!("rebalance_entry: defer give worker done");
+        // });
 
         if entry.is_dir() {
+            warn!("rebalance_entry: entry is dir, skipping");
             return;
         }
 
         if self.check_if_rebalance_done(pool_index).await {
+            warn!("rebalance_entry: rebalance done, skipping pool {}", pool_index);
             return;
         }
 
@@ -666,6 +732,7 @@ impl ECStore {
             Ok(fivs) => fivs,
             Err(err) => {
                 error!("rebalance_entry Error getting file info versions: {}", err);
+                warn!("rebalance_entry: Error getting file info versions, skipping");
                 return;
             }
         };
@@ -676,7 +743,7 @@ impl ECStore {
         let expired: usize = 0;
         for version in fivs.versions.iter() {
             if version.is_remote() {
-                info!("rebalance_entry Entry {} is remote, skipping", version.name);
+                warn!("rebalance_entry Entry {} is remote, skipping", version.name);
                 continue;
             }
             // TODO: filterLifecycle
@@ -684,7 +751,7 @@ impl ECStore {
             let remaining_versions = fivs.versions.len() - expired;
             if version.deleted && remaining_versions == 1 {
                 rebalanced += 1;
-                info!("rebalance_entry Entry {} is deleted and last version, skipping", version.name);
+                warn!("rebalance_entry Entry {} is deleted and last version, skipping", version.name);
                 continue;
             }
             let version_id = version.version_id.map(|v| v.to_string());
@@ -735,6 +802,7 @@ impl ECStore {
             }
 
             for _i in 0..3 {
+                warn!("rebalance_entry: get_object_reader, bucket: {}, version: {}", &bucket, &version.name);
                 let rd = match set
                     .get_object_reader(
                         bucket.as_str(),
@@ -753,6 +821,10 @@ impl ECStore {
                     Err(err) => {
                         if is_err_object_not_found(&err) || is_err_version_not_found(&err) {
                             ignore = true;
+                            warn!(
+                                "rebalance_entry: get_object_reader, bucket: {}, version: {}, ignore",
+                                &bucket, &version.name
+                            );
                             break;
                         }
 
@@ -762,10 +834,10 @@ impl ECStore {
                     }
                 };
 
-                if let Err(err) = self.rebalance_object(pool_index, bucket.clone(), rd).await {
+                if let Err(err) = self.clone().rebalance_object(pool_index, bucket.clone(), rd).await {
                     if is_err_object_not_found(&err) || is_err_version_not_found(&err) || is_err_data_movement_overwrite(&err) {
                         ignore = true;
-                        info!("rebalance_entry {} Entry {} is already deleted, skipping", &bucket, version.name);
+                        warn!("rebalance_entry {} Entry {} is already deleted, skipping", &bucket, version.name);
                         break;
                     }
 
@@ -780,7 +852,7 @@ impl ECStore {
             }
 
             if ignore {
-                info!("rebalance_entry {} Entry {} is already deleted, skipping", &bucket, version.name);
+                warn!("rebalance_entry {} Entry {} is already deleted, skipping", &bucket, version.name);
                 continue;
             }
 
@@ -812,13 +884,13 @@ impl ECStore {
             {
                 error!("rebalance_entry: delete_object err {:?}", &err);
             } else {
-                info!("rebalance_entry {} Entry {} deleted successfully", &bucket, &entry.name);
+                warn!("rebalance_entry {} Entry {} deleted successfully", &bucket, &entry.name);
             }
         }
     }
 
     #[tracing::instrument(skip(self, rd))]
-    async fn rebalance_object(&self, pool_idx: usize, bucket: String, rd: GetObjectReader) -> Result<()> {
+    async fn rebalance_object(self: Arc<Self>, pool_idx: usize, bucket: String, rd: GetObjectReader) -> Result<()> {
         let object_info = rd.object_info.clone();
 
         // TODO: check : use size or actual_size ?
@@ -897,6 +969,7 @@ impl ECStore {
             }
 
             if let Err(err) = self
+                .clone()
                 .complete_multipart_upload(
                     &bucket,
                     &object_info.name,
@@ -917,8 +990,9 @@ impl ECStore {
             return Ok(());
         }
 
-        let hrd = HashReader::new(rd.stream, object_info.size as i64, object_info.size as i64, None, false)?;
-        let mut data = PutObjReader::new(hrd, object_info.size);
+        let reader = BufReader::new(rd.stream);
+        let hrd = HashReader::new(Box::new(WarpReader::new(reader)), object_info.size, object_info.size, None, false)?;
+        let mut data = PutObjReader::new(hrd);
 
         if let Err(err) = self
             .put_object(
@@ -957,26 +1031,29 @@ impl ECStore {
 
         let pool = self.pools[pool_index].clone();
 
-        let wk = Workers::new(pool.disk_set.len() * 2).map_err(Error::other)?;
+        let mut jobs = Vec::new();
 
+        // let wk = Workers::new(pool.disk_set.len() * 2).map_err(Error::other)?;
+        // wk.clone().take().await;
         for (set_idx, set) in pool.disk_set.iter().enumerate() {
-            wk.clone().take().await;
-
             let rebalance_entry: ListCallback = Arc::new({
                 let this = Arc::clone(self);
                 let bucket = bucket.clone();
-                let wk = wk.clone();
+                // let wk = wk.clone();
                 let set = set.clone();
                 move |entry: MetaCacheEntry| {
                     let this = this.clone();
                     let bucket = bucket.clone();
-                    let wk = wk.clone();
+                    // let wk = wk.clone();
                     let set = set.clone();
                     Box::pin(async move {
-                        wk.take().await;
-                        tokio::spawn(async move {
-                            this.rebalance_entry(bucket, pool_index, entry, set, wk).await;
-                        });
+                        warn!("rebalance_entry: rebalance_entry spawn start");
+                        // wk.take().await;
+                        // tokio::spawn(async move {
+                        warn!("rebalance_entry: rebalance_entry spawn start2");
+                        this.rebalance_entry(bucket, pool_index, entry, set).await;
+                        warn!("rebalance_entry: rebalance_entry spawn done");
+                        // });
                     })
                 }
             });
@@ -984,62 +1061,68 @@ impl ECStore {
             let set = set.clone();
             let rx = rx.resubscribe();
             let bucket = bucket.clone();
-            let wk = wk.clone();
-            tokio::spawn(async move {
+            // let wk = wk.clone();
+
+            let job = tokio::spawn(async move {
                 if let Err(err) = set.list_objects_to_rebalance(rx, bucket, rebalance_entry).await {
                     error!("Rebalance worker {} error: {}", set_idx, err);
                 } else {
                     info!("Rebalance worker {} done", set_idx);
                 }
-                wk.clone().give().await;
+                // wk.clone().give().await;
             });
+
+            jobs.push(job);
         }
 
-        wk.wait().await;
+        // wk.wait().await;
+        for job in jobs {
+            job.await.unwrap();
+        }
+        warn!("rebalance_bucket: rebalance_bucket done");
         Ok(())
     }
 
     #[tracing::instrument(skip(self))]
     pub async fn save_rebalance_stats(&self, pool_idx: usize, opt: RebalSaveOpt) -> Result<()> {
-        // TODO: NSLOOK
-
+        // TODO: lock
         let mut meta = RebalanceMeta::new();
-        meta.load_with_opts(
-            self.pools[0].clone(),
-            ObjectOptions {
-                no_lock: true,
-                ..Default::default()
-            },
-        )
-        .await?;
-
-        if opt == RebalSaveOpt::StoppedAt {
-            meta.stopped_at = Some(SystemTime::now());
-        }
-
-        let mut rebalance_meta = self.rebalance_meta.write().await;
-
-        if let Some(rb) = rebalance_meta.as_mut() {
-            if opt == RebalSaveOpt::Stats {
-                meta.pool_stats[pool_idx] = rb.pool_stats[pool_idx].clone();
+        if let Err(err) = meta.load(self.pools[0].clone()).await {
+            if err != Error::ConfigNotFound {
+                warn!("save_rebalance_stats: load err: {:?}", err);
+                return Err(err);
             }
-
-            *rb = meta;
-        } else {
-            *rebalance_meta = Some(meta);
         }
 
-        if let Some(meta) = rebalance_meta.as_mut() {
-            meta.save_with_opts(
-                self.pools[0].clone(),
-                ObjectOptions {
-                    no_lock: true,
-                    ..Default::default()
-                },
-            )
-            .await?;
+        match opt {
+            RebalSaveOpt::Stats => {
+                {
+                    let mut rebalance_meta = self.rebalance_meta.write().await;
+                    if let Some(rbm) = rebalance_meta.as_mut() {
+                        meta.pool_stats[pool_idx] = rbm.pool_stats[pool_idx].clone();
+                    }
+                }
+
+                if let Some(pool_stat) = meta.pool_stats.get_mut(pool_idx) {
+                    pool_stat.info.end_time = Some(OffsetDateTime::now_utc());
+                }
+            }
+            RebalSaveOpt::StoppedAt => {
+                meta.stopped_at = Some(OffsetDateTime::now_utc());
+            }
         }
 
+        {
+            let mut rebalance_meta = self.rebalance_meta.write().await;
+            *rebalance_meta = Some(meta.clone());
+        }
+
+        warn!(
+            "save_rebalance_stats: save rebalance meta, pool_idx: {}, opt: {:?}, meta: {:?}",
+            pool_idx, opt, meta
+        );
+        meta.save(self.pools[0].clone()).await?;
+
         Ok(())
     }
 }
@@ -1052,12 +1135,15 @@ impl SetDisks {
         bucket: String,
         cb: ListCallback,
     ) -> Result<()> {
+        warn!("list_objects_to_rebalance: start list_objects_to_rebalance");
         // Placeholder for actual object listing logic
         let (disks, _) = self.get_online_disks_with_healing(false).await;
         if disks.is_empty() {
+            warn!("list_objects_to_rebalance: no disk available");
             return Err(Error::other("errNoDiskAvailable"));
         }
 
+        warn!("list_objects_to_rebalance: get online disks with healing");
         let listing_quorum = self.set_drive_count.div_ceil(2);
 
         let resolver = MetadataResolutionParams {
@@ -1075,7 +1161,10 @@ impl SetDisks {
                 bucket: bucket.clone(),
                 recursice: true,
                 min_disks: listing_quorum,
-                agreed: Some(Box::new(move |entry: MetaCacheEntry| Box::pin(cb1(entry)))),
+                agreed: Some(Box::new(move |entry: MetaCacheEntry| {
+                    warn!("list_objects_to_rebalance: agreed: {:?}", &entry.name);
+                    Box::pin(cb1(entry))
+                })),
                 partial: Some(Box::new(move |entries: MetaCacheEntries, _: &[Option<DiskError>]| {
                     // let cb = cb.clone();
                     let resolver = resolver.clone();
@@ -1083,11 +1172,11 @@ impl SetDisks {
 
                     match entries.resolve(resolver) {
                         Some(entry) => {
-                            warn!("rebalance: list_objects_to_decommission get {}", &entry.name);
+                            warn!("list_objects_to_rebalance: list_objects_to_decommission get {}", &entry.name);
                             Box::pin(async move { cb(entry).await })
                         }
                         None => {
-                            warn!("rebalance: list_objects_to_decommission get none");
+                            warn!("list_objects_to_rebalance: list_objects_to_decommission get none");
                             Box::pin(async {})
                         }
                     }
@@ -1097,6 +1186,7 @@ impl SetDisks {
         )
         .await?;
 
+        warn!("list_objects_to_rebalance: list_objects_to_rebalance done");
         Ok(())
     }
 }
diff --git a/ecstore/src/rpc/http_auth.rs b/ecstore/src/rpc/http_auth.rs
new file mode 100644
index 00000000..1268932d
--- /dev/null
+++ b/ecstore/src/rpc/http_auth.rs
@@ -0,0 +1,375 @@
+use crate::global::get_global_action_cred;
+use base64::Engine as _;
+use base64::engine::general_purpose;
+use hmac::{Hmac, Mac};
+use http::HeaderMap;
+use http::HeaderValue;
+use http::Method;
+use http::Uri;
+use sha2::Sha256;
+use time::OffsetDateTime;
+use tracing::error;
+
+type HmacSha256 = Hmac<Sha256>;
+
+const SIGNATURE_HEADER: &str = "x-rustfs-signature";
+const TIMESTAMP_HEADER: &str = "x-rustfs-timestamp";
+const SIGNATURE_VALID_DURATION: i64 = 300; // 5 minutes
+
+/// Get the shared secret for HMAC signing
+fn get_shared_secret() -> String {
+    if let Some(cred) = get_global_action_cred() {
+        cred.secret_key
+    } else {
+        // Fallback to environment variable if global credentials are not available
+        std::env::var("RUSTFS_RPC_SECRET").unwrap_or_else(|_| "rustfs-default-secret".to_string())
+    }
+}
+
+/// Generate HMAC-SHA256 signature for the given data
+fn generate_signature(secret: &str, url: &str, method: &Method, timestamp: i64) -> String {
+    let uri: Uri = url.parse().expect("Invalid URL");
+
+    let path_and_query = uri.path_and_query().unwrap();
+
+    let url = path_and_query.to_string();
+
+    let data = format!("{}|{}|{}", url, method, timestamp);
+    let mut mac = HmacSha256::new_from_slice(secret.as_bytes()).expect("HMAC can take key of any size");
+    mac.update(data.as_bytes());
+    let result = mac.finalize();
+    general_purpose::STANDARD.encode(result.into_bytes())
+}
+
+/// Build headers with authentication signature
+pub fn build_auth_headers(url: &str, method: &Method, headers: &mut HeaderMap) {
+    let secret = get_shared_secret();
+    let timestamp = OffsetDateTime::now_utc().unix_timestamp();
+
+    let signature = generate_signature(&secret, url, method, timestamp);
+
+    headers.insert(SIGNATURE_HEADER, HeaderValue::from_str(&signature).unwrap());
+    headers.insert(TIMESTAMP_HEADER, HeaderValue::from_str(&timestamp.to_string()).unwrap());
+}
+
+/// Verify the request signature for RPC requests
+pub fn verify_rpc_signature(url: &str, method: &Method, headers: &HeaderMap) -> std::io::Result<()> {
+    let secret = get_shared_secret();
+
+    // Get signature from header
+    let signature = headers
+        .get(SIGNATURE_HEADER)
+        .and_then(|v| v.to_str().ok())
+        .ok_or_else(|| std::io::Error::other("Missing signature header"))?;
+
+    // Get timestamp from header
+    let timestamp_str = headers
+        .get(TIMESTAMP_HEADER)
+        .and_then(|v| v.to_str().ok())
+        .ok_or_else(|| std::io::Error::other("Missing timestamp header"))?;
+
+    let timestamp: i64 = timestamp_str
+        .parse()
+        .map_err(|_| std::io::Error::other("Invalid timestamp format"))?;
+
+    // Check timestamp validity (prevent replay attacks)
+    let current_time = OffsetDateTime::now_utc().unix_timestamp();
+
+    if current_time.saturating_sub(timestamp) > SIGNATURE_VALID_DURATION {
+        return Err(std::io::Error::other("Request timestamp expired"));
+    }
+
+    // Generate expected signature
+
+    let expected_signature = generate_signature(&secret, url, method, timestamp);
+
+    // Compare signatures
+    if signature != expected_signature {
+        error!(
+            "verify_rpc_signature: Invalid signature: secret {}, url {}, method {}, timestamp {}, signature {}, expected_signature {}",
+            secret, url, method, timestamp, signature, expected_signature
+        );
+
+        return Err(std::io::Error::other("Invalid signature"));
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use http::{HeaderMap, Method};
+    use time::OffsetDateTime;
+
+    #[test]
+    fn test_get_shared_secret() {
+        let secret = get_shared_secret();
+        assert!(!secret.is_empty(), "Secret should not be empty");
+
+        let url = "http://node1:7000/rustfs/rpc/read_file_stream?disk=http%3A%2F%2Fnode1%3A7000%2Fdata%2Frustfs3&volume=.rustfs.sys&path=pool.bin%2Fdd0fd773-a962-4265-b543-783ce83953e9%2Fpart.1&offset=0&length=44";
+        let method = Method::GET;
+        let mut headers = HeaderMap::new();
+
+        build_auth_headers(url, &method, &mut headers);
+
+        let url = "/rustfs/rpc/read_file_stream?disk=http%3A%2F%2Fnode1%3A7000%2Fdata%2Frustfs3&volume=.rustfs.sys&path=pool.bin%2Fdd0fd773-a962-4265-b543-783ce83953e9%2Fpart.1&offset=0&length=44";
+
+        let result = verify_rpc_signature(url, &method, &headers);
+        assert!(result.is_ok(), "Valid signature should pass verification");
+    }
+
+    #[test]
+    fn test_generate_signature_deterministic() {
+        let secret = "test-secret";
+        let url = "http://example.com/api/test";
+        let method = Method::GET;
+        let timestamp = 1640995200; // Fixed timestamp
+
+        let signature1 = generate_signature(secret, url, &method, timestamp);
+        let signature2 = generate_signature(secret, url, &method, timestamp);
+
+        assert_eq!(signature1, signature2, "Same inputs should produce same signature");
+        assert!(!signature1.is_empty(), "Signature should not be empty");
+    }
+
+    #[test]
+    fn test_generate_signature_different_inputs() {
+        let secret = "test-secret";
+        let url = "http://example.com/api/test";
+        let method = Method::GET;
+        let timestamp = 1640995200;
+
+        let signature1 = generate_signature(secret, url, &method, timestamp);
+        let signature2 = generate_signature(secret, "http://different.com/api/test2", &method, timestamp);
+        let signature3 = generate_signature(secret, url, &Method::POST, timestamp);
+        let signature4 = generate_signature(secret, url, &method, timestamp + 1);
+
+        assert_ne!(signature1, signature2, "Different URLs should produce different signatures");
+        assert_ne!(signature1, signature3, "Different methods should produce different signatures");
+        assert_ne!(signature1, signature4, "Different timestamps should produce different signatures");
+    }
+
+    #[test]
+    fn test_build_auth_headers() {
+        let url = "http://example.com/api/test";
+        let method = Method::POST;
+        let mut headers = HeaderMap::new();
+
+        build_auth_headers(url, &method, &mut headers);
+
+        // Verify headers are present
+        assert!(headers.contains_key(SIGNATURE_HEADER), "Should contain signature header");
+        assert!(headers.contains_key(TIMESTAMP_HEADER), "Should contain timestamp header");
+
+        // Verify header values are not empty
+        let signature = headers.get(SIGNATURE_HEADER).unwrap().to_str().unwrap();
+        let timestamp_str = headers.get(TIMESTAMP_HEADER).unwrap().to_str().unwrap();
+
+        assert!(!signature.is_empty(), "Signature should not be empty");
+        assert!(!timestamp_str.is_empty(), "Timestamp should not be empty");
+
+        // Verify timestamp is a valid integer
+        let timestamp: i64 = timestamp_str.parse().expect("Timestamp should be valid integer");
+        let current_time = OffsetDateTime::now_utc().unix_timestamp();
+
+        // Should be within a reasonable range (within 1 second of current time)
+        assert!((current_time - timestamp).abs() <= 1, "Timestamp should be close to current time");
+    }
+
+    #[test]
+    fn test_verify_rpc_signature_success() {
+        let url = "http://example.com/api/test";
+        let method = Method::GET;
+        let mut headers = HeaderMap::new();
+
+        // Build headers with valid signature
+        build_auth_headers(url, &method, &mut headers);
+
+        // Verify should succeed
+        let result = verify_rpc_signature(url, &method, &headers);
+        assert!(result.is_ok(), "Valid signature should pass verification");
+    }
+
+    #[test]
+    fn test_verify_rpc_signature_invalid_signature() {
+        let url = "http://example.com/api/test";
+        let method = Method::GET;
+        let mut headers = HeaderMap::new();
+
+        // Build headers with valid signature first
+        build_auth_headers(url, &method, &mut headers);
+
+        // Tamper with the signature
+        headers.insert(SIGNATURE_HEADER, HeaderValue::from_str("invalid-signature").unwrap());
+
+        // Verify should fail
+        let result = verify_rpc_signature(url, &method, &headers);
+        assert!(result.is_err(), "Invalid signature should fail verification");
+
+        let error = result.unwrap_err();
+        assert_eq!(error.to_string(), "Invalid signature");
+    }
+
+    #[test]
+    fn test_verify_rpc_signature_expired_timestamp() {
+        let url = "http://example.com/api/test";
+        let method = Method::GET;
+        let mut headers = HeaderMap::new();
+
+        // Set expired timestamp (older than SIGNATURE_VALID_DURATION)
+        let expired_timestamp = OffsetDateTime::now_utc().unix_timestamp() - SIGNATURE_VALID_DURATION - 10;
+        let secret = get_shared_secret();
+        let signature = generate_signature(&secret, url, &method, expired_timestamp);
+
+        headers.insert(SIGNATURE_HEADER, HeaderValue::from_str(&signature).unwrap());
+        headers.insert(TIMESTAMP_HEADER, HeaderValue::from_str(&expired_timestamp.to_string()).unwrap());
+
+        // Verify should fail due to expired timestamp
+        let result = verify_rpc_signature(url, &method, &headers);
+        assert!(result.is_err(), "Expired timestamp should fail verification");
+
+        let error = result.unwrap_err();
+        assert_eq!(error.to_string(), "Request timestamp expired");
+    }
+
+    #[test]
+    fn test_verify_rpc_signature_missing_signature_header() {
+        let url = "http://example.com/api/test";
+        let method = Method::GET;
+        let mut headers = HeaderMap::new();
+
+        // Add only timestamp header, missing signature
+        let timestamp = OffsetDateTime::now_utc().unix_timestamp();
+        headers.insert(TIMESTAMP_HEADER, HeaderValue::from_str(&timestamp.to_string()).unwrap());
+
+        // Verify should fail
+        let result = verify_rpc_signature(url, &method, &headers);
+        assert!(result.is_err(), "Missing signature header should fail verification");
+
+        let error = result.unwrap_err();
+        assert_eq!(error.to_string(), "Missing signature header");
+    }
+
+    #[test]
+    fn test_verify_rpc_signature_missing_timestamp_header() {
+        let url = "http://example.com/api/test";
+        let method = Method::GET;
+        let mut headers = HeaderMap::new();
+
+        // Add only signature header, missing timestamp
+        headers.insert(SIGNATURE_HEADER, HeaderValue::from_str("some-signature").unwrap());
+
+        // Verify should fail
+        let result = verify_rpc_signature(url, &method, &headers);
+        assert!(result.is_err(), "Missing timestamp header should fail verification");
+
+        let error = result.unwrap_err();
+        assert_eq!(error.to_string(), "Missing timestamp header");
+    }
+
+    #[test]
+    fn test_verify_rpc_signature_invalid_timestamp_format() {
+        let url = "http://example.com/api/test";
+        let method = Method::GET;
+        let mut headers = HeaderMap::new();
+
+        headers.insert(SIGNATURE_HEADER, HeaderValue::from_str("some-signature").unwrap());
+        headers.insert(TIMESTAMP_HEADER, HeaderValue::from_str("invalid-timestamp").unwrap());
+
+        // Verify should fail
+        let result = verify_rpc_signature(url, &method, &headers);
+        assert!(result.is_err(), "Invalid timestamp format should fail verification");
+
+        let error = result.unwrap_err();
+        assert_eq!(error.to_string(), "Invalid timestamp format");
+    }
+
+    #[test]
+    fn test_verify_rpc_signature_url_mismatch() {
+        let original_url = "http://example.com/api/test";
+        let different_url = "http://example.com/api/different";
+        let method = Method::GET;
+        let mut headers = HeaderMap::new();
+
+        // Build headers for one URL
+        build_auth_headers(original_url, &method, &mut headers);
+
+        // Try to verify with a different URL
+        let result = verify_rpc_signature(different_url, &method, &headers);
+        assert!(result.is_err(), "URL mismatch should fail verification");
+
+        let error = result.unwrap_err();
+        assert_eq!(error.to_string(), "Invalid signature");
+    }
+
+    #[test]
+    fn test_verify_rpc_signature_method_mismatch() {
+        let url = "http://example.com/api/test";
+        let original_method = Method::GET;
+        let different_method = Method::POST;
+        let mut headers = HeaderMap::new();
+
+        // Build headers for one method
+        build_auth_headers(url, &original_method, &mut headers);
+
+        // Try to verify with a different method
+        let result = verify_rpc_signature(url, &different_method, &headers);
+        assert!(result.is_err(), "Method mismatch should fail verification");
+
+        let error = result.unwrap_err();
+        assert_eq!(error.to_string(), "Invalid signature");
+    }
+
+    #[test]
+    fn test_signature_valid_duration_boundary() {
+        let url = "http://example.com/api/test";
+        let method = Method::GET;
+        let secret = get_shared_secret();
+
+        let mut headers = HeaderMap::new();
+        let current_time = OffsetDateTime::now_utc().unix_timestamp();
+        // Test timestamp just within valid duration
+        let valid_timestamp = current_time - SIGNATURE_VALID_DURATION + 1;
+
+        let signature = generate_signature(&secret, url, &method, valid_timestamp);
+
+        headers.insert(SIGNATURE_HEADER, HeaderValue::from_str(&signature).unwrap());
+        headers.insert(TIMESTAMP_HEADER, HeaderValue::from_str(&valid_timestamp.to_string()).unwrap());
+
+        let result = verify_rpc_signature(url, &method, &headers);
+        assert!(result.is_ok(), "Timestamp within valid duration should pass");
+
+        // Test timestamp just outside valid duration
+        let mut headers = HeaderMap::new();
+        let invalid_timestamp = current_time - SIGNATURE_VALID_DURATION - 15;
+        let signature = generate_signature(&secret, url, &method, invalid_timestamp);
+
+        headers.insert(SIGNATURE_HEADER, HeaderValue::from_str(&signature).unwrap());
+        headers.insert(TIMESTAMP_HEADER, HeaderValue::from_str(&invalid_timestamp.to_string()).unwrap());
+
+        let result = verify_rpc_signature(url, &method, &headers);
+        assert!(result.is_err(), "Timestamp outside valid duration should fail");
+    }
+
+    #[test]
+    fn test_round_trip_authentication() {
+        let test_cases = vec![
+            ("http://example.com/api/test", Method::GET),
+            ("https://api.rustfs.com/v1/bucket", Method::POST),
+            ("http://localhost:9000/admin/info", Method::PUT),
+            ("https://storage.example.com/path/to/object?query=param", Method::DELETE),
+        ];
+
+        for (url, method) in test_cases {
+            let mut headers = HeaderMap::new();
+
+            // Build authentication headers
+            build_auth_headers(url, &method, &mut headers);
+
+            // Verify the signature should succeed
+            let result = verify_rpc_signature(url, &method, &headers);
+            assert!(result.is_ok(), "Round-trip test failed for {} {}", method, url);
+        }
+    }
+}
diff --git a/ecstore/src/rpc/mod.rs b/ecstore/src/rpc/mod.rs
new file mode 100644
index 00000000..e95032ab
--- /dev/null
+++ b/ecstore/src/rpc/mod.rs
@@ -0,0 +1,11 @@
+mod http_auth;
+mod peer_rest_client;
+mod peer_s3_client;
+mod remote_disk;
+mod tonic_service;
+
+pub use http_auth::{build_auth_headers, verify_rpc_signature};
+pub use peer_rest_client::PeerRestClient;
+pub use peer_s3_client::{LocalPeerS3Client, PeerS3Client, RemotePeerS3Client, S3PeerSys};
+pub use remote_disk::RemoteDisk;
+pub use tonic_service::make_server;
diff --git a/ecstore/src/peer_rest_client.rs b/ecstore/src/rpc/peer_rest_client.rs
similarity index 99%
rename from ecstore/src/peer_rest_client.rs
rename to ecstore/src/rpc/peer_rest_client.rs
index 31c74d3a..425413c3 100644
--- a/ecstore/src/peer_rest_client.rs
+++ b/ecstore/src/rpc/peer_rest_client.rs
@@ -292,8 +292,8 @@ impl PeerRestClient {
         let mut buf_o = Vec::new();
         opts.serialize(&mut Serializer::new(&mut buf_o))?;
         let request = Request::new(GetMetricsRequest {
-            metric_type: buf_t,
-            opts: buf_o,
+            metric_type: buf_t.into(),
+            opts: buf_o.into(),
         });
 
         let response = client.get_metrics(request).await?.into_inner();
@@ -664,7 +664,7 @@ impl PeerRestClient {
 
         let response = client.load_rebalance_meta(request).await?.into_inner();
 
-        warn!("load_rebalance_meta response {:?}", response);
+        warn!("load_rebalance_meta response {:?}, grid_host: {:?}", response, &self.grid_host);
         if !response.success {
             if let Some(msg) = response.error_info {
                 return Err(Error::other(msg));
diff --git a/ecstore/src/peer.rs b/ecstore/src/rpc/peer_s3_client.rs
similarity index 93%
rename from ecstore/src/peer.rs
rename to ecstore/src/rpc/peer_s3_client.rs
index 4ffba975..37992dbe 100644
--- a/ecstore/src/peer.rs
+++ b/ecstore/src/rpc/peer_s3_client.rs
@@ -8,6 +8,7 @@ use crate::heal::heal_commands::{
 };
 use crate::heal::heal_ops::RUSTFS_RESERVED_BUCKET;
 use crate::store::all_local_disk;
+use crate::store_utils::is_reserved_or_invalid_bucket;
 use crate::{
     disk::{self, VolumeInfo},
     endpoints::{EndpointServerPools, Node},
@@ -20,7 +21,6 @@ use protos::node_service_time_out_client;
 use protos::proto_gen::node_service::{
     DeleteBucketRequest, GetBucketInfoRequest, HealBucketRequest, ListBucketRequest, MakeBucketRequest,
 };
-use regex::Regex;
 use std::{collections::HashMap, fmt::Debug, sync::Arc};
 use tokio::sync::RwLock;
 use tonic::Request;
@@ -622,63 +622,6 @@ impl PeerS3Client for RemotePeerS3Client {
     }
 }
 
-// 检查桶名是否有效
-fn check_bucket_name(bucket_name: &str, strict: bool) -> Result<()> {
-    if bucket_name.trim().is_empty() {
-        return Err(Error::other("Bucket name cannot be empty"));
-    }
-    if bucket_name.len() < 3 {
-        return Err(Error::other("Bucket name cannot be shorter than 3 characters"));
-    }
-    if bucket_name.len() > 63 {
-        return Err(Error::other("Bucket name cannot be longer than 63 characters"));
-    }
-
-    let ip_address_regex = Regex::new(r"^(\d+\.){3}\d+$").unwrap();
-    if ip_address_regex.is_match(bucket_name) {
-        return Err(Error::other("Bucket name cannot be an IP address"));
-    }
-
-    let valid_bucket_name_regex = if strict {
-        Regex::new(r"^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$").unwrap()
-    } else {
-        Regex::new(r"^[A-Za-z0-9][A-Za-z0-9\.\-_:]{1,61}[A-Za-z0-9]$").unwrap()
-    };
-
-    if !valid_bucket_name_regex.is_match(bucket_name) {
-        return Err(Error::other("Bucket name contains invalid characters"));
-    }
-
-    // 检查包含 "..", ".-", "-."
-    if bucket_name.contains("..") || bucket_name.contains(".-") || bucket_name.contains("-.") {
-        return Err(Error::other("Bucket name contains invalid characters"));
-    }
-
-    Ok(())
-}
-
-// 检查是否为  元数据桶
-fn is_meta_bucket(bucket_name: &str) -> bool {
-    bucket_name == disk::RUSTFS_META_BUCKET
-}
-
-// 检查是否为 保留桶
-fn is_reserved_bucket(bucket_name: &str) -> bool {
-    bucket_name == "rustfs"
-}
-
-// 检查桶名是否为保留名或无效名
-pub fn is_reserved_or_invalid_bucket(bucket_entry: &str, strict: bool) -> bool {
-    if bucket_entry.is_empty() {
-        return true;
-    }
-
-    let bucket_entry = bucket_entry.trim_end_matches('/');
-    let result = check_bucket_name(bucket_entry, strict).is_err();
-
-    result || is_meta_bucket(bucket_entry) || is_reserved_bucket(bucket_entry)
-}
-
 pub async fn heal_bucket_local(bucket: &str, opts: &HealOpts) -> Result<HealResultItem> {
     let disks = clone_drives().await;
     let before_state = Arc::new(RwLock::new(vec![String::new(); disks.len()]));
diff --git a/ecstore/src/disk/remote.rs b/ecstore/src/rpc/remote_disk.rs
similarity index 88%
rename from ecstore/src/disk/remote.rs
rename to ecstore/src/rpc/remote_disk.rs
index 511022cc..d8376309 100644
--- a/ecstore/src/disk/remote.rs
+++ b/ecstore/src/rpc/remote_disk.rs
@@ -1,36 +1,27 @@
 use std::path::PathBuf;
 
+use bytes::Bytes;
 use futures::lock::Mutex;
-use http::{HeaderMap, Method};
+use http::{HeaderMap, HeaderValue, Method, header::CONTENT_TYPE};
 use protos::{
     node_service_time_out_client,
     proto_gen::node_service::{
         CheckPartsRequest, DeletePathsRequest, DeleteRequest, DeleteVersionRequest, DeleteVersionsRequest, DeleteVolumeRequest,
         DiskInfoRequest, ListDirRequest, ListVolumesRequest, MakeVolumeRequest, MakeVolumesRequest, NsScannerRequest,
         ReadAllRequest, ReadMultipleRequest, ReadVersionRequest, ReadXlRequest, RenameDataRequest, RenameFileRequest,
-        StatVolumeRequest, UpdateMetadataRequest, VerifyFileRequest, WalkDirRequest, WriteAllRequest, WriteMetadataRequest,
+        StatVolumeRequest, UpdateMetadataRequest, VerifyFileRequest, WriteAllRequest, WriteMetadataRequest,
     },
 };
-use rmp_serde::Serializer;
-use rustfs_filemeta::{FileInfo, MetaCacheEntry, MetacacheWriter, RawFileInfo};
-use rustfs_rio::{HttpReader, HttpWriter};
-use serde::Serialize;
-use tokio::{
-    io::AsyncWrite,
-    sync::mpsc::{self, Sender},
-};
-use tokio_stream::{StreamExt, wrappers::ReceiverStream};
-use tonic::Request;
-use tracing::info;
-use uuid::Uuid;
 
-use super::error::{Error, Result};
-use super::{
+use crate::disk::{
     CheckPartsResp, DeleteOptions, DiskAPI, DiskInfo, DiskInfoOptions, DiskLocation, DiskOption, FileInfoVersions,
     ReadMultipleReq, ReadMultipleResp, ReadOptions, RenameDataResp, UpdateMetadataOpts, VolumeInfo, WalkDirOptions,
     endpoint::Endpoint,
 };
-
+use crate::{
+    disk::error::{Error, Result},
+    rpc::build_auth_headers,
+};
 use crate::{
     disk::{FileReader, FileWriter},
     heal::{
@@ -39,6 +30,16 @@ use crate::{
         heal_commands::{HealScanMode, HealingTracker},
     },
 };
+use rustfs_filemeta::{FileInfo, RawFileInfo};
+use rustfs_rio::{HttpReader, HttpWriter};
+use tokio::{
+    io::AsyncWrite,
+    sync::mpsc::{self, Sender},
+};
+use tokio_stream::{StreamExt, wrappers::ReceiverStream};
+use tonic::Request;
+use tracing::info;
+use uuid::Uuid;
 
 use protos::proto_gen::node_service::RenamePartRequest;
 
@@ -255,47 +256,55 @@ impl DiskAPI for RemoteDisk {
         Ok(())
     }
 
-    // FIXME: TODO: use writer
-    #[tracing::instrument(skip(self, wr))]
-    async fn walk_dir<W: AsyncWrite + Unpin + Send>(&self, opts: WalkDirOptions, wr: &mut W) -> Result<()> {
-        let now = std::time::SystemTime::now();
-        info!("walk_dir {}/{}/{:?}", self.endpoint.to_string(), opts.bucket, opts.filter_prefix);
-        let mut wr = wr;
-        let mut out = MetacacheWriter::new(&mut wr);
-        let mut buf = Vec::new();
-        opts.serialize(&mut Serializer::new(&mut buf))?;
-        let mut client = node_service_time_out_client(&self.addr)
-            .await
-            .map_err(|err| Error::other(format!("can not get client, err: {}", err)))?;
-        let request = Request::new(WalkDirRequest {
-            disk: self.endpoint.to_string(),
-            walk_dir_options: buf,
-        });
-        let mut response = client.walk_dir(request).await?.into_inner();
+    // // FIXME: TODO: use writer
+    // #[tracing::instrument(skip(self, wr))]
+    // async fn walk_dir<W: AsyncWrite + Unpin + Send>(&self, opts: WalkDirOptions, wr: &mut W) -> Result<()> {
+    //     let now = std::time::SystemTime::now();
+    //     info!("walk_dir {}/{}/{:?}", self.endpoint.to_string(), opts.bucket, opts.filter_prefix);
+    //     let mut wr = wr;
+    //     let mut out = MetacacheWriter::new(&mut wr);
+    //     let mut buf = Vec::new();
+    //     opts.serialize(&mut Serializer::new(&mut buf))?;
+    //     let mut client = node_service_time_out_client(&self.addr)
+    //         .await
+    //         .map_err(|err| Error::other(format!("can not get client, err: {}", err)))?;
+    //     let request = Request::new(WalkDirRequest {
+    //         disk: self.endpoint.to_string(),
+    //         walk_dir_options: buf.into(),
+    //     });
+    //     let mut response = client.walk_dir(request).await?.into_inner();
 
-        loop {
-            match response.next().await {
-                Some(Ok(resp)) => {
-                    if !resp.success {
-                        return Err(Error::other(resp.error_info.unwrap_or_default()));
-                    }
-                    let entry = serde_json::from_str::<MetaCacheEntry>(&resp.meta_cache_entry)
-                        .map_err(|_| Error::other(format!("Unexpected response: {:?}", response)))?;
-                    out.write_obj(&entry).await?;
-                }
-                None => break,
-                _ => return Err(Error::other(format!("Unexpected response: {:?}", response))),
-            }
-        }
+    //     loop {
+    //         match response.next().await {
+    //             Some(Ok(resp)) => {
+    //                 if !resp.success {
+    //                     if let Some(err) = resp.error_info {
+    //                         if err == "Unexpected EOF" {
+    //                             return Err(Error::Io(std::io::Error::new(std::io::ErrorKind::UnexpectedEof, err)));
+    //                         } else {
+    //                             return Err(Error::other(err));
+    //                         }
+    //                     }
 
-        info!(
-            "walk_dir {}/{:?} done {:?}",
-            opts.bucket,
-            opts.filter_prefix,
-            now.elapsed().unwrap_or_default()
-        );
-        Ok(())
-    }
+    //                     return Err(Error::other("unknown error"));
+    //                 }
+    //                 let entry = serde_json::from_str::<MetaCacheEntry>(&resp.meta_cache_entry)
+    //                     .map_err(|_| Error::other(format!("Unexpected response: {:?}", response)))?;
+    //                 out.write_obj(&entry).await?;
+    //             }
+    //             None => break,
+    //             _ => return Err(Error::other(format!("Unexpected response: {:?}", response))),
+    //         }
+    //     }
+
+    //     info!(
+    //         "walk_dir {}/{:?} done {:?}",
+    //         opts.bucket,
+    //         opts.filter_prefix,
+    //         now.elapsed().unwrap_or_default()
+    //     );
+    //     Ok(())
+    // }
 
     #[tracing::instrument(skip(self))]
     async fn delete_version(
@@ -558,6 +567,29 @@ impl DiskAPI for RemoteDisk {
         Ok(response.volumes)
     }
 
+    #[tracing::instrument(skip(self, wr))]
+    async fn walk_dir<W: AsyncWrite + Unpin + Send>(&self, opts: WalkDirOptions, wr: &mut W) -> Result<()> {
+        info!("walk_dir {}", self.endpoint.to_string());
+
+        let url = format!(
+            "{}/rustfs/rpc/walk_dir?disk={}",
+            self.endpoint.grid_host(),
+            urlencoding::encode(self.endpoint.to_string().as_str()),
+        );
+
+        let opts = serde_json::to_vec(&opts)?;
+
+        let mut headers = HeaderMap::new();
+        headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
+        build_auth_headers(&url, &Method::GET, &mut headers);
+
+        let mut reader = HttpReader::new(url, Method::GET, headers, Some(opts)).await?;
+
+        tokio::io::copy(&mut reader, wr).await?;
+
+        Ok(())
+    }
+
     #[tracing::instrument(level = "debug", skip(self))]
     async fn read_file(&self, volume: &str, path: &str) -> Result<FileReader> {
         info!("read_file {}/{}", volume, path);
@@ -572,12 +604,22 @@ impl DiskAPI for RemoteDisk {
             0
         );
 
-        Ok(Box::new(HttpReader::new(url, Method::GET, HeaderMap::new()).await?))
+        let mut headers = HeaderMap::new();
+        headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
+        build_auth_headers(&url, &Method::GET, &mut headers);
+        Ok(Box::new(HttpReader::new(url, Method::GET, headers, None).await?))
     }
 
     #[tracing::instrument(level = "debug", skip(self))]
     async fn read_file_stream(&self, volume: &str, path: &str, offset: usize, length: usize) -> Result<FileReader> {
-        info!("read_file_stream {}/{}/{}", self.endpoint.to_string(), volume, path);
+        // warn!(
+        //     "disk remote read_file_stream {}/{}/{} offset={} length={}",
+        //     self.endpoint.to_string(),
+        //     volume,
+        //     path,
+        //     offset,
+        //     length
+        // );
         let url = format!(
             "{}/rustfs/rpc/read_file_stream?disk={}&volume={}&path={}&offset={}&length={}",
             self.endpoint.grid_host(),
@@ -588,7 +630,10 @@ impl DiskAPI for RemoteDisk {
             length
         );
 
-        Ok(Box::new(HttpReader::new(url, Method::GET, HeaderMap::new()).await?))
+        let mut headers = HeaderMap::new();
+        headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
+        build_auth_headers(&url, &Method::GET, &mut headers);
+        Ok(Box::new(HttpReader::new(url, Method::GET, headers, None).await?))
     }
 
     #[tracing::instrument(level = "debug", skip(self))]
@@ -605,12 +650,21 @@ impl DiskAPI for RemoteDisk {
             0
         );
 
-        Ok(Box::new(HttpWriter::new(url, Method::PUT, HeaderMap::new()).await?))
+        let mut headers = HeaderMap::new();
+        headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
+        build_auth_headers(&url, &Method::PUT, &mut headers);
+        Ok(Box::new(HttpWriter::new(url, Method::PUT, headers).await?))
     }
 
     #[tracing::instrument(level = "debug", skip(self))]
-    async fn create_file(&self, _origvolume: &str, volume: &str, path: &str, file_size: usize) -> Result<FileWriter> {
-        info!("create_file {}/{}/{}", self.endpoint.to_string(), volume, path);
+    async fn create_file(&self, _origvolume: &str, volume: &str, path: &str, file_size: i64) -> Result<FileWriter> {
+        // warn!(
+        //     "disk remote create_file {}/{}/{} file_size={}",
+        //     self.endpoint.to_string(),
+        //     volume,
+        //     path,
+        //     file_size
+        // );
 
         let url = format!(
             "{}/rustfs/rpc/put_file_stream?disk={}&volume={}&path={}&append={}&size={}",
@@ -622,7 +676,10 @@ impl DiskAPI for RemoteDisk {
             file_size
         );
 
-        Ok(Box::new(HttpWriter::new(url, Method::PUT, HeaderMap::new()).await?))
+        let mut headers = HeaderMap::new();
+        headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
+        build_auth_headers(&url, &Method::PUT, &mut headers);
+        Ok(Box::new(HttpWriter::new(url, Method::PUT, headers).await?))
     }
 
     #[tracing::instrument(level = "debug", skip(self))]
@@ -649,7 +706,7 @@ impl DiskAPI for RemoteDisk {
     }
 
     #[tracing::instrument(skip(self))]
-    async fn rename_part(&self, src_volume: &str, src_path: &str, dst_volume: &str, dst_path: &str, meta: Vec<u8>) -> Result<()> {
+    async fn rename_part(&self, src_volume: &str, src_path: &str, dst_volume: &str, dst_path: &str, meta: Bytes) -> Result<()> {
         info!("rename_part {}/{}", src_volume, src_path);
         let mut client = node_service_time_out_client(&self.addr)
             .await
@@ -773,7 +830,7 @@ impl DiskAPI for RemoteDisk {
     }
 
     #[tracing::instrument(skip(self))]
-    async fn write_all(&self, volume: &str, path: &str, data: Vec<u8>) -> Result<()> {
+    async fn write_all(&self, volume: &str, path: &str, data: Bytes) -> Result<()> {
         info!("write_all");
         let mut client = node_service_time_out_client(&self.addr)
             .await
@@ -795,7 +852,7 @@ impl DiskAPI for RemoteDisk {
     }
 
     #[tracing::instrument(skip(self))]
-    async fn read_all(&self, volume: &str, path: &str) -> Result<Vec<u8>> {
+    async fn read_all(&self, volume: &str, path: &str) -> Result<Bytes> {
         info!("read_all {}/{}", volume, path);
         let mut client = node_service_time_out_client(&self.addr)
             .await
diff --git a/rustfs/src/grpc.rs b/ecstore/src/rpc/tonic_service.rs
similarity index 97%
rename from rustfs/src/grpc.rs
rename to ecstore/src/rpc/tonic_service.rs
index 6c155edc..d7a47aa0 100644
--- a/rustfs/src/grpc.rs
+++ b/ecstore/src/rpc/tonic_service.rs
@@ -1,7 +1,7 @@
 use std::{collections::HashMap, io::Cursor, pin::Pin};
 
 // use common::error::Error as EcsError;
-use ecstore::{
+use crate::{
     admin_server_info::get_local_server_property,
     bucket::{metadata::load_bucket_metadata, metadata_sys},
     disk::{
@@ -14,7 +14,7 @@ use ecstore::{
     },
     metrics_realtime::{CollectMetricsOpts, MetricType, collect_local_metrics},
     new_object_layer_fn,
-    peer::{LocalPeerS3Client, PeerS3Client},
+    rpc::{LocalPeerS3Client, PeerS3Client},
     store::{all_local_disk_path, find_local_disk},
     store_api::{BucketOptions, DeleteBucketOptions, MakeBucketOptions, StorageAPI},
 };
@@ -24,6 +24,7 @@ use lock::{GLOBAL_LOCAL_SERVER, Locker, lock_args::LockArgs};
 
 use common::globals::GLOBAL_Local_Node_Name;
 
+use bytes::Bytes;
 use madmin::health::{
     get_cpus, get_mem_info, get_os_info, get_partitions, get_proc_info, get_sys_config, get_sys_errors, get_sys_services,
 };
@@ -108,7 +109,7 @@ impl Node for NodeService {
 
         Ok(tonic::Response::new(PingResponse {
             version: 1,
-            body: finished_data.to_vec(),
+            body: Bytes::copy_from_slice(finished_data),
         }))
     }
 
@@ -225,7 +226,6 @@ impl Node for NodeService {
                     }
                 };
 
-                println!("bucket info {}", bucket_info.clone());
                 Ok(tonic::Response::new(GetBucketInfoResponse {
                     success: true,
                     bucket_info,
@@ -276,19 +276,19 @@ impl Node for NodeService {
             match disk.read_all(&request.volume, &request.path).await {
                 Ok(data) => Ok(tonic::Response::new(ReadAllResponse {
                     success: true,
-                    data: data.to_vec(),
+                    data,
                     error: None,
                 })),
                 Err(err) => Ok(tonic::Response::new(ReadAllResponse {
                     success: false,
-                    data: Vec::new(),
+                    data: Bytes::new(),
                     error: Some(err.into()),
                 })),
             }
         } else {
             Ok(tonic::Response::new(ReadAllResponse {
                 success: false,
-                data: Vec::new(),
+                data: Bytes::new(),
                 error: Some(DiskError::other("can not find disk".to_string()).into()),
             }))
         }
@@ -806,11 +806,38 @@ impl Node for NodeService {
                                 }
                             }
                             Err(err) => {
+                                if err == rustfs_filemeta::Error::Unexpected {
+                                    let _ = tx
+                                        .send(Ok(WalkDirResponse {
+                                            success: false,
+                                            meta_cache_entry: "".to_string(),
+                                            error_info: Some(err.to_string()),
+                                        }))
+                                        .await;
+
+                                    break;
+                                }
+
                                 if rustfs_filemeta::is_io_eof(&err) {
+                                    let _ = tx
+                                        .send(Ok(WalkDirResponse {
+                                            success: false,
+                                            meta_cache_entry: "".to_string(),
+                                            error_info: Some(err.to_string()),
+                                        }))
+                                        .await;
                                     break;
                                 }
 
                                 println!("get err {:?}", err);
+
+                                let _ = tx
+                                    .send(Ok(WalkDirResponse {
+                                        success: false,
+                                        meta_cache_entry: "".to_string(),
+                                        error_info: Some(err.to_string()),
+                                    }))
+                                    .await;
                                 break;
                             }
                         }
@@ -1577,7 +1604,7 @@ impl Node for NodeService {
         let Some(store) = new_object_layer_fn() else {
             return Ok(tonic::Response::new(LocalStorageInfoResponse {
                 success: false,
-                storage_info: vec![],
+                storage_info: Bytes::new(),
                 error_info: Some("errServerNotInitialized".to_string()),
             }));
         };
@@ -1587,14 +1614,14 @@ impl Node for NodeService {
         if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
             return Ok(tonic::Response::new(LocalStorageInfoResponse {
                 success: false,
-                storage_info: vec![],
+                storage_info: Bytes::new(),
                 error_info: Some(err.to_string()),
             }));
         }
 
         Ok(tonic::Response::new(LocalStorageInfoResponse {
             success: true,
-            storage_info: buf,
+            storage_info: buf.into(),
             error_info: None,
         }))
     }
@@ -1605,13 +1632,13 @@ impl Node for NodeService {
         if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
             return Ok(tonic::Response::new(ServerInfoResponse {
                 success: false,
-                server_properties: vec![],
+                server_properties: Bytes::new(),
                 error_info: Some(err.to_string()),
             }));
         }
         Ok(tonic::Response::new(ServerInfoResponse {
             success: true,
-            server_properties: buf,
+            server_properties: buf.into(),
             error_info: None,
         }))
     }
@@ -1622,13 +1649,13 @@ impl Node for NodeService {
         if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
             return Ok(tonic::Response::new(GetCpusResponse {
                 success: false,
-                cpus: vec![],
+                cpus: Bytes::new(),
                 error_info: Some(err.to_string()),
             }));
         }
         Ok(tonic::Response::new(GetCpusResponse {
             success: true,
-            cpus: buf,
+            cpus: buf.into(),
             error_info: None,
         }))
     }
@@ -1640,13 +1667,13 @@ impl Node for NodeService {
         if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
             return Ok(tonic::Response::new(GetNetInfoResponse {
                 success: false,
-                net_info: vec![],
+                net_info: Bytes::new(),
                 error_info: Some(err.to_string()),
             }));
         }
         Ok(tonic::Response::new(GetNetInfoResponse {
             success: true,
-            net_info: buf,
+            net_info: buf.into(),
             error_info: None,
         }))
     }
@@ -1657,13 +1684,13 @@ impl Node for NodeService {
         if let Err(err) = partitions.serialize(&mut Serializer::new(&mut buf)) {
             return Ok(tonic::Response::new(GetPartitionsResponse {
                 success: false,
-                partitions: vec![],
+                partitions: Bytes::new(),
                 error_info: Some(err.to_string()),
             }));
         }
         Ok(tonic::Response::new(GetPartitionsResponse {
             success: true,
-            partitions: buf,
+            partitions: buf.into(),
             error_info: None,
         }))
     }
@@ -1674,13 +1701,13 @@ impl Node for NodeService {
         if let Err(err) = os_info.serialize(&mut Serializer::new(&mut buf)) {
             return Ok(tonic::Response::new(GetOsInfoResponse {
                 success: false,
-                os_info: vec![],
+                os_info: Bytes::new(),
                 error_info: Some(err.to_string()),
             }));
         }
         Ok(tonic::Response::new(GetOsInfoResponse {
             success: true,
-            os_info: buf,
+            os_info: buf.into(),
             error_info: None,
         }))
     }
@@ -1695,13 +1722,13 @@ impl Node for NodeService {
         if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
             return Ok(tonic::Response::new(GetSeLinuxInfoResponse {
                 success: false,
-                sys_services: vec![],
+                sys_services: Bytes::new(),
                 error_info: Some(err.to_string()),
             }));
         }
         Ok(tonic::Response::new(GetSeLinuxInfoResponse {
             success: true,
-            sys_services: buf,
+            sys_services: buf.into(),
             error_info: None,
         }))
     }
@@ -1713,13 +1740,13 @@ impl Node for NodeService {
         if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
             return Ok(tonic::Response::new(GetSysConfigResponse {
                 success: false,
-                sys_config: vec![],
+                sys_config: Bytes::new(),
                 error_info: Some(err.to_string()),
             }));
         }
         Ok(tonic::Response::new(GetSysConfigResponse {
             success: true,
-            sys_config: buf,
+            sys_config: buf.into(),
             error_info: None,
         }))
     }
@@ -1731,13 +1758,13 @@ impl Node for NodeService {
         if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
             return Ok(tonic::Response::new(GetSysErrorsResponse {
                 success: false,
-                sys_errors: vec![],
+                sys_errors: Bytes::new(),
                 error_info: Some(err.to_string()),
             }));
         }
         Ok(tonic::Response::new(GetSysErrorsResponse {
             success: true,
-            sys_errors: buf,
+            sys_errors: buf.into(),
             error_info: None,
         }))
     }
@@ -1749,13 +1776,13 @@ impl Node for NodeService {
         if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
             return Ok(tonic::Response::new(GetMemInfoResponse {
                 success: false,
-                mem_info: vec![],
+                mem_info: Bytes::new(),
                 error_info: Some(err.to_string()),
             }));
         }
         Ok(tonic::Response::new(GetMemInfoResponse {
             success: true,
-            mem_info: buf,
+            mem_info: buf.into(),
             error_info: None,
         }))
     }
@@ -1774,13 +1801,13 @@ impl Node for NodeService {
         if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
             return Ok(tonic::Response::new(GetMetricsResponse {
                 success: false,
-                realtime_metrics: vec![],
+                realtime_metrics: Bytes::new(),
                 error_info: Some(err.to_string()),
             }));
         }
         Ok(tonic::Response::new(GetMetricsResponse {
             success: true,
-            realtime_metrics: buf,
+            realtime_metrics: buf.into(),
             error_info: None,
         }))
     }
@@ -1792,13 +1819,13 @@ impl Node for NodeService {
         if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
             return Ok(tonic::Response::new(GetProcInfoResponse {
                 success: false,
-                proc_info: vec![],
+                proc_info: Bytes::new(),
                 error_info: Some(err.to_string()),
             }));
         }
         Ok(tonic::Response::new(GetProcInfoResponse {
             success: true,
-            proc_info: buf,
+            proc_info: buf.into(),
             error_info: None,
         }))
     }
@@ -2085,7 +2112,7 @@ impl Node for NodeService {
         if !ok {
             return Ok(tonic::Response::new(BackgroundHealStatusResponse {
                 success: false,
-                bg_heal_state: vec![],
+                bg_heal_state: Bytes::new(),
                 error_info: Some("errServerNotInitialized".to_string()),
             }));
         }
@@ -2094,13 +2121,13 @@ impl Node for NodeService {
         if let Err(err) = state.serialize(&mut Serializer::new(&mut buf)) {
             return Ok(tonic::Response::new(BackgroundHealStatusResponse {
                 success: false,
-                bg_heal_state: vec![],
+                bg_heal_state: Bytes::new(),
                 error_info: Some(err.to_string()),
             }));
         }
         Ok(tonic::Response::new(BackgroundHealStatusResponse {
             success: true,
-            bg_heal_state: buf,
+            bg_heal_state: buf.into(),
             error_info: None,
         }))
     }
@@ -2257,7 +2284,7 @@ mod tests {
 
         let request = Request::new(PingRequest {
             version: 1,
-            body: fbb.finished_data().to_vec(),
+            body: Bytes::copy_from_slice(fbb.finished_data()),
         });
 
         let response = service.ping(request).await;
@@ -2274,7 +2301,7 @@ mod tests {
 
         let request = Request::new(PingRequest {
             version: 1,
-            body: vec![0x00, 0x01, 0x02], // Invalid flatbuffer data
+            body: vec![0x00, 0x01, 0x02].into(), // Invalid flatbuffer data
         });
 
         let response = service.ping(request).await;
@@ -2397,7 +2424,7 @@ mod tests {
             disk: "invalid-disk-path".to_string(),
             volume: "test-volume".to_string(),
             path: "test-path".to_string(),
-            data: vec![1, 2, 3, 4],
+            data: vec![1, 2, 3, 4].into(),
         });
 
         let response = service.write_all(request).await;
@@ -2514,7 +2541,7 @@ mod tests {
             src_path: "src-path".to_string(),
             dst_volume: "dst-volume".to_string(),
             dst_path: "dst-path".to_string(),
-            meta: vec![],
+            meta: Bytes::new(),
         });
 
         let response = service.rename_part(request).await;
diff --git a/ecstore/src/set_disk.rs b/ecstore/src/set_disk.rs
index e2ab478e..becaff5a 100644
--- a/ecstore/src/set_disk.rs
+++ b/ecstore/src/set_disk.rs
@@ -52,6 +52,7 @@ use crate::{
     heal::data_scanner::{HEAL_DELETE_DANGLING, globalHealConfig},
     store_api::ListObjectVersionsInfo,
 };
+use bytes::Bytes;
 use bytesize::ByteSize;
 use chrono::Utc;
 use futures::future::join_all;
@@ -61,13 +62,14 @@ use lock::{LockApi, namespace_lock::NsLockMap};
 use madmin::heal_commands::{HealDriveInfo, HealResultItem};
 use md5::{Digest as Md5Digest, Md5};
 use rand::{Rng, seq::SliceRandom};
+use rustfs_filemeta::headers::RESERVED_METADATA_PREFIX_LOWER;
 use rustfs_filemeta::{
     FileInfo, FileMeta, FileMetaShallowVersion, MetaCacheEntries, MetaCacheEntry, MetadataResolutionParams, ObjectPartInfo,
     RawFileInfo, file_info_from_raw,
     headers::{AMZ_OBJECT_TAGGING, AMZ_STORAGE_CLASS},
     merge_file_meta_versions,
 };
-use rustfs_rio::{EtagResolvable, HashReader};
+use rustfs_rio::{EtagResolvable, HashReader, TryGetIndex as _, WarpReader};
 use rustfs_utils::{
     HashAlgorithm,
     crypto::{base64_decode, base64_encode, hex},
@@ -497,7 +499,7 @@ impl SetDisks {
         src_object: &str,
         dst_bucket: &str,
         dst_object: &str,
-        meta: Vec<u8>,
+        meta: Bytes,
         write_quorum: usize,
     ) -> disk::error::Result<Vec<Option<DiskStore>>> {
         let src_bucket = Arc::new(src_bucket.to_string());
@@ -867,6 +869,8 @@ impl SetDisks {
         };
 
         if let Some(err) = reduce_read_quorum_errs(errs, OBJECT_OP_IGNORED_ERRS, expected_rquorum) {
+            // let object = parts_metadata.first().map(|v| v.name.clone()).unwrap_or_default();
+            // error!("object_quorum_from_meta: {:?}, errs={:?}, object={:?}", err, errs, object);
             return Err(err);
         }
 
@@ -879,6 +883,7 @@ impl SetDisks {
         let parity_blocks = Self::common_parity(&parities, default_parity_count as i32);
 
         if parity_blocks < 0 {
+            error!("object_quorum_from_meta: parity_blocks < 0, errs={:?}", errs);
             return Err(DiskError::ErasureReadQuorum);
         }
 
@@ -943,6 +948,7 @@ impl SetDisks {
             Self::object_quorum_from_meta(&parts_metadata, &errs, self.default_parity_count).map_err(map_err_notfound)?;
 
         if read_quorum < 0 {
+            error!("check_upload_id_exists: read_quorum < 0, errs={:?}", errs);
             return Err(Error::ErasureReadQuorum);
         }
 
@@ -984,6 +990,7 @@ impl SetDisks {
         quorum: usize,
     ) -> disk::error::Result<FileInfo> {
         if quorum < 1 {
+            error!("find_file_info_in_quorum: quorum < 1");
             return Err(DiskError::ErasureReadQuorum);
         }
 
@@ -1042,6 +1049,7 @@ impl SetDisks {
         }
 
         if max_count < quorum {
+            error!("find_file_info_in_quorum: max_count < quorum, max_val={:?}", max_val);
             return Err(DiskError::ErasureReadQuorum);
         }
 
@@ -1086,7 +1094,7 @@ impl SetDisks {
             return Ok(fi);
         }
 
-        warn!("QuorumError::Read, find_file_info_in_quorum fileinfo not found");
+        error!("find_file_info_in_quorum: fileinfo not found");
 
         Err(DiskError::ErasureReadQuorum)
     }
@@ -1770,10 +1778,18 @@ impl SetDisks {
 
         let _min_disks = self.set_drive_count - self.default_parity_count;
 
-        let (read_quorum, _) = Self::object_quorum_from_meta(&parts_metadata, &errs, self.default_parity_count)
-            .map_err(|err| to_object_err(err.into(), vec![bucket, object]))?;
+        let (read_quorum, _) = match Self::object_quorum_from_meta(&parts_metadata, &errs, self.default_parity_count)
+            .map_err(|err| to_object_err(err.into(), vec![bucket, object]))
+        {
+            Ok(v) => v,
+            Err(e) => {
+                // error!("Self::object_quorum_from_meta: {:?}, bucket: {}, object: {}", &e, bucket, object);
+                return Err(e);
+            }
+        };
 
         if let Some(err) = reduce_read_quorum_errs(&errs, OBJECT_OP_IGNORED_ERRS, read_quorum as usize) {
+            error!("reduce_read_quorum_errs: {:?}, bucket: {}, object: {}", &err, bucket, object);
             return Err(to_object_err(err.into(), vec![bucket, object]));
         }
 
@@ -1811,7 +1827,7 @@ impl SetDisks {
         bucket: &str,
         object: &str,
         offset: usize,
-        length: usize,
+        length: i64,
         writer: &mut W,
         fi: FileInfo,
         files: Vec<FileInfo>,
@@ -1824,11 +1840,16 @@ impl SetDisks {
     {
         let (disks, files) = Self::shuffle_disks_and_parts_metadata_by_index(disks, &files, &fi);
 
-        let total_size = fi.size;
+        let total_size = fi.size as usize;
 
-        let length = { if length == 0 { total_size - offset } else { length } };
+        let length = if length < 0 {
+            fi.size as usize - offset
+        } else {
+            length as usize
+        };
 
         if offset > total_size || offset + length > total_size {
+            error!("get_object_with_fileinfo offset out of range: {}, total_size: {}", offset, total_size);
             return Err(Error::other("offset out of range"));
         }
 
@@ -1846,13 +1867,6 @@ impl SetDisks {
 
         let (last_part_index, _) = fi.to_part_offset(end_offset)?;
 
-        // debug!(
-        //     "get_object_with_fileinfo end offset:{}, last_part_index:{},part_offset:{}",
-        //     end_offset, last_part_index, 0
-        // );
-
-        // let erasure = Erasure::new(fi.erasure.data_blocks, fi.erasure.parity_blocks, fi.erasure.block_size);
-
         let erasure = erasure_coding::Erasure::new(fi.erasure.data_blocks, fi.erasure.parity_blocks, fi.erasure.block_size);
 
         let mut total_readed = 0;
@@ -1864,7 +1878,7 @@ impl SetDisks {
             let part_number = fi.parts[i].number;
             let part_size = fi.parts[i].size;
             let mut part_length = part_size - part_offset;
-            if part_length > length - total_readed {
+            if part_length > (length - total_readed) {
                 part_length = length - total_readed
             }
 
@@ -1903,9 +1917,10 @@ impl SetDisks {
             let nil_count = errors.iter().filter(|&e| e.is_none()).count();
             if nil_count < erasure.data_shards {
                 if let Some(read_err) = reduce_read_quorum_errs(&errors, OBJECT_OP_IGNORED_ERRS, erasure.data_shards) {
+                    error!("create_bitrot_reader reduce_read_quorum_errs {:?}", &errors);
                     return Err(to_object_err(read_err.into(), vec![bucket, object]));
                 }
-
+                error!("create_bitrot_reader not enough disks to read: {:?}", &errors);
                 return Err(Error::other(format!("not enough disks to read: {:?}", errors)));
             }
 
@@ -2252,7 +2267,8 @@ impl SetDisks {
                             erasure_coding::Erasure::default()
                         };
 
-                        result.object_size = ObjectInfo::from_file_info(&lastest_meta, bucket, object, true).get_actual_size()?;
+                        result.object_size =
+                            ObjectInfo::from_file_info(&lastest_meta, bucket, object, true).get_actual_size()? as usize;
                         // Loop to find number of disks with valid data, per-drive
                         // data state and a list of outdated disks on which data needs
                         // to be healed.
@@ -2514,7 +2530,7 @@ impl SetDisks {
                                         disk.as_ref(),
                                         RUSTFS_META_TMP_BUCKET,
                                         &format!("{}/{}/part.{}", tmp_id, dst_data_dir, part.number),
-                                        erasure.shard_file_size(part.size),
+                                        erasure.shard_file_size(part.size as i64),
                                         erasure.shard_size(),
                                         HashAlgorithm::HighwayHash256,
                                     )
@@ -2596,13 +2612,15 @@ impl SetDisks {
                                         part.size,
                                         part.mod_time,
                                         part.actual_size,
+                                        part.index.clone(),
                                     );
                                     if is_inline_buffer {
                                         if let Some(writer) = writers[index].take() {
                                             // if let Some(w) = writer.as_any().downcast_ref::<BitrotFileWriter>() {
                                             //     parts_metadata[index].data = Some(w.inline_data().to_vec());
                                             // }
-                                            parts_metadata[index].data = Some(writer.into_inline_data().unwrap_or_default());
+                                            parts_metadata[index].data =
+                                                Some(writer.into_inline_data().map(bytes::Bytes::from).unwrap_or_default());
                                         }
                                         parts_metadata[index].set_inline_data();
                                     } else {
@@ -2826,7 +2844,7 @@ impl SetDisks {
             heal_item_type: HEAL_ITEM_OBJECT.to_string(),
             bucket: bucket.to_string(),
             object: object.to_string(),
-            object_size: lfi.size,
+            object_size: lfi.size as usize,
             version_id: version_id.to_string(),
             disk_count: disk_len,
             ..Default::default()
@@ -2948,6 +2966,7 @@ impl SetDisks {
             }
             Ok(m)
         } else {
+            error!("delete_if_dang_ling: is_object_dang_ling errs={:?}", errs);
             Err(DiskError::ErasureReadQuorum)
         }
     }
@@ -3010,13 +3029,25 @@ impl SetDisks {
         }
 
         let (buckets_results_tx, mut buckets_results_rx) = mpsc::channel::<DataUsageEntryInfo>(disks.len());
+        // 新增：从环境变量读取基础间隔，默认 30 秒
+        let set_disk_update_interval_secs = std::env::var("RUSTFS_NS_SCANNER_INTERVAL")
+            .ok()
+            .and_then(|v| v.parse::<u64>().ok())
+            .unwrap_or(30);
         let update_time = {
             let mut rng = rand::rng();
-            Duration::from_secs(30) + Duration::from_secs_f64(10.0 * rng.random_range(0.0..1.0))
+            Duration::from_secs(set_disk_update_interval_secs) + Duration::from_secs_f64(10.0 * rng.random_range(0.0..1.0))
         };
         let mut ticker = interval(update_time);
 
-        let task = tokio::spawn(async move {
+        // 检查是否需要运行后台任务
+        let skip_background_task = std::env::var("RUSTFS_SKIP_BACKGROUND_TASK")
+            .ok()
+            .and_then(|v| v.parse::<bool>().ok())
+            .unwrap_or(false);
+
+        let task = if !skip_background_task {
+            Some(tokio::spawn(async move {
             let last_save = Some(SystemTime::now());
             let mut need_loop = true;
             while need_loop {
@@ -3044,7 +3075,10 @@ impl SetDisks {
                     }
                 }
             }
-        });
+            }))
+        } else {
+            None
+        };
 
         // Restrict parallelism for disk usage scanner
         let max_procs = num_cpus::get();
@@ -3148,7 +3182,9 @@ impl SetDisks {
 
         info!("ns_scanner start");
         let _ = join_all(futures).await;
+        if let Some(task) = task {
         let _ = task.await;
+        }
         info!("ns_scanner completed");
         Ok(())
     }
@@ -3474,7 +3510,7 @@ impl SetDisks {
                         if let (Some(started), Some(mod_time)) = (started, version.mod_time) {
                             if mod_time > started {
                                 version_not_found += 1;
-                                if send(heal_entry_skipped(version.size)).await {
+                                if send(heal_entry_skipped(version.size as usize)).await {
                                     defer.await;
                                     return;
                                 }
@@ -3518,10 +3554,10 @@ impl SetDisks {
 
                         if version_healed {
                             bg_seq.count_healed(HEAL_ITEM_OBJECT.to_string()).await;
-                            result = heal_entry_success(version.size);
+                            result = heal_entry_success(version.size as usize);
                         } else {
                             bg_seq.count_failed(HEAL_ITEM_OBJECT.to_string()).await;
-                            result = heal_entry_failure(version.size);
+                            result = heal_entry_failure(version.size as usize);
                             match version.version_id {
                                 Some(version_id) => {
                                     info!("unable to heal object {}/{}-v({})", bucket, version.name, version_id);
@@ -3876,7 +3912,7 @@ impl ObjectIO for SetDisks {
 
         let is_inline_buffer = {
             if let Some(sc) = GLOBAL_StorageClass.get() {
-                sc.should_inline(erasure.shard_file_size(data.content_length), opts.versioned)
+                sc.should_inline(erasure.shard_file_size(data.size()), opts.versioned)
             } else {
                 false
             }
@@ -3891,7 +3927,7 @@ impl ObjectIO for SetDisks {
                     Some(disk),
                     RUSTFS_META_TMP_BUCKET,
                     &tmp_object,
-                    erasure.shard_file_size(data.content_length),
+                    erasure.shard_file_size(data.size()),
                     erasure.shard_size(),
                     HashAlgorithm::HighwayHash256,
                 )
@@ -3937,15 +3973,34 @@ impl ObjectIO for SetDisks {
             return Err(Error::other(format!("not enough disks to write: {:?}", errors)));
         }
 
-        let stream = mem::replace(&mut data.stream, HashReader::new(Box::new(Cursor::new(Vec::new())), 0, 0, None, false)?);
+        let stream = mem::replace(
+            &mut data.stream,
+            HashReader::new(Box::new(WarpReader::new(Cursor::new(Vec::new()))), 0, 0, None, false)?,
+        );
 
-        let (reader, w_size) = Arc::new(erasure).encode(stream, &mut writers, write_quorum).await?; // TODO: 出错，删除临时目录
+        let (reader, w_size) = match Arc::new(erasure).encode(stream, &mut writers, write_quorum).await {
+            Ok((r, w)) => (r, w),
+            Err(e) => {
+                error!("encode err {:?}", e);
+                return Err(e.into());
+            }
+        }; // TODO: 出错，删除临时目录
 
         let _ = mem::replace(&mut data.stream, reader);
         // if let Err(err) = close_bitrot_writers(&mut writers).await {
         //     error!("close_bitrot_writers err {:?}", err);
         // }
 
+        if (w_size as i64) < data.size() {
+            return Err(Error::other("put_object write size < data.size()"));
+        }
+
+        if user_defined.contains_key(&format!("{}compression", RESERVED_METADATA_PREFIX_LOWER)) {
+            user_defined.insert(format!("{}compression-size", RESERVED_METADATA_PREFIX_LOWER), w_size.to_string());
+        }
+
+        let index_op = data.stream.try_get_index().map(|v| v.clone().into_vec());
+
         //TODO: userDefined
 
         let etag = data.stream.try_resolve_etag().unwrap_or_default();
@@ -3956,6 +4011,14 @@ impl ObjectIO for SetDisks {
             //  get content-type
         }
 
+        let mut actual_size = data.actual_size();
+        if actual_size < 0 {
+            let is_compressed = fi.is_compressed();
+            if !is_compressed {
+                actual_size = w_size as i64;
+            }
+        }
+
         if let Some(sc) = user_defined.get(AMZ_STORAGE_CLASS) {
             if sc == storageclass::STANDARD {
                 let _ = user_defined.remove(AMZ_STORAGE_CLASS);
@@ -3967,19 +4030,21 @@ impl ObjectIO for SetDisks {
         for (i, fi) in parts_metadatas.iter_mut().enumerate() {
             if is_inline_buffer {
                 if let Some(writer) = writers[i].take() {
-                    fi.data = Some(writer.into_inline_data().unwrap_or_default());
+                    fi.data = Some(writer.into_inline_data().map(bytes::Bytes::from).unwrap_or_default());
                 }
+
+                fi.set_inline_data();
             }
 
             fi.metadata = user_defined.clone();
             fi.mod_time = Some(now);
-            fi.size = w_size;
+            fi.size = w_size as i64;
             fi.versioned = opts.versioned || opts.version_suspended;
-            fi.add_object_part(1, etag.clone(), w_size, fi.mod_time, w_size);
+            fi.add_object_part(1, etag.clone(), w_size, fi.mod_time, actual_size, index_op.clone());
 
-            fi.set_inline_data();
-
-            // debug!("put_object fi {:?}", &fi)
+            if opts.data_movement {
+                fi.set_data_moved();
+        }
         }
 
         let (online_disks, _, op_old_dir) = Self::rename_data(
@@ -4036,7 +4101,7 @@ impl StorageAPI for SetDisks {
     async fn local_storage_info(&self) -> madmin::StorageInfo {
         let disks = self.get_disks_internal().await;
 
-        let mut local_disks: Vec<Option<Arc<crate::disk::Disk>>> = Vec::new();
+        let mut local_disks: Vec<Option<Arc<disk::Disk>>> = Vec::new();
         let mut local_endpoints = Vec::new();
 
         for (i, ep) in self.set_endpoints.iter().enumerate() {
@@ -4843,7 +4908,7 @@ impl StorageAPI for SetDisks {
                     Some(disk),
                     RUSTFS_META_TMP_BUCKET,
                     &tmp_part_path,
-                    erasure.shard_file_size(data.content_length),
+                    erasure.shard_file_size(data.size()),
                     erasure.shard_size(),
                     HashAlgorithm::HighwayHash256,
                 )
@@ -4882,16 +4947,33 @@ impl StorageAPI for SetDisks {
             return Err(Error::other(format!("not enough disks to write: {:?}", errors)));
         }
 
-        let stream = mem::replace(&mut data.stream, HashReader::new(Box::new(Cursor::new(Vec::new())), 0, 0, None, false)?);
+        let stream = mem::replace(
+            &mut data.stream,
+            HashReader::new(Box::new(WarpReader::new(Cursor::new(Vec::new()))), 0, 0, None, false)?,
+        );
 
         let (reader, w_size) = Arc::new(erasure).encode(stream, &mut writers, write_quorum).await?; // TODO: 出错，删除临时目录
 
         let _ = mem::replace(&mut data.stream, reader);
 
+        if (w_size as i64) < data.size() {
+            return Err(Error::other("put_object_part write size < data.size()"));
+        }
+
+        let index_op = data.stream.try_get_index().map(|v| v.clone().into_vec());
+
         let mut etag = data.stream.try_resolve_etag().unwrap_or_default();
 
         if let Some(ref tag) = opts.preserve_etag {
-            etag = tag.clone(); // TODO: 需要验证 etag 是否一致
+            etag = tag.clone();
+        }
+
+        let mut actual_size = data.actual_size();
+        if actual_size < 0 {
+            let is_compressed = fi.is_compressed();
+            if !is_compressed {
+                actual_size = w_size as i64;
+            }
         }
 
         let part_info = ObjectPartInfo {
@@ -4899,7 +4981,8 @@ impl StorageAPI for SetDisks {
             number: part_id,
             size: w_size,
             mod_time: Some(OffsetDateTime::now_utc()),
-            actual_size: data.content_length,
+            actual_size,
+            index: index_op,
             ..Default::default()
         };
 
@@ -4916,7 +4999,7 @@ impl StorageAPI for SetDisks {
             &tmp_part_path,
             RUSTFS_META_MULTIPART_BUCKET,
             &part_path,
-            fi_buff,
+            fi_buff.into(),
             write_quorum,
         )
         .await?;
@@ -4926,6 +5009,7 @@ impl StorageAPI for SetDisks {
             part_num: part_id,
             last_mod: Some(OffsetDateTime::now_utc()),
             size: w_size,
+            actual_size,
         };
 
         // error!("put_object_part ret {:?}", &ret);
@@ -5209,7 +5293,7 @@ impl StorageAPI for SetDisks {
     // complete_multipart_upload 完成
     #[tracing::instrument(skip(self))]
     async fn complete_multipart_upload(
-        &self,
+        self: Arc<Self>,
         bucket: &str,
         object: &str,
         upload_id: &str,
@@ -5251,12 +5335,15 @@ impl StorageAPI for SetDisks {
         for (i, res) in part_files_resp.iter().enumerate() {
             let part_id = uploaded_parts[i].part_num;
             if !res.error.is_empty() || !res.exists {
-                // error!("complete_multipart_upload part_id err {:?}", res);
+                error!("complete_multipart_upload part_id err {:?}, exists={}", res, res.exists);
                 return Err(Error::InvalidPart(part_id, bucket.to_owned(), object.to_owned()));
             }
 
-            let part_fi = FileInfo::unmarshal(&res.data).map_err(|_e| {
-                // error!("complete_multipart_upload FileInfo::unmarshal err {:?}", e);
+            let part_fi = FileInfo::unmarshal(&res.data).map_err(|e| {
+                error!(
+                    "complete_multipart_upload FileInfo::unmarshal err {:?}, part_id={}, bucket={}, object={}",
+                    e, part_id, bucket, object
+                );
                 Error::InvalidPart(part_id, bucket.to_owned(), object.to_owned())
             })?;
             let part = &part_fi.parts[0];
@@ -5266,11 +5353,18 @@ impl StorageAPI for SetDisks {
             // debug!("complete part {} object info {:?}", part_num, &part);
 
             if part_id != part_num {
-                // error!("complete_multipart_upload part_id err part_id != part_num {} != {}", part_id, part_num);
+                error!("complete_multipart_upload part_id err part_id != part_num {} != {}", part_id, part_num);
                 return Err(Error::InvalidPart(part_id, bucket.to_owned(), object.to_owned()));
             }
 
-            fi.add_object_part(part.number, part.etag.clone(), part.size, part.mod_time, part.actual_size);
+            fi.add_object_part(
+                part.number,
+                part.etag.clone(),
+                part.size,
+                part.mod_time,
+                part.actual_size,
+                part.index.clone(),
+            );
         }
 
         let (shuffle_disks, mut parts_metadatas) = Self::shuffle_disks_and_parts_metadata_by_index(&disks, &files_metas, &fi);
@@ -5280,24 +5374,35 @@ impl StorageAPI for SetDisks {
         fi.parts = Vec::with_capacity(uploaded_parts.len());
 
         let mut object_size: usize = 0;
-        let mut object_actual_size: usize = 0;
+        let mut object_actual_size: i64 = 0;
 
         for (i, p) in uploaded_parts.iter().enumerate() {
             let has_part = curr_fi.parts.iter().find(|v| v.number == p.part_num);
             if has_part.is_none() {
-                // error!("complete_multipart_upload has_part.is_none() {:?}", has_part);
+                error!(
+                    "complete_multipart_upload has_part.is_none() {:?}, part_id={}, bucket={}, object={}",
+                    has_part, p.part_num, bucket, object
+                );
                 return Err(Error::InvalidPart(p.part_num, "".to_owned(), p.etag.clone().unwrap_or_default()));
             }
 
             let ext_part = &curr_fi.parts[i];
 
             if p.etag != Some(ext_part.etag.clone()) {
+                error!(
+                    "complete_multipart_upload etag err {:?}, part_id={}, bucket={}, object={}",
+                    p.etag, p.part_num, bucket, object
+                );
                 return Err(Error::InvalidPart(p.part_num, ext_part.etag.clone(), p.etag.clone().unwrap_or_default()));
             }
 
             // TODO: crypto
 
-            if (i < uploaded_parts.len() - 1) && !is_min_allowed_part_size(ext_part.size) {
+            if (i < uploaded_parts.len() - 1) && !is_min_allowed_part_size(ext_part.actual_size) {
+                error!(
+                    "complete_multipart_upload is_min_allowed_part_size err {:?}, part_id={}, bucket={}, object={}",
+                    ext_part.actual_size, p.part_num, bucket, object
+                );
                 return Err(Error::InvalidPart(p.part_num, ext_part.etag.clone(), p.etag.clone().unwrap_or_default()));
             }
 
@@ -5310,11 +5415,12 @@ impl StorageAPI for SetDisks {
                 size: ext_part.size,
                 mod_time: ext_part.mod_time,
                 actual_size: ext_part.actual_size,
+                index: ext_part.index.clone(),
                 ..Default::default()
             });
         }
 
-        fi.size = object_size;
+        fi.size = object_size as i64;
         fi.mod_time = opts.mod_time;
         if fi.mod_time.is_none() {
             fi.mod_time = Some(OffsetDateTime::now_utc());
@@ -5331,6 +5437,18 @@ impl StorageAPI for SetDisks {
 
         fi.metadata.insert("etag".to_owned(), etag);
 
+        fi.metadata
+            .insert(format!("{}actual-size", RESERVED_METADATA_PREFIX_LOWER), object_actual_size.to_string());
+
+        if fi.is_compressed() {
+            fi.metadata
+                .insert(format!("{}compression-size", RESERVED_METADATA_PREFIX_LOWER), object_size.to_string());
+        }
+
+        if opts.data_movement {
+            fi.set_data_moved();
+        }
+
         // TODO: object_actual_size
         let _ = object_actual_size;
 
@@ -5402,17 +5520,6 @@ impl StorageAPI for SetDisks {
         )
         .await?;
 
-        for (i, op_disk) in online_disks.iter().enumerate() {
-            if let Some(disk) = op_disk {
-                if disk.is_online().await {
-                    fi = parts_metadatas[i].clone();
-                    break;
-                }
-            }
-        }
-
-        fi.is_latest = true;
-
         // debug!("complete fileinfo {:?}", &fi);
 
         // TODO: reduce_common_data_dir
@@ -5434,7 +5541,22 @@ impl StorageAPI for SetDisks {
                 .await;
         }
 
-        let _ = self.delete_all(RUSTFS_META_MULTIPART_BUCKET, &upload_id_path).await;
+        let upload_id_path = upload_id_path.clone();
+        let store = self.clone();
+        let _cleanup_handle = tokio::spawn(async move {
+            let _ = store.delete_all(RUSTFS_META_MULTIPART_BUCKET, &upload_id_path).await;
+        });
+
+        for (i, op_disk) in online_disks.iter().enumerate() {
+            if let Some(disk) = op_disk {
+                if disk.is_online().await {
+                    fi = parts_metadatas[i].clone();
+                    break;
+                }
+            }
+        }
+
+        fi.is_latest = true;
 
         Ok(ObjectInfo::from_file_info(&fi, bucket, object, opts.versioned || opts.version_suspended))
     }
@@ -5794,7 +5916,7 @@ async fn disks_with_all_parts(
                 let verify_err = bitrot_verify(
                     Box::new(Cursor::new(data.clone())),
                     data_len,
-                    meta.erasure.shard_file_size(meta.size),
+                    meta.erasure.shard_file_size(meta.size) as usize,
                     checksum_info.algorithm,
                     checksum_info.hash,
                     meta.erasure.shard_size(),
@@ -6006,8 +6128,8 @@ pub async fn stat_all_dirs(disks: &[Option<DiskStore>], bucket: &str, prefix: &s
 }
 
 const GLOBAL_MIN_PART_SIZE: ByteSize = ByteSize::mib(5);
-fn is_min_allowed_part_size(size: usize) -> bool {
-    size as u64 >= GLOBAL_MIN_PART_SIZE.as_u64()
+fn is_min_allowed_part_size(size: i64) -> bool {
+    size >= GLOBAL_MIN_PART_SIZE.as_u64() as i64
 }
 
 fn get_complete_multipart_md5(parts: &[CompletePart]) -> String {
diff --git a/ecstore/src/sets.rs b/ecstore/src/sets.rs
index c5343757..676af12a 100644
--- a/ecstore/src/sets.rs
+++ b/ecstore/src/sets.rs
@@ -651,7 +651,7 @@ impl StorageAPI for Sets {
 
     #[tracing::instrument(skip(self))]
     async fn complete_multipart_upload(
-        &self,
+        self: Arc<Self>,
         bucket: &str,
         object: &str,
         upload_id: &str,
diff --git a/ecstore/src/store.rs b/ecstore/src/store.rs
index 62fe0a60..1a85d6e1 100644
--- a/ecstore/src/store.rs
+++ b/ecstore/src/store.rs
@@ -31,7 +31,7 @@ use crate::{
     bucket::{lifecycle::bucket_lifecycle_ops::TransitionState, metadata::BucketMetadata},
     disk::{BUCKET_META_PREFIX, DiskOption, DiskStore, RUSTFS_META_BUCKET, new_disk},
     endpoints::EndpointServerPools,
-    peer::S3PeerSys,
+    rpc::S3PeerSys,
     sets::Sets,
     store_api::{
         BucketInfo, BucketOptions, CompletePart, DeleteBucketOptions, DeletedObject, GetObjectReader, HTTPRangeSpec,
@@ -53,6 +53,7 @@ use rustfs_utils::crypto::base64_decode;
 use rustfs_utils::path::{SLASH_SEPARATOR, decode_dir_object, encode_dir_object, path_join_buf};
 use s3s::dto::{BucketVersioningStatus, ObjectLockConfiguration, ObjectLockEnabled, VersioningConfiguration};
 use std::cmp::Ordering;
+use std::net::SocketAddr;
 use std::process::exit;
 use std::slice::Iter;
 use std::time::SystemTime;
@@ -101,7 +102,7 @@ pub struct ECStore {
 impl ECStore {
     #[allow(clippy::new_ret_no_self)]
     #[tracing::instrument(level = "debug", skip(endpoint_pools))]
-    pub async fn new(_address: String, endpoint_pools: EndpointServerPools) -> Result<Arc<Self>> {
+    pub async fn new(address: SocketAddr, endpoint_pools: EndpointServerPools) -> Result<Arc<Self>> {
         // let layouts = DisksLayout::from_volumes(endpoints.as_slice())?;
 
         let mut deployment_id = None;
@@ -115,12 +116,17 @@ impl ECStore {
 
         let mut local_disks = Vec::new();
 
-        init_local_peer(
-            &endpoint_pools,
-            &GLOBAL_Rustfs_Host.read().await.to_string(),
-            &GLOBAL_Rustfs_Port.read().await.to_string(),
-        )
-        .await;
+        info!("ECStore new address: {}", address.to_string());
+        let mut host = address.ip().to_string();
+        if host.is_empty() {
+            host = GLOBAL_Rustfs_Host.read().await.to_string()
+        }
+        let mut port = address.port().to_string();
+        if port.is_empty() {
+            port = GLOBAL_Rustfs_Port.read().await.to_string()
+        }
+        info!("ECStore new host: {}, port: {}", host, port);
+        init_local_peer(&endpoint_pools, &host, &port).await;
 
         // debug!("endpoint_pools: {:?}", endpoint_pools);
 
@@ -856,9 +862,26 @@ impl ECStore {
         let (update_closer_tx, mut update_close_rx) = mpsc::channel(10);
         let mut ctx_clone = cancel.subscribe();
         let all_buckets_clone = all_buckets.clone();
+        // 新增：从环境变量读取interval，默认30秒
+        let ns_scanner_interval_secs = std::env::var("RUSTFS_NS_SCANNER_INTERVAL")
+            .ok()
+            .and_then(|v| v.parse::<u64>().ok())
+            .unwrap_or(30);
+
+        // 检查是否跳过后台任务
+        let skip_background_task = std::env::var("RUSTFS_SKIP_BACKGROUND_TASK")
+            .ok()
+            .and_then(|v| v.parse::<bool>().ok())
+            .unwrap_or(false);
+
+        if skip_background_task {
+            info!("跳过后台任务执行: RUSTFS_SKIP_BACKGROUND_TASK=true");
+            return Ok(());
+        }
+
         let task = tokio::spawn(async move {
             let mut last_update: Option<SystemTime> = None;
-            let mut interval = interval(Duration::from_secs(30));
+            let mut interval = interval(Duration::from_secs(ns_scanner_interval_secs));
             let all_merged = Arc::new(RwLock::new(DataUsageCache::default()));
             loop {
                 select! {
@@ -1225,7 +1248,7 @@ impl ObjectIO for ECStore {
             return self.pools[0].put_object(bucket, object.as_str(), data, opts).await;
         }
 
-        let idx = self.get_pool_idx(bucket, &object, data.content_length as i64).await?;
+        let idx = self.get_pool_idx(bucket, &object, data.size()).await?;
 
         if opts.data_movement && idx == opts.src_pool_idx {
             return Err(StorageError::DataMovementOverwriteErr(
@@ -1500,9 +1523,7 @@ impl StorageAPI for ECStore {
 
         // TODO: nslock
 
-        let pool_idx = self
-            .get_pool_idx_no_lock(src_bucket, &src_object, src_info.size as i64)
-            .await?;
+        let pool_idx = self.get_pool_idx_no_lock(src_bucket, &src_object, src_info.size).await?;
 
         if cp_src_dst_same {
             if let (Some(src_vid), Some(dst_vid)) = (&src_opts.version_id, &dst_opts.version_id) {
@@ -2029,7 +2050,7 @@ impl StorageAPI for ECStore {
 
     #[tracing::instrument(skip(self))]
     async fn complete_multipart_upload(
-        &self,
+        self: Arc<Self>,
         bucket: &str,
         object: &str,
         upload_id: &str,
@@ -2040,6 +2061,7 @@ impl StorageAPI for ECStore {
 
         if self.single_pool() {
             return self.pools[0]
+                .clone()
                 .complete_multipart_upload(bucket, object, upload_id, uploaded_parts, opts)
                 .await;
         }
@@ -2049,6 +2071,7 @@ impl StorageAPI for ECStore {
                 continue;
             }
 
+            let pool = pool.clone();
             let err = match pool
                 .complete_multipart_upload(bucket, object, upload_id, uploaded_parts.clone(), opts)
                 .await
diff --git a/ecstore/src/store_api.rs b/ecstore/src/store_api.rs
index 2fac857b..913556b2 100644
--- a/ecstore/src/store_api.rs
+++ b/ecstore/src/store_api.rs
@@ -12,24 +12,24 @@ use crate::{
 use crate::{disk::DiskStore, heal::heal_commands::HealOpts};
 use http::{HeaderMap, HeaderValue};
 use madmin::heal_commands::HealResultItem;
+use rustfs_filemeta::headers::RESERVED_METADATA_PREFIX_LOWER;
 use rustfs_filemeta::{FileInfo, MetaCacheEntriesSorted, ObjectPartInfo, headers::AMZ_OBJECT_TAGGING};
-use rustfs_rio::{HashReader, Reader};
+use rustfs_rio::{DecompressReader, HashReader, LimitReader, WarpReader};
+use rustfs_utils::CompressionAlgorithm;
 use rustfs_utils::path::decode_dir_object;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fmt::Debug;
 use std::io::Cursor;
+use std::str::FromStr as _;
 use std::sync::Arc;
 use time::OffsetDateTime;
-use tokio::io::AsyncReadExt;
+use tokio::io::{AsyncRead, AsyncReadExt};
+use tracing::warn;
 use uuid::Uuid;
 
 pub const ERASURE_ALGORITHM: &str = "rs-vandermonde";
 pub const BLOCK_SIZE_V2: usize = 1024 * 1024; // 1M
-pub const RESERVED_METADATA_PREFIX: &str = "X-Rustfs-Internal-";
-pub const RESERVED_METADATA_PREFIX_LOWER: &str = "x-rustfs-internal-";
-pub const RUSTFS_HEALING: &str = "X-Rustfs-Internal-healing";
-pub const RUSTFS_DATA_MOVE: &str = "X-Rustfs-Internal-data-mov";
 
 #[derive(Debug, Default, Serialize, Deserialize)]
 pub struct MakeBucketOptions {
@@ -58,46 +58,50 @@ pub struct DeleteBucketOptions {
 
 pub struct PutObjReader {
     pub stream: HashReader,
-    pub content_length: usize,
 }
 
 impl Debug for PutObjReader {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("PutObjReader")
-            .field("content_length", &self.content_length)
-            .finish()
+        f.debug_struct("PutObjReader").finish()
     }
 }
 
 impl PutObjReader {
-    pub fn new(stream: HashReader, content_length: usize) -> Self {
-        PutObjReader { stream, content_length }
+    pub fn new(stream: HashReader) -> Self {
+        PutObjReader { stream }
     }
 
     pub fn from_vec(data: Vec<u8>) -> Self {
-        let content_length = data.len();
+        let content_length = data.len() as i64;
         PutObjReader {
-            stream: HashReader::new(Box::new(Cursor::new(data)), content_length as i64, content_length as i64, None, false)
+            stream: HashReader::new(Box::new(WarpReader::new(Cursor::new(data))), content_length, content_length, None, false)
                 .unwrap(),
-            content_length,
         }
     }
+
+    pub fn size(&self) -> i64 {
+        self.stream.size()
+    }
+
+    pub fn actual_size(&self) -> i64 {
+        self.stream.actual_size()
+    }
 }
 
 pub struct GetObjectReader {
-    pub stream: Box<dyn Reader>,
+    pub stream: Box<dyn AsyncRead + Unpin + Send + Sync>,
     pub object_info: ObjectInfo,
 }
 
 impl GetObjectReader {
     #[tracing::instrument(level = "debug", skip(reader))]
     pub fn new(
-        reader: Box<dyn Reader>,
+        reader: Box<dyn AsyncRead + Unpin + Send + Sync>,
         rs: Option<HTTPRangeSpec>,
         oi: &ObjectInfo,
         opts: &ObjectOptions,
         _h: &HeaderMap<HeaderValue>,
-    ) -> Result<(Self, usize, usize)> {
+    ) -> Result<(Self, usize, i64)> {
         let mut rs = rs;
 
         if let Some(part_number) = opts.part_number {
@@ -106,6 +110,47 @@ impl GetObjectReader {
             }
         }
 
+        // TODO:Encrypted
+
+        let (algo, is_compressed) = oi.is_compressed_ok()?;
+
+        // TODO: check TRANSITION
+
+        if is_compressed {
+            let actual_size = oi.get_actual_size()?;
+            let (off, length) = (0, oi.size);
+            let (_dec_off, dec_length) = (0, actual_size);
+            if let Some(_rs) = rs {
+                // TODO: range spec is not supported for compressed object
+                return Err(Error::other("The requested range is not satisfiable"));
+                // let (off, length) = rs.get_offset_length(actual_size)?;
+            }
+
+            let dec_reader = DecompressReader::new(reader, algo);
+
+            let actual_size = if actual_size > 0 {
+                actual_size as usize
+            } else {
+                return Err(Error::other(format!("invalid decompressed size {}", actual_size)));
+            };
+
+            warn!("actual_size: {}", actual_size);
+            let dec_reader = LimitReader::new(dec_reader, actual_size);
+
+            let mut oi = oi.clone();
+            oi.size = dec_length;
+
+            warn!("oi.size: {}, off: {}, length: {}", oi.size, off, length);
+            return Ok((
+                GetObjectReader {
+                    stream: Box::new(dec_reader),
+                    object_info: oi,
+                },
+                off,
+                length,
+            ));
+        }
+
         if let Some(rs) = rs {
             let (off, length) = rs.get_offset_length(oi.size)?;
 
@@ -147,8 +192,8 @@ impl GetObjectReader {
 #[derive(Debug)]
 pub struct HTTPRangeSpec {
     pub is_suffix_length: bool,
-    pub start: usize,
-    pub end: Option<usize>,
+    pub start: i64,
+    pub end: i64,
 }
 
 impl HTTPRangeSpec {
@@ -157,29 +202,38 @@ impl HTTPRangeSpec {
             return None;
         }
 
-        let mut start = 0;
-        let mut end = -1;
+        let mut start = 0i64;
+        let mut end = -1i64;
         for i in 0..oi.parts.len().min(part_number) {
             start = end + 1;
-            end = start + oi.parts[i].size as i64 - 1
+            end = start + (oi.parts[i].size as i64) - 1
         }
 
         Some(HTTPRangeSpec {
             is_suffix_length: false,
-            start: start as usize,
-            end: { if end < 0 { None } else { Some(end as usize) } },
+            start,
+            end,
         })
     }
 
-    pub fn get_offset_length(&self, res_size: usize) -> Result<(usize, usize)> {
+    pub fn get_offset_length(&self, res_size: i64) -> Result<(usize, i64)> {
         let len = self.get_length(res_size)?;
+
         let mut start = self.start;
         if self.is_suffix_length {
-            start = res_size - self.start
+            start = res_size + self.start;
+
+            if start < 0 {
+                start = 0;
+            }
         }
-        Ok((start, len))
+        Ok((start as usize, len))
     }
-    pub fn get_length(&self, res_size: usize) -> Result<usize> {
+    pub fn get_length(&self, res_size: i64) -> Result<i64> {
+        if res_size < 0 {
+            return Err(Error::other("The requested range is not satisfiable"));
+        }
+
         if self.is_suffix_length {
             let specified_len = self.start; // 假设 h.start 是一个 i64 类型
             let mut range_length = specified_len;
@@ -195,8 +249,8 @@ impl HTTPRangeSpec {
             return Err(Error::other("The requested range is not satisfiable"));
         }
 
-        if let Some(end) = self.end {
-            let mut end = end;
+        if self.end > -1 {
+            let mut end = self.end;
             if res_size <= end {
                 end = res_size - 1;
             }
@@ -205,7 +259,7 @@ impl HTTPRangeSpec {
             return Ok(range_length);
         }
 
-        if self.end.is_none() {
+        if self.end == -1 {
             let range_length = res_size - self.start;
             return Ok(range_length);
         }
@@ -285,6 +339,7 @@ pub struct PartInfo {
     pub last_mod: Option<OffsetDateTime>,
     pub size: usize,
     pub etag: Option<String>,
+    pub actual_size: i64,
 }
 
 #[derive(Debug, Clone, Default)]
@@ -307,9 +362,9 @@ pub struct ObjectInfo {
     pub bucket: String,
     pub name: String,
     pub mod_time: Option<OffsetDateTime>,
-    pub size: usize,
+    pub size: i64,
     // Actual size is the real size of the object uploaded by client.
-    pub actual_size: Option<usize>,
+    pub actual_size: i64,
     pub is_dir: bool,
     pub user_defined: Option<HashMap<String, String>>,
     pub parity_blocks: usize,
@@ -375,27 +430,41 @@ impl Clone for ObjectInfo {
 impl ObjectInfo {
     pub fn is_compressed(&self) -> bool {
         if let Some(meta) = &self.user_defined {
-            meta.contains_key(&format!("{}compression", RESERVED_METADATA_PREFIX))
+            meta.contains_key(&format!("{}compression", RESERVED_METADATA_PREFIX_LOWER))
         } else {
             false
         }
     }
 
+    pub fn is_compressed_ok(&self) -> Result<(CompressionAlgorithm, bool)> {
+        let scheme = self
+            .user_defined
+            .as_ref()
+            .and_then(|meta| meta.get(&format!("{}compression", RESERVED_METADATA_PREFIX_LOWER)).cloned());
+
+        if let Some(scheme) = scheme {
+            let algorithm = CompressionAlgorithm::from_str(&scheme)?;
+            Ok((algorithm, true))
+        } else {
+            Ok((CompressionAlgorithm::None, false))
+        }
+    }
+
     pub fn is_multipart(&self) -> bool {
         self.etag.as_ref().is_some_and(|v| v.len() != 32)
     }
 
-    pub fn get_actual_size(&self) -> std::io::Result<usize> {
-        if let Some(actual_size) = self.actual_size {
-            return Ok(actual_size);
+    pub fn get_actual_size(&self) -> std::io::Result<i64> {
+        if self.actual_size > 0 {
+            return Ok(self.actual_size);
         }
 
         if self.is_compressed() {
             if let Some(meta) = &self.user_defined {
-                if let Some(size_str) = meta.get(&format!("{}actual-size", RESERVED_METADATA_PREFIX)) {
+                if let Some(size_str) = meta.get(&format!("{}actual-size", RESERVED_METADATA_PREFIX_LOWER)) {
                     if !size_str.is_empty() {
                         // Todo: deal with error
-                        let size = size_str.parse::<usize>().map_err(|e| std::io::Error::other(e.to_string()))?;
+                        let size = size_str.parse::<i64>().map_err(|e| std::io::Error::other(e.to_string()))?;
                         return Ok(size);
                     }
                 }
@@ -406,8 +475,9 @@ impl ObjectInfo {
                 actual_size += part.actual_size;
             });
             if actual_size == 0 && actual_size != self.size {
-                return Err(std::io::Error::other("invalid decompressed size"));
+                return Err(std::io::Error::other(format!("invalid decompressed size {} {}", actual_size, self.size)));
             }
+
             return Ok(actual_size);
         }
 
@@ -827,7 +897,7 @@ pub trait StorageAPI: ObjectIO {
     // ListObjectParts
     async fn abort_multipart_upload(&self, bucket: &str, object: &str, upload_id: &str, opts: &ObjectOptions) -> Result<()>;
     async fn complete_multipart_upload(
-        &self,
+        self: Arc<Self>,
         bucket: &str,
         object: &str,
         upload_id: &str,
diff --git a/ecstore/src/store_init.rs b/ecstore/src/store_init.rs
index 68a6b72b..97c23cb0 100644
--- a/ecstore/src/store_init.rs
+++ b/ecstore/src/store_init.rs
@@ -256,7 +256,7 @@ pub async fn load_format_erasure(disk: &DiskStore, heal: bool) -> disk::error::R
             _ => e,
         })?;
 
-    let mut fm = FormatV3::try_from(data.as_slice())?;
+    let mut fm = FormatV3::try_from(data.as_ref())?;
 
     if heal {
         let info = disk
@@ -311,7 +311,7 @@ pub async fn save_format_file(disk: &Option<DiskStore>, format: &Option<FormatV3
     let tmpfile = Uuid::new_v4().to_string();
 
     let disk = disk.as_ref().unwrap();
-    disk.write_all(RUSTFS_META_BUCKET, tmpfile.as_str(), json_data.into_bytes())
+    disk.write_all(RUSTFS_META_BUCKET, tmpfile.as_str(), json_data.into_bytes().into())
         .await?;
 
     disk.rename_file(RUSTFS_META_BUCKET, tmpfile.as_str(), RUSTFS_META_BUCKET, FORMAT_CONFIG_FILE)
diff --git a/ecstore/src/store_list_objects.rs b/ecstore/src/store_list_objects.rs
index c3bd38d9..4aed6cab 100644
--- a/ecstore/src/store_list_objects.rs
+++ b/ecstore/src/store_list_objects.rs
@@ -7,10 +7,10 @@ use crate::disk::{DiskInfo, DiskStore};
 use crate::error::{
     Error, Result, StorageError, is_all_not_found, is_all_volume_not_found, is_err_bucket_not_found, to_object_err,
 };
-use crate::peer::is_reserved_or_invalid_bucket;
 use crate::set_disk::SetDisks;
 use crate::store::check_list_objs_args;
 use crate::store_api::{ListObjectVersionsInfo, ListObjectsInfo, ObjectInfo, ObjectOptions};
+use crate::store_utils::is_reserved_or_invalid_bucket;
 use crate::{store::ECStore, store_api::ListObjectsV2Info};
 use futures::future::join_all;
 use rand::seq::SliceRandom;
@@ -364,6 +364,7 @@ impl ECStore {
         max_keys: i32,
     ) -> Result<ListObjectVersionsInfo> {
         if marker.is_none() && version_marker.is_some() {
+            warn!("inner_list_object_versions: marker is none and version_marker is some");
             return Err(StorageError::NotImplemented);
         }
 
diff --git a/ecstore/src/store_utils.rs b/ecstore/src/store_utils.rs
index 06edaacb..5ba5b1f4 100644
--- a/ecstore/src/store_utils.rs
+++ b/ecstore/src/store_utils.rs
@@ -1,7 +1,10 @@
 use crate::config::storageclass::STANDARD;
+use crate::disk::RUSTFS_META_BUCKET;
+use regex::Regex;
 use rustfs_filemeta::headers::AMZ_OBJECT_TAGGING;
 use rustfs_filemeta::headers::AMZ_STORAGE_CLASS;
 use std::collections::HashMap;
+use std::io::{Error, Result};
 
 pub fn clean_metadata(metadata: &mut HashMap<String, String>) {
     remove_standard_storage_class(metadata);
@@ -19,3 +22,60 @@ pub fn clean_metadata_keys(metadata: &mut HashMap<String, String>, key_names: &[
         metadata.remove(key.to_owned());
     }
 }
+
+// 检查是否为  元数据桶
+fn is_meta_bucket(bucket_name: &str) -> bool {
+    bucket_name == RUSTFS_META_BUCKET
+}
+
+// 检查是否为 保留桶
+fn is_reserved_bucket(bucket_name: &str) -> bool {
+    bucket_name == "rustfs"
+}
+
+// 检查桶名是否为保留名或无效名
+pub fn is_reserved_or_invalid_bucket(bucket_entry: &str, strict: bool) -> bool {
+    if bucket_entry.is_empty() {
+        return true;
+    }
+
+    let bucket_entry = bucket_entry.trim_end_matches('/');
+    let result = check_bucket_name(bucket_entry, strict).is_err();
+
+    result || is_meta_bucket(bucket_entry) || is_reserved_bucket(bucket_entry)
+}
+
+// 检查桶名是否有效
+fn check_bucket_name(bucket_name: &str, strict: bool) -> Result<()> {
+    if bucket_name.trim().is_empty() {
+        return Err(Error::other("Bucket name cannot be empty"));
+    }
+    if bucket_name.len() < 3 {
+        return Err(Error::other("Bucket name cannot be shorter than 3 characters"));
+    }
+    if bucket_name.len() > 63 {
+        return Err(Error::other("Bucket name cannot be longer than 63 characters"));
+    }
+
+    let ip_address_regex = Regex::new(r"^(\d+\.){3}\d+$").unwrap();
+    if ip_address_regex.is_match(bucket_name) {
+        return Err(Error::other("Bucket name cannot be an IP address"));
+    }
+
+    let valid_bucket_name_regex = if strict {
+        Regex::new(r"^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$").unwrap()
+    } else {
+        Regex::new(r"^[A-Za-z0-9][A-Za-z0-9\.\-_:]{1,61}[A-Za-z0-9]$").unwrap()
+    };
+
+    if !valid_bucket_name_regex.is_match(bucket_name) {
+        return Err(Error::other("Bucket name contains invalid characters"));
+    }
+
+    // 检查包含 "..", ".-", "-."
+    if bucket_name.contains("..") || bucket_name.contains(".-") || bucket_name.contains("-.") {
+        return Err(Error::other("Bucket name contains invalid characters"));
+    }
+
+    Ok(())
+}
diff --git a/iam/Cargo.toml b/iam/Cargo.toml
index 451344e3..f6132996 100644
--- a/iam/Cargo.toml
+++ b/iam/Cargo.toml
@@ -31,7 +31,8 @@ tracing.workspace = true
 madmin.workspace = true
 lazy_static.workspace = true
 regex = { workspace = true }
-rustfs-utils= { workspace = true, features = ["path"] }
+common.workspace = true
+rustfs-utils = { workspace = true, features = ["path"] }
 
 [dev-dependencies]
 test-case.workspace = true
diff --git a/iam/src/cache.rs b/iam/src/cache.rs
index b5dd20c3..6935054e 100644
--- a/iam/src/cache.rs
+++ b/iam/src/cache.rs
@@ -22,7 +22,7 @@ pub struct Cache {
     pub sts_accounts: ArcSwap<CacheEntity<UserIdentity>>,
     pub sts_policies: ArcSwap<CacheEntity<MappedPolicy>>,
     pub groups: ArcSwap<CacheEntity<GroupInfo>>,
-    pub user_group_memeberships: ArcSwap<CacheEntity<HashSet<String>>>,
+    pub user_group_memberships: ArcSwap<CacheEntity<HashSet<String>>>,
     pub group_policies: ArcSwap<CacheEntity<MappedPolicy>>,
 }
 
@@ -35,7 +35,7 @@ impl Default for Cache {
             sts_accounts: ArcSwap::new(Arc::new(CacheEntity::default())),
             sts_policies: ArcSwap::new(Arc::new(CacheEntity::default())),
             groups: ArcSwap::new(Arc::new(CacheEntity::default())),
-            user_group_memeberships: ArcSwap::new(Arc::new(CacheEntity::default())),
+            user_group_memberships: ArcSwap::new(Arc::new(CacheEntity::default())),
             group_policies: ArcSwap::new(Arc::new(CacheEntity::default())),
         }
     }
@@ -55,7 +55,8 @@ impl Cache {
     fn exec<T: Clone>(target: &ArcSwap<CacheEntity<T>>, t: OffsetDateTime, mut op: impl FnMut(&mut CacheEntity<T>)) {
         let mut cur = target.load();
         loop {
-            // 当前的更新时间晚于执行时间，说明后台任务加载完毕，不需要执行当前操作。
+            // If the current update time is later than the execution time,
+            // the background task is loaded and the current operation does not need to be performed.
             if cur.load_time >= t {
                 return;
             }
@@ -63,7 +64,7 @@ impl Cache {
             let mut new = CacheEntity::clone(&cur);
             op(&mut new);
 
-            // 使用 cas 原子替换内容
+            // Replace content with CAS atoms
             let prev = target.compare_and_swap(&*cur, Arc::new(new));
             let swapped = Self::ptr_eq(&*cur, &*prev);
             if swapped {
@@ -88,17 +89,17 @@ impl Cache {
 
     pub fn build_user_group_memberships(&self) {
         let groups = self.groups.load();
-        let mut user_group_memeberships = HashMap::new();
+        let mut user_group_memberships = HashMap::new();
         for (group_name, group) in groups.iter() {
             for user_name in &group.members {
-                user_group_memeberships
+                user_group_memberships
                     .entry(user_name.clone())
                     .or_insert_with(HashSet::new)
                     .insert(group_name.clone());
             }
         }
-        self.user_group_memeberships
-            .store(Arc::new(CacheEntity::new(user_group_memeberships)));
+        self.user_group_memberships
+            .store(Arc::new(CacheEntity::new(user_group_memberships)));
     }
 }
 
@@ -164,7 +165,7 @@ impl CacheInner {
 #[derive(Clone)]
 pub struct CacheEntity<T> {
     map: HashMap<String, T>,
-    /// 重新加载的时间
+    /// The time of the reload
     load_time: OffsetDateTime,
 }
 
@@ -215,7 +216,7 @@ pub struct CacheInner {
     pub sts_accounts: G<UserIdentity>,
     pub sts_policies: G<MappedPolicy>,
     pub groups: G<GroupInfo>,
-    pub user_group_memeberships: G<HashSet<String>>,
+    pub user_group_memberships: G<HashSet<String>>,
     pub group_policies: G<MappedPolicy>,
 }
 
@@ -228,7 +229,7 @@ impl From<&Cache> for CacheInner {
             sts_accounts: value.sts_accounts.load(),
             sts_policies: value.sts_policies.load(),
             groups: value.groups.load(),
-            user_group_memeberships: value.user_group_memeberships.load(),
+            user_group_memberships: value.user_group_memberships.load(),
             group_policies: value.group_policies.load(),
         }
     }
diff --git a/iam/src/lib.rs b/iam/src/lib.rs
index 3aa1259e..8f3fd6b0 100644
--- a/iam/src/lib.rs
+++ b/iam/src/lib.rs
@@ -1,7 +1,6 @@
 use crate::error::{Error, Result};
 use ecstore::store::ECStore;
 use manager::IamCache;
-use policy::auth::Credentials;
 use std::sync::{Arc, OnceLock};
 use store::object::ObjectStore;
 use sys::IamSys;
@@ -17,39 +16,6 @@ pub mod sys;
 
 static IAM_SYS: OnceLock<Arc<IamSys<ObjectStore>>> = OnceLock::new();
 
-static GLOBAL_ACTIVE_CRED: OnceLock<Credentials> = OnceLock::new();
-
-pub fn init_global_action_cred(ak: Option<String>, sk: Option<String>) -> Result<()> {
-    let ak = {
-        if let Some(k) = ak {
-            k
-        } else {
-            utils::gen_access_key(20).unwrap_or_default()
-        }
-    };
-
-    let sk = {
-        if let Some(k) = sk {
-            k
-        } else {
-            utils::gen_secret_key(32).unwrap_or_default()
-        }
-    };
-
-    GLOBAL_ACTIVE_CRED
-        .set(Credentials {
-            access_key: ak,
-            secret_key: sk,
-            ..Default::default()
-        })
-        .unwrap();
-    Ok(())
-}
-
-pub fn get_global_action_cred() -> Option<Credentials> {
-    GLOBAL_ACTIVE_CRED.get().cloned()
-}
-
 #[instrument(skip(ecstore))]
 pub async fn init_iam_sys(ecstore: Arc<ECStore>) -> Result<()> {
     debug!("init iam system");
diff --git a/iam/src/manager.rs b/iam/src/manager.rs
index 23c10ecd..9551f455 100644
--- a/iam/src/manager.rs
+++ b/iam/src/manager.rs
@@ -2,14 +2,13 @@ use crate::error::{Error, Result, is_err_config_not_found};
 use crate::{
     cache::{Cache, CacheEntity},
     error::{Error as IamError, is_err_no_such_group, is_err_no_such_policy, is_err_no_such_user},
-    get_global_action_cred,
     store::{GroupInfo, MappedPolicy, Store, UserType, object::IAM_CONFIG_PREFIX},
     sys::{
         MAX_SVCSESSION_POLICY_SIZE, SESSION_POLICY_NAME, SESSION_POLICY_NAME_EXTRACTED, STATUS_DISABLED, STATUS_ENABLED,
         UpdateServiceAccountOpts,
     },
 };
-// use ecstore::utils::crypto::base64_encode;
+use ecstore::global::get_global_action_cred;
 use madmin::{AccountStatus, AddOrUpdateUserReq, GroupDesc};
 use policy::{
     arn::ARN,
@@ -39,8 +38,8 @@ use tokio::{
         mpsc::{Receiver, Sender},
     },
 };
-use tracing::error;
 use tracing::warn;
+use tracing::{error, info};
 
 const IAM_FORMAT_FILE: &str = "format.json";
 const IAM_FORMAT_VERSION_1: i32 = 1;
@@ -95,38 +94,45 @@ where
         self.clone().save_iam_formatter().await?;
         self.clone().load().await?;
 
-        // Background thread starts periodic updates or receives signal updates
-        tokio::spawn({
-            let s = Arc::clone(&self);
-            async move {
-                let ticker = tokio::time::interval(Duration::from_secs(120));
-                tokio::pin!(ticker, reciver);
-                loop {
-                    select! {
-                        _ = ticker.tick() => {
-                            if let Err(err) =s.clone().load().await{
-                                error!("iam load err {:?}", err);
-                            }
-                        },
-                        i = reciver.recv() => {
-                            match i {
-                                Some(t) => {
-                                    let last = s.last_timestamp.load(Ordering::Relaxed);
-                                    if last <= t {
+        // 检查环境变量是否设置
+        let skip_background_task = std::env::var("RUSTFS_SKIP_BACKGROUND_TASK").is_ok();
 
-                                        if let Err(err) =s.clone().load().await{
-                                            error!("iam load err {:?}", err);
+        if !skip_background_task {
+            // Background thread starts periodic updates or receives signal updates
+            tokio::spawn({
+                let s = Arc::clone(&self);
+                async move {
+                    let ticker = tokio::time::interval(Duration::from_secs(120));
+                    tokio::pin!(ticker, reciver);
+                    loop {
+                        select! {
+                            _ = ticker.tick() => {
+                                info!("iam load ticker");
+                                if let Err(err) =s.clone().load().await{
+                                    error!("iam load err {:?}", err);
+                                }
+                            },
+                            i = reciver.recv() => {
+                                info!("iam load reciver");
+                                match i {
+                                    Some(t) => {
+                                        let last = s.last_timestamp.load(Ordering::Relaxed);
+                                        if last <= t {
+                                            info!("iam load reciver load");
+                                            if let Err(err) =s.clone().load().await{
+                                                error!("iam load err {:?}", err);
+                                            }
+                                            ticker.reset();
                                         }
-                                        ticker.reset();
-                                    }
-                                },
-                                None => return,
+                                    },
+                                    None => return,
+                                }
                             }
                         }
                     }
                 }
-            }
-        });
+            });
+        }
 
         Ok(())
     }
@@ -691,7 +697,7 @@ where
 
         for group in self
             .cache
-            .user_group_memeberships
+            .user_group_memberships
             .load()
             .get(name)
             .cloned()
@@ -816,7 +822,7 @@ where
     pub async fn get_user_info(&self, name: &str) -> Result<madmin::UserInfo> {
         let users = self.cache.users.load();
         let policies = self.cache.user_policies.load();
-        let group_members = self.cache.user_group_memeberships.load();
+        let group_members = self.cache.user_group_memberships.load();
 
         let u = match users.get(name) {
             Some(u) => u,
@@ -855,7 +861,7 @@ where
 
         let users = self.cache.users.load();
         let policies = self.cache.user_policies.load();
-        let group_members = self.cache.user_group_memeberships.load();
+        let group_members = self.cache.user_group_memberships.load();
 
         for (k, v) in users.iter() {
             if v.credentials.is_temp() || v.credentials.is_service_account() {
@@ -889,7 +895,7 @@ where
     pub async fn get_bucket_users(&self, bucket_name: &str) -> Result<HashMap<String, madmin::UserInfo>> {
         let users = self.cache.users.load();
         let policies_cache = self.cache.user_policies.load();
-        let group_members = self.cache.user_group_memeberships.load();
+        let group_members = self.cache.user_group_memberships.load();
         let group_policy_cache = self.cache.group_policies.load();
 
         let mut ret = HashMap::new();
@@ -988,7 +994,7 @@ where
         }
 
         if utype == UserType::Reg {
-            if let Some(member_of) = self.cache.user_group_memeberships.load().get(access_key) {
+            if let Some(member_of) = self.cache.user_group_memberships.load().get(access_key) {
                 for member in member_of.iter() {
                     let _ = self
                         .remove_members_from_group(member, vec![access_key.to_string()], false)
@@ -1162,12 +1168,12 @@ where
 
         Cache::add_or_update(&self.cache.groups, group, &gi, OffsetDateTime::now_utc());
 
-        let user_group_memeberships = self.cache.user_group_memeberships.load();
+        let user_group_memberships = self.cache.user_group_memberships.load();
         members.iter().for_each(|member| {
-            if let Some(m) = user_group_memeberships.get(member) {
+            if let Some(m) = user_group_memberships.get(member) {
                 let mut m = m.clone();
                 m.insert(group.to_string());
-                Cache::add_or_update(&self.cache.user_group_memeberships, member, &m, OffsetDateTime::now_utc());
+                Cache::add_or_update(&self.cache.user_group_memberships, member, &m, OffsetDateTime::now_utc());
             }
         });
 
@@ -1247,12 +1253,12 @@ where
 
         Cache::add_or_update(&self.cache.groups, name, &gi, OffsetDateTime::now_utc());
 
-        let user_group_memeberships = self.cache.user_group_memeberships.load();
+        let user_group_memberships = self.cache.user_group_memberships.load();
         members.iter().for_each(|member| {
-            if let Some(m) = user_group_memeberships.get(member) {
+            if let Some(m) = user_group_memberships.get(member) {
                 let mut m = m.clone();
                 m.remove(name);
-                Cache::add_or_update(&self.cache.user_group_memeberships, member, &m, OffsetDateTime::now_utc());
+                Cache::add_or_update(&self.cache.user_group_memberships, member, &m, OffsetDateTime::now_utc());
             }
         });
 
@@ -1303,23 +1309,23 @@ where
     }
 
     fn remove_group_from_memberships_map(&self, group: &str) {
-        let user_group_memeberships = self.cache.user_group_memeberships.load();
-        for (k, v) in user_group_memeberships.iter() {
+        let user_group_memberships = self.cache.user_group_memberships.load();
+        for (k, v) in user_group_memberships.iter() {
             if v.contains(group) {
                 let mut m = v.clone();
                 m.remove(group);
-                Cache::add_or_update(&self.cache.user_group_memeberships, k, &m, OffsetDateTime::now_utc());
+                Cache::add_or_update(&self.cache.user_group_memberships, k, &m, OffsetDateTime::now_utc());
             }
         }
     }
 
     fn update_group_memberships_map(&self, group: &str, gi: &GroupInfo) {
-        let user_group_memeberships = self.cache.user_group_memeberships.load();
+        let user_group_memberships = self.cache.user_group_memberships.load();
         for member in gi.members.iter() {
-            if let Some(m) = user_group_memeberships.get(member) {
+            if let Some(m) = user_group_memberships.get(member) {
                 let mut m = m.clone();
                 m.insert(group.to_string());
-                Cache::add_or_update(&self.cache.user_group_memeberships, member, &m, OffsetDateTime::now_utc());
+                Cache::add_or_update(&self.cache.user_group_memberships, member, &m, OffsetDateTime::now_utc());
             }
         }
     }
@@ -1437,7 +1443,7 @@ where
                 Cache::delete(&self.cache.users, name, OffsetDateTime::now_utc());
             }
 
-            let member_of = self.cache.user_group_memeberships.load();
+            let member_of = self.cache.user_group_memberships.load();
             if let Some(m) = member_of.get(name) {
                 for group in m.iter() {
                     if let Err(err) = self.remove_members_from_group(group, vec![name.to_string()], true).await {
diff --git a/iam/src/store/object.rs b/iam/src/store/object.rs
index 6e616eb5..538d2e57 100644
--- a/iam/src/store/object.rs
+++ b/iam/src/store/object.rs
@@ -3,7 +3,6 @@ use crate::error::{Error, Result, is_err_config_not_found};
 use crate::{
     cache::{Cache, CacheEntity},
     error::{is_err_no_such_policy, is_err_no_such_user},
-    get_global_action_cred,
     manager::{extract_jwt_claims, get_default_policyes},
 };
 use ecstore::{
@@ -11,6 +10,7 @@ use ecstore::{
         RUSTFS_CONFIG_PREFIX,
         com::{delete_config, read_config, read_config_with_metadata, save_config},
     },
+    global::get_global_action_cred,
     store::ECStore,
     store_api::{ObjectInfo, ObjectOptions},
     store_list_objects::{ObjectInfoOrErr, WalkOptions},
@@ -109,7 +109,7 @@ pub struct ObjectStore {
 }
 
 impl ObjectStore {
-    const BUCKET_NAME: &str = ".rustfs.sys";
+    const BUCKET_NAME: &'static str = ".rustfs.sys";
 
     pub fn new(object_api: Arc<ECStore>) -> Self {
         Self { object_api }
diff --git a/iam/src/sys.rs b/iam/src/sys.rs
index 6840212b..b7761db3 100644
--- a/iam/src/sys.rs
+++ b/iam/src/sys.rs
@@ -2,15 +2,13 @@ use crate::error::Error as IamError;
 use crate::error::is_err_no_such_account;
 use crate::error::is_err_no_such_temp_account;
 use crate::error::{Error, Result};
-use crate::get_global_action_cred;
 use crate::manager::IamCache;
 use crate::manager::extract_jwt_claims;
 use crate::manager::get_default_policyes;
 use crate::store::MappedPolicy;
 use crate::store::Store;
 use crate::store::UserType;
-// use ecstore::utils::crypto::base64_decode;
-// use ecstore::utils::crypto::base64_encode;
+use ecstore::global::get_global_action_cred;
 use madmin::AddOrUpdateUserReq;
 use madmin::GroupDesc;
 use policy::arn::ARN;
@@ -283,7 +281,7 @@ impl<T: Store> IamSys<T> {
         self.store.list_service_accounts(access_key).await
     }
 
-    pub async fn list_tmep_accounts(&self, access_key: &str) -> Result<Vec<UserIdentity>> {
+    pub async fn list_temp_accounts(&self, access_key: &str) -> Result<Vec<UserIdentity>> {
         self.store.list_temp_accounts(access_key).await
     }
 
@@ -638,17 +636,17 @@ impl<T: Store> IamSys<T> {
 }
 
 fn is_allowed_by_session_policy(args: &Args<'_>) -> (bool, bool) {
-    let Some(spolicy) = args.claims.get(SESSION_POLICY_NAME_EXTRACTED) else {
+    let Some(policy) = args.claims.get(SESSION_POLICY_NAME_EXTRACTED) else {
         return (false, false);
     };
 
     let has_session_policy = true;
 
-    let Some(spolicy_str) = spolicy.as_str() else {
+    let Some(policy_str) = policy.as_str() else {
         return (has_session_policy, false);
     };
 
-    let Ok(sub_policy) = Policy::parse_config(spolicy_str.as_bytes()) else {
+    let Ok(sub_policy) = Policy::parse_config(policy_str.as_bytes()) else {
         return (has_session_policy, false);
     };
 
@@ -663,17 +661,17 @@ fn is_allowed_by_session_policy(args: &Args<'_>) -> (bool, bool) {
 }
 
 fn is_allowed_by_session_policy_for_service_account(args: &Args<'_>) -> (bool, bool) {
-    let Some(spolicy) = args.claims.get(SESSION_POLICY_NAME_EXTRACTED) else {
+    let Some(policy) = args.claims.get(SESSION_POLICY_NAME_EXTRACTED) else {
         return (false, false);
     };
 
     let mut has_session_policy = true;
 
-    let Some(spolicy_str) = spolicy.as_str() else {
+    let Some(policy_str) = policy.as_str() else {
         return (has_session_policy, false);
     };
 
-    let Ok(sub_policy) = Policy::parse_config(spolicy_str.as_bytes()) else {
+    let Ok(sub_policy) = Policy::parse_config(policy_str.as_bytes()) else {
         return (has_session_policy, false);
     };
 
diff --git a/iam/src/utils.rs b/iam/src/utils.rs
index 475ccaf9..c4b875cf 100644
--- a/iam/src/utils.rs
+++ b/iam/src/utils.rs
@@ -3,6 +3,20 @@ use rand::{Rng, RngCore};
 use serde::{Serialize, de::DeserializeOwned};
 use std::io::{Error, Result};
 
+/// Generates a random access key of the specified length.
+///
+/// # Arguments
+///
+/// * `length` - The length of the access key to be generated.
+///
+/// # Returns
+///
+/// * `Result<String>` - A result containing the generated access key or an error if the length is invalid.
+///
+/// # Errors
+///
+/// * Returns an error if the length is less than 3.
+///
 pub fn gen_access_key(length: usize) -> Result<String> {
     const ALPHA_NUMERIC_TABLE: [char; 36] = [
         '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
@@ -23,6 +37,20 @@ pub fn gen_access_key(length: usize) -> Result<String> {
     Ok(result)
 }
 
+/// Generates a random secret key of the specified length.
+///
+/// # Arguments
+///
+/// * `length` - The length of the secret key to be generated.
+///
+/// # Returns
+///
+/// * `Result<String>` - A result containing the generated secret key or an error if the length is invalid.
+///
+/// # Errors
+///
+/// * Returns an error if the length is less than 8.
+///
 pub fn gen_secret_key(length: usize) -> Result<String> {
     use base64_simd::URL_SAFE_NO_PAD;
 
diff --git a/policy/Cargo.toml b/policy/Cargo.toml
index cb9c3341..046e89e0 100644
--- a/policy/Cargo.toml
+++ b/policy/Cargo.toml
@@ -29,6 +29,7 @@ tracing.workspace = true
 madmin.workspace = true
 lazy_static.workspace = true
 regex = { workspace = true }
+common.workspace = true
 
 [dev-dependencies]
 test-case.workspace = true
diff --git a/rustfs/Cargo.toml b/rustfs/Cargo.toml
index 96c6d371..6e53df5d 100644
--- a/rustfs/Cargo.toml
+++ b/rustfs/Cargo.toml
@@ -57,8 +57,8 @@ protos.workspace = true
 query = { workspace = true }
 regex = { workspace = true }
 rmp-serde.workspace = true
-rustfs-config = { workspace = true }
-rustfs-event-notifier = { workspace = true }
+rustfs-config = { workspace = true, features = ["constants"] }
+rustfs-notify = { workspace = true }
 rustfs-obs = { workspace = true }
 rustfs-utils = { workspace = true, features = ["full"] }
 rustls.workspace = true
@@ -95,6 +95,9 @@ urlencoding = { workspace = true }
 uuid = { workspace = true }
 rustfs-filemeta.workspace = true
 rustfs-rio.workspace = true
+base64 = { workspace = true }
+hmac = { workspace = true }
+sha2 = { workspace = true }
 
 [target.'cfg(target_os = "linux")'.dependencies]
 libsystemd.workspace = true
diff --git a/rustfs/src/admin/handlers.rs b/rustfs/src/admin/handlers.rs
index 31a21581..75dcfa38 100644
--- a/rustfs/src/admin/handlers.rs
+++ b/rustfs/src/admin/handlers.rs
@@ -11,20 +11,20 @@ use ecstore::bucket::versioning_sys::BucketVersioningSys;
 use ecstore::cmd::bucket_targets::{self, GLOBAL_Bucket_Target_Sys};
 use ecstore::error::StorageError;
 use ecstore::global::GLOBAL_ALlHealState;
+use ecstore::global::get_global_action_cred;
 use ecstore::heal::data_usage::load_data_usage_from_backend;
 use ecstore::heal::heal_commands::HealOpts;
 use ecstore::heal::heal_ops::new_heal_sequence;
 use ecstore::metrics_realtime::{CollectMetricsOpts, MetricType, collect_local_metrics};
 use ecstore::new_object_layer_fn;
-use ecstore::peer::is_reserved_or_invalid_bucket;
 use ecstore::pools::{get_total_usable_capacity, get_total_usable_capacity_free};
 use ecstore::store::is_valid_object_prefix;
 use ecstore::store_api::BucketOptions;
 use ecstore::store_api::StorageAPI;
+use ecstore::store_utils::is_reserved_or_invalid_bucket;
 use futures::{Stream, StreamExt};
 use http::{HeaderMap, Uri};
 use hyper::StatusCode;
-use iam::get_global_action_cred;
 use iam::store::MappedPolicy;
 use rustfs_utils::path::path_join;
 // use lazy_static::lazy_static;
@@ -811,7 +811,7 @@ impl Operation for SetRemoteTargetHandler {
         //println!("bucket is:{}", bucket.clone());
         if let Some(bucket) = querys.get("bucket") {
             if bucket.is_empty() {
-                println!("have bucket: {}", bucket);
+                info!("have bucket: {}", bucket);
                 return Ok(S3Response::new((StatusCode::OK, Body::from("fuck".to_string()))));
             }
             let Some(store) = new_object_layer_fn() else {
@@ -825,13 +825,13 @@ impl Operation for SetRemoteTargetHandler {
                 .await
             {
                 Ok(info) => {
-                    println!("Bucket Info: {:?}", info);
+                    info!("Bucket Info: {:?}", info);
                     if !info.versionning {
                         return Ok(S3Response::new((StatusCode::FORBIDDEN, Body::from("bucket need versioned".to_string()))));
                     }
                 }
                 Err(err) => {
-                    eprintln!("Error: {:?}", err);
+                    error!("Error: {:?}", err);
                     return Ok(S3Response::new((StatusCode::BAD_REQUEST, Body::from("empty bucket".to_string()))));
                 }
             }
@@ -935,7 +935,7 @@ impl Operation for ListRemoteTargetHandler {
                 .await
             {
                 Ok(info) => {
-                    println!("Bucket Info: {:?}", info);
+                    info!("Bucket Info: {:?}", info);
                     if !info.versionning {
                         return Ok(S3Response::new((
                             StatusCode::FORBIDDEN,
@@ -944,7 +944,7 @@ impl Operation for ListRemoteTargetHandler {
                     }
                 }
                 Err(err) => {
-                    eprintln!("Error fetching bucket info: {:?}", err);
+                    error!("Error fetching bucket info: {:?}", err);
                     return Ok(S3Response::new((StatusCode::BAD_REQUEST, Body::from("Invalid bucket".to_string()))));
                 }
             }
diff --git a/rustfs/src/admin/handlers/group.rs b/rustfs/src/admin/handlers/group.rs
index e64ef4c1..b8eb3628 100644
--- a/rustfs/src/admin/handlers/group.rs
+++ b/rustfs/src/admin/handlers/group.rs
@@ -1,8 +1,6 @@
+use ecstore::global::get_global_action_cred;
 use http::{HeaderMap, StatusCode};
-use iam::{
-    error::{is_err_no_such_group, is_err_no_such_user},
-    get_global_action_cred,
-};
+use iam::error::{is_err_no_such_group, is_err_no_such_user};
 use madmin::GroupAddRemove;
 use matchit::Params;
 use s3s::{Body, S3Error, S3ErrorCode, S3Request, S3Response, S3Result, header::CONTENT_TYPE, s3_error};
diff --git a/rustfs/src/admin/handlers/policys.rs b/rustfs/src/admin/handlers/policys.rs
index 41329a0b..2c575c8d 100644
--- a/rustfs/src/admin/handlers/policys.rs
+++ b/rustfs/src/admin/handlers/policys.rs
@@ -1,6 +1,8 @@
 use crate::admin::{router::Operation, utils::has_space_be};
+use ecstore::global::get_global_action_cred;
 use http::{HeaderMap, StatusCode};
-use iam::{error::is_err_no_such_user, get_global_action_cred, store::MappedPolicy};
+use iam::error::is_err_no_such_user;
+use iam::store::MappedPolicy;
 use matchit::Params;
 use policy::policy::Policy;
 use s3s::{Body, S3Error, S3ErrorCode, S3Request, S3Response, S3Result, header::CONTENT_TYPE, s3_error};
diff --git a/rustfs/src/admin/handlers/rebalance.rs b/rustfs/src/admin/handlers/rebalance.rs
index f2cfb7c5..e9c3507a 100644
--- a/rustfs/src/admin/handlers/rebalance.rs
+++ b/rustfs/src/admin/handlers/rebalance.rs
@@ -10,7 +10,8 @@ use http::{HeaderMap, StatusCode};
 use matchit::Params;
 use s3s::{Body, S3Request, S3Response, S3Result, header::CONTENT_TYPE, s3_error};
 use serde::{Deserialize, Serialize};
-use std::time::{Duration, SystemTime};
+use std::time::Duration;
+use time::OffsetDateTime;
 use tracing::warn;
 
 use crate::admin::router::Operation;
@@ -56,8 +57,8 @@ pub struct RebalanceAdminStatus {
     pub id: String, // Identifies the ongoing rebalance operation by a UUID
     #[serde(rename = "pools")]
     pub pools: Vec<RebalancePoolStatus>, // Contains all pools, including inactive
-    #[serde(rename = "stoppedAt")]
-    pub stopped_at: Option<SystemTime>, // Optional timestamp when rebalance was stopped
+    #[serde(rename = "stoppedAt", with = "offsetdatetime_rfc3339")]
+    pub stopped_at: Option<OffsetDateTime>, // Optional timestamp when rebalance was stopped
 }
 
 pub struct RebalanceStart {}
@@ -101,11 +102,13 @@ impl Operation for RebalanceStart {
             }
         };
 
+        store.start_rebalance().await;
+
         warn!("Rebalance started with id: {}", id);
         if let Some(notification_sys) = get_global_notification_sys() {
-            warn!("Loading rebalance meta");
+            warn!("RebalanceStart Loading rebalance meta start");
             notification_sys.load_rebalance_meta(true).await;
-            warn!("Rebalance meta loaded");
+            warn!("RebalanceStart Loading rebalance meta done");
         }
 
         let resp = RebalanceResp { id };
@@ -175,15 +178,14 @@ impl Operation for RebalanceStatus {
             let total_bytes_to_rebal = ps.init_capacity as f64 * meta.percent_free_goal - ps.init_free_space as f64;
 
             let mut elapsed = if let Some(start_time) = ps.info.start_time {
-                SystemTime::now()
-                    .duration_since(start_time)
-                    .map_err(|e| s3_error!(InternalError, "Failed to calculate elapsed time: {}", e))?
+                let now = OffsetDateTime::now_utc();
+                now - start_time
             } else {
                 return Err(s3_error!(InternalError, "Start time is not available"));
             };
 
             let mut eta = if ps.bytes > 0 {
-                Duration::from_secs_f64(total_bytes_to_rebal * elapsed.as_secs_f64() / ps.bytes as f64)
+                Duration::from_secs_f64(total_bytes_to_rebal * elapsed.as_seconds_f64() / ps.bytes as f64)
             } else {
                 Duration::ZERO
             };
@@ -193,10 +195,8 @@ impl Operation for RebalanceStatus {
             }
 
             if let Some(stopped_at) = stop_time {
-                if let Ok(du) = stopped_at.duration_since(ps.info.start_time.unwrap_or(stopped_at)) {
-                    elapsed = du;
-                } else {
-                    return Err(s3_error!(InternalError, "Failed to calculate elapsed time"));
+                if let Some(start_time) = ps.info.start_time {
+                    elapsed = stopped_at - start_time;
                 }
 
                 eta = Duration::ZERO;
@@ -208,7 +208,7 @@ impl Operation for RebalanceStatus {
                 bytes: ps.bytes,
                 bucket: ps.bucket.clone(),
                 object: ps.object.clone(),
-                elapsed: elapsed.as_secs(),
+                elapsed: elapsed.whole_seconds() as u64,
                 eta: eta.as_secs(),
             });
         }
@@ -244,10 +244,45 @@ impl Operation for RebalanceStop {
             .await
             .map_err(|e| s3_error!(InternalError, "Failed to stop rebalance: {}", e))?;
 
+        warn!("handle RebalanceStop save_rebalance_stats done ");
         if let Some(notification_sys) = get_global_notification_sys() {
-            notification_sys.load_rebalance_meta(true).await;
+            warn!("handle RebalanceStop notification_sys load_rebalance_meta");
+            notification_sys.load_rebalance_meta(false).await;
+            warn!("handle RebalanceStop notification_sys load_rebalance_meta done");
         }
 
-        return Err(s3_error!(NotImplemented));
+        Ok(S3Response::new((StatusCode::OK, Body::empty())))
+    }
+}
+
+mod offsetdatetime_rfc3339 {
+    use serde::{self, Deserialize, Deserializer, Serializer};
+    use time::{OffsetDateTime, format_description::well_known::Rfc3339};
+
+    pub fn serialize<S>(dt: &Option<OffsetDateTime>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match dt {
+            Some(dt) => {
+                let s = dt.format(&Rfc3339).map_err(serde::ser::Error::custom)?;
+                serializer.serialize_some(&s)
+            }
+            None => serializer.serialize_none(),
+        }
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<OffsetDateTime>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let opt = Option::<String>::deserialize(deserializer)?;
+        match opt {
+            Some(s) => {
+                let dt = OffsetDateTime::parse(&s, &Rfc3339).map_err(serde::de::Error::custom)?;
+                Ok(Some(dt))
+            }
+            None => Ok(None),
+        }
     }
 }
diff --git a/rustfs/src/admin/handlers/service_account.rs b/rustfs/src/admin/handlers/service_account.rs
index 7893082f..a821bf09 100644
--- a/rustfs/src/admin/handlers/service_account.rs
+++ b/rustfs/src/admin/handlers/service_account.rs
@@ -1,13 +1,11 @@
 use crate::admin::utils::has_space_be;
 use crate::auth::{get_condition_values, get_session_token};
 use crate::{admin::router::Operation, auth::check_key_valid};
+use ecstore::global::get_global_action_cred;
 use http::HeaderMap;
 use hyper::StatusCode;
-use iam::{
-    error::is_err_no_such_service_account,
-    get_global_action_cred,
-    sys::{NewServiceAccountOpts, UpdateServiceAccountOpts},
-};
+use iam::error::is_err_no_such_service_account;
+use iam::sys::{NewServiceAccountOpts, UpdateServiceAccountOpts};
 use madmin::{
     AddServiceAccountReq, AddServiceAccountResp, Credentials, InfoServiceAccountResp, ListServiceAccountsResp,
     ServiceAccountInfo, UpdateServiceAccountReq,
diff --git a/rustfs/src/admin/handlers/sts.rs b/rustfs/src/admin/handlers/sts.rs
index f32892cf..ff728321 100644
--- a/rustfs/src/admin/handlers/sts.rs
+++ b/rustfs/src/admin/handlers/sts.rs
@@ -1,5 +1,3 @@
-use std::collections::HashMap;
-
 use crate::{
     admin::router::Operation,
     auth::{check_key_valid, get_session_token},
@@ -18,6 +16,7 @@ use s3s::{
 use serde::Deserialize;
 use serde_json::Value;
 use serde_urlencoded::from_bytes;
+use std::collections::HashMap;
 use time::{Duration, OffsetDateTime};
 use tracing::{info, warn};
 
@@ -52,7 +51,7 @@ impl Operation for AssumeRoleHandle {
         let (cred, _owner) =
             check_key_valid(get_session_token(&req.uri, &req.headers).unwrap_or_default(), &user.access_key).await?;
 
-        // // TODO: Check permissions, do not allow STS access
+        // TODO: Check permissions, do not allow STS access
         if cred.is_temp() || cred.is_service_account() {
             return Err(s3_error!(InvalidRequest, "AccessDenied"));
         }
@@ -70,11 +69,11 @@ impl Operation for AssumeRoleHandle {
         let body: AssumeRoleRequest = from_bytes(&bytes).map_err(|_e| s3_error!(InvalidRequest, "get body failed"))?;
 
         if body.action.as_str() != ASSUME_ROLE_ACTION {
-            return Err(s3_error!(InvalidArgument, "not suport action"));
+            return Err(s3_error!(InvalidArgument, "not support action"));
         }
 
         if body.version.as_str() != ASSUME_ROLE_VERSION {
-            return Err(s3_error!(InvalidArgument, "not suport version"));
+            return Err(s3_error!(InvalidArgument, "not support version"));
         }
 
         let mut claims = cred.claims.unwrap_or_default();
diff --git a/rustfs/src/admin/handlers/trace.rs b/rustfs/src/admin/handlers/trace.rs
index 55a489b5..a2d34087 100644
--- a/rustfs/src/admin/handlers/trace.rs
+++ b/rustfs/src/admin/handlers/trace.rs
@@ -1,4 +1,4 @@
-use ecstore::{GLOBAL_Endpoints, peer_rest_client::PeerRestClient};
+use ecstore::{GLOBAL_Endpoints, rpc::PeerRestClient};
 use http::StatusCode;
 use hyper::Uri;
 use madmin::service_commands::ServiceTraceOpts;
diff --git a/rustfs/src/admin/handlers/user.rs b/rustfs/src/admin/handlers/user.rs
index a375d7ad..871c4337 100644
--- a/rustfs/src/admin/handlers/user.rs
+++ b/rustfs/src/admin/handlers/user.rs
@@ -1,7 +1,9 @@
-use std::{collections::HashMap, str::from_utf8};
-
+use crate::{
+    admin::{router::Operation, utils::has_space_be},
+    auth::{check_key_valid, get_condition_values, get_session_token},
+};
+use ecstore::global::get_global_action_cred;
 use http::{HeaderMap, StatusCode};
-use iam::get_global_action_cred;
 use madmin::{AccountStatus, AddOrUpdateUserReq};
 use matchit::Params;
 use policy::policy::{
@@ -11,13 +13,9 @@ use policy::policy::{
 use s3s::{Body, S3Error, S3ErrorCode, S3Request, S3Response, S3Result, header::CONTENT_TYPE, s3_error};
 use serde::Deserialize;
 use serde_urlencoded::from_bytes;
+use std::{collections::HashMap, str::from_utf8};
 use tracing::warn;
 
-use crate::{
-    admin::{router::Operation, utils::has_space_be},
-    auth::{check_key_valid, get_condition_values, get_session_token},
-};
-
 #[derive(Debug, Deserialize, Default)]
 pub struct AddUserQuery {
     #[serde(rename = "accessKey")]
diff --git a/rustfs/src/admin/mod.rs b/rustfs/src/admin/mod.rs
index 3489d5e3..85df4f29 100644
--- a/rustfs/src/admin/mod.rs
+++ b/rustfs/src/admin/mod.rs
@@ -13,7 +13,7 @@ use handlers::{
 use handlers::{GetReplicationMetricsHandler, ListRemoteTargetHandler, RemoveRemoteTargetHandler, SetRemoteTargetHandler};
 use hyper::Method;
 use router::{AdminOperation, S3Router};
-use rpc::regist_rpc_route;
+use rpc::register_rpc_route;
 use s3s::route::S3Route;
 
 const ADMIN_PREFIX: &str = "/rustfs/admin";
@@ -25,7 +25,7 @@ pub fn make_admin_route() -> std::io::Result<impl S3Route> {
     // 1
     r.insert(Method::POST, "/", AdminOperation(&sts::AssumeRoleHandle {}))?;
 
-    regist_rpc_route(&mut r)?;
+    register_rpc_route(&mut r)?;
     register_user_route(&mut r)?;
 
     r.insert(
diff --git a/rustfs/src/admin/router.rs b/rustfs/src/admin/router.rs
index bea785cd..3fa18b7c 100644
--- a/rustfs/src/admin/router.rs
+++ b/rustfs/src/admin/router.rs
@@ -1,3 +1,4 @@
+use ecstore::rpc::verify_rpc_signature;
 use hyper::HeaderMap;
 use hyper::Method;
 use hyper::StatusCode;
@@ -12,6 +13,7 @@ use s3s::S3Result;
 use s3s::header;
 use s3s::route::S3Route;
 use s3s::s3_error;
+use tracing::error;
 
 use super::ADMIN_PREFIX;
 use super::RUSTFS_ADMIN_PREFIX;
@@ -84,10 +86,19 @@ where
 
     // check_access before call
     async fn check_access(&self, req: &mut S3Request<Body>) -> S3Result<()> {
-        // TODO: check access by req.credentials
+        // Check RPC signature verification
         if req.uri.path().starts_with(RPC_PREFIX) {
+            // Skip signature verification for HEAD requests (health checks)
+            if req.method != Method::HEAD {
+                verify_rpc_signature(&req.uri.to_string(), &req.method, &req.headers).map_err(|e| {
+                    error!("RPC signature verification failed: {}", e);
+                    s3_error!(AccessDenied, "{}", e)
+                })?;
+            }
             return Ok(());
         }
+
+        // For non-RPC admin requests, check credentials
         match req.credentials {
             Some(_) => Ok(()),
             None => Err(s3_error!(AccessDenied, "Signature is required")),
diff --git a/rustfs/src/admin/rpc.rs b/rustfs/src/admin/rpc.rs
index 19fe84d0..5f471f96 100644
--- a/rustfs/src/admin/rpc.rs
+++ b/rustfs/src/admin/rpc.rs
@@ -1,14 +1,15 @@
 use super::router::AdminOperation;
 use super::router::Operation;
 use super::router::S3Router;
-use crate::storage::ecfs::bytes_stream;
 use ecstore::disk::DiskAPI;
+use ecstore::disk::WalkDirOptions;
 use ecstore::set_disk::DEFAULT_READ_BUFFER_SIZE;
 use ecstore::store::find_local_disk;
-use futures::TryStreamExt;
+use futures::StreamExt;
 use http::StatusCode;
 use hyper::Method;
 use matchit::Params;
+use rustfs_utils::net::bytes_stream;
 use s3s::Body;
 use s3s::S3Request;
 use s3s::S3Response;
@@ -16,24 +17,43 @@ use s3s::S3Result;
 use s3s::dto::StreamingBlob;
 use s3s::s3_error;
 use serde_urlencoded::from_bytes;
+use tokio::io::AsyncWriteExt;
 use tokio_util::io::ReaderStream;
-use tokio_util::io::StreamReader;
+use tracing::warn;
 
 pub const RPC_PREFIX: &str = "/rustfs/rpc";
 
-pub fn regist_rpc_route(r: &mut S3Router<AdminOperation>) -> std::io::Result<()> {
+pub fn register_rpc_route(r: &mut S3Router<AdminOperation>) -> std::io::Result<()> {
     r.insert(
         Method::GET,
         format!("{}{}", RPC_PREFIX, "/read_file_stream").as_str(),
         AdminOperation(&ReadFile {}),
     )?;
 
+    r.insert(
+        Method::HEAD,
+        format!("{}{}", RPC_PREFIX, "/read_file_stream").as_str(),
+        AdminOperation(&ReadFile {}),
+    )?;
+
     r.insert(
         Method::PUT,
         format!("{}{}", RPC_PREFIX, "/put_file_stream").as_str(),
         AdminOperation(&PutFile {}),
     )?;
 
+    r.insert(
+        Method::GET,
+        format!("{}{}", RPC_PREFIX, "/walk_dir").as_str(),
+        AdminOperation(&WalkDir {}),
+    )?;
+
+    r.insert(
+        Method::HEAD,
+        format!("{}{}", RPC_PREFIX, "/walk_dir").as_str(),
+        AdminOperation(&WalkDir {}),
+    )?;
+
     Ok(())
 }
 
@@ -50,6 +70,9 @@ pub struct ReadFile {}
 #[async_trait::async_trait]
 impl Operation for ReadFile {
     async fn call(&self, req: S3Request<Body>, _params: Params<'_, '_>) -> S3Result<S3Response<(StatusCode, Body)>> {
+        if req.method == Method::HEAD {
+            return Ok(S3Response::new((StatusCode::OK, Body::empty())));
+        }
         let query = {
             if let Some(query) = req.uri.query() {
                 let input: ReadFileQuery =
@@ -79,6 +102,61 @@ impl Operation for ReadFile {
     }
 }
 
+#[derive(Debug, Default, serde::Deserialize)]
+pub struct WalkDirQuery {
+    disk: String,
+}
+
+pub struct WalkDir {}
+
+#[async_trait::async_trait]
+impl Operation for WalkDir {
+    async fn call(&self, req: S3Request<Body>, _params: Params<'_, '_>) -> S3Result<S3Response<(StatusCode, Body)>> {
+        if req.method == Method::HEAD {
+            return Ok(S3Response::new((StatusCode::OK, Body::empty())));
+        }
+
+        let query = {
+            if let Some(query) = req.uri.query() {
+                let input: WalkDirQuery =
+                    from_bytes(query.as_bytes()).map_err(|e| s3_error!(InvalidArgument, "get query failed1 {:?}", e))?;
+                input
+            } else {
+                WalkDirQuery::default()
+            }
+        };
+
+        let mut input = req.input;
+        let body = match input.store_all_unlimited().await {
+            Ok(b) => b,
+            Err(e) => {
+                warn!("get body failed, e: {:?}", e);
+                return Err(s3_error!(InvalidRequest, "get body failed"));
+            }
+        };
+
+        // let body_bytes = decrypt_data(input_cred.secret_key.expose().as_bytes(), &body)
+        //     .map_err(|e| S3Error::with_message(S3ErrorCode::InvalidArgument, format!("decrypt_data err {}", e)))?;
+
+        let args: WalkDirOptions =
+            serde_json::from_slice(&body).map_err(|e| s3_error!(InternalError, "unmarshal body err {}", e))?;
+        let Some(disk) = find_local_disk(&query.disk).await else {
+            return Err(s3_error!(InvalidArgument, "disk not found"));
+        };
+
+        let (rd, mut wd) = tokio::io::duplex(DEFAULT_READ_BUFFER_SIZE);
+
+        tokio::spawn(async move {
+            if let Err(e) = disk.walk_dir(args, &mut wd).await {
+                warn!("walk dir err {}", e);
+            }
+        });
+
+        let body = Body::from(StreamingBlob::wrap(ReaderStream::with_capacity(rd, DEFAULT_READ_BUFFER_SIZE)));
+        Ok(S3Response::new((StatusCode::OK, body)))
+    }
+}
+
 // /rustfs/rpc/read_file_stream?disk={}&volume={}&path={}&offset={}&length={}"
 #[derive(Debug, Default, serde::Deserialize)]
 pub struct PutFileQuery {
@@ -86,7 +164,7 @@ pub struct PutFileQuery {
     volume: String,
     path: String,
     append: bool,
-    size: usize,
+    size: i64,
 }
 pub struct PutFile {}
 #[async_trait::async_trait]
@@ -116,11 +194,12 @@ impl Operation for PutFile {
                 .map_err(|e| s3_error!(InternalError, "read file err {}", e))?
         };
 
-        let mut body = StreamReader::new(req.input.into_stream().map_err(std::io::Error::other));
-
-        tokio::io::copy(&mut body, &mut file)
-            .await
-            .map_err(|e| s3_error!(InternalError, "copy err {}", e))?;
+        let mut body = req.input;
+        while let Some(item) = body.next().await {
+            let bytes = item.map_err(|e| s3_error!(InternalError, "body stream err {}", e))?;
+            let result = file.write_all(&bytes).await;
+            result.map_err(|e| s3_error!(InternalError, "write file err {}", e))?;
+        }
 
         Ok(S3Response::new((StatusCode::OK, Body::empty())))
     }
diff --git a/rustfs/src/auth.rs b/rustfs/src/auth.rs
index a66a9242..a5cac503 100644
--- a/rustfs/src/auth.rs
+++ b/rustfs/src/auth.rs
@@ -1,9 +1,7 @@
-use std::collections::HashMap;
-
+use ecstore::global::get_global_action_cred;
 use http::HeaderMap;
 use http::Uri;
 use iam::error::Error as IamError;
-use iam::get_global_action_cred;
 use iam::sys::SESSION_POLICY_NAME;
 use policy::auth;
 use policy::auth::get_claims_from_token_with_secret;
@@ -15,6 +13,7 @@ use s3s::auth::SecretKey;
 use s3s::auth::SimpleAuth;
 use s3s::s3_error;
 use serde_json::Value;
+use std::collections::HashMap;
 
 pub struct IAMAuth {
     simple_auth: SimpleAuth,
diff --git a/rustfs/src/config/mod.rs b/rustfs/src/config/mod.rs
index a720221f..945451df 100644
--- a/rustfs/src/config/mod.rs
+++ b/rustfs/src/config/mod.rs
@@ -73,10 +73,6 @@ pub struct Opt {
 
     #[arg(long, env = "RUSTFS_LICENSE")]
     pub license: Option<String>,
-
-    /// event notifier config file
-    #[arg(long, env = "RUSTFS_EVENT_CONFIG")]
-    pub event_config: Option<String>,
 }
 
 // lazy_static::lazy_static! {
diff --git a/rustfs/src/event.rs b/rustfs/src/event.rs
index 99e2a75c..2a855275 100644
--- a/rustfs/src/event.rs
+++ b/rustfs/src/event.rs
@@ -1,21 +1,34 @@
-use rustfs_event_notifier::NotifierConfig;
+use ecstore::config::GLOBAL_ServerConfig;
 use tracing::{error, info, instrument};
 
 #[instrument]
-pub(crate) async fn init_event_notifier(notifier_config: Option<String>) {
-    // Initialize event notifier
-    if notifier_config.is_some() {
-        info!("event_config is not empty");
-        tokio::spawn(async move {
-            let config = NotifierConfig::event_load_config(notifier_config);
-            let result = rustfs_event_notifier::initialize(config).await;
-            if let Err(e) = result {
-                error!("Failed to initialize event notifier: {}", e);
-            } else {
-                info!("Event notifier initialized successfully");
-            }
-        });
-    } else {
-        info!("event_config is empty");
+pub(crate) async fn init_event_notifier() {
+    info!("Initializing event notifier...");
+
+    // 1. Get the global configuration loaded by ecstore
+    let server_config = match GLOBAL_ServerConfig.get() {
+        Some(config) => config.clone(), // Clone the config to pass ownership
+        None => {
+            error!("Event notifier initialization failed: Global server config not loaded.");
+            return;
+        }
+    };
+
+    // 2. Check if the notify subsystem exists in the configuration, and skip initialization if it doesn't
+    if server_config.get_value("notify", "_").is_none() {
+        info!("'notify' subsystem not configured, skipping event notifier initialization.");
+        return;
     }
+
+    info!("Event notifier configuration found, proceeding with initialization.");
+
+    // 3. Initialize the notification system asynchronously with a global configuration
+    // Put it into a separate task to avoid blocking the main initialization process
+    tokio::spawn(async move {
+        if let Err(e) = rustfs_notify::initialize(server_config).await {
+            error!("Failed to initialize event notifier system: {}", e);
+        } else {
+            info!("Event notifier system initialized successfully.");
+        }
+    });
 }
diff --git a/rustfs/src/main.rs b/rustfs/src/main.rs
index ab0889eb..bc495d9b 100644
--- a/rustfs/src/main.rs
+++ b/rustfs/src/main.rs
@@ -4,7 +4,7 @@ mod config;
 mod console;
 mod error;
 mod event;
-mod grpc;
+// mod grpc;
 pub mod license;
 mod logging;
 mod server;
@@ -12,9 +12,9 @@ mod service;
 mod storage;
 
 use crate::auth::IAMAuth;
-use crate::console::{CONSOLE_CONFIG, init_console_cfg};
+use crate::console::{init_console_cfg, CONSOLE_CONFIG};
 // Ensure the correct path for parse_license is imported
-use crate::server::{SHUTDOWN_TIMEOUT, ServiceState, ServiceStateManager, ShutdownSignal, wait_for_shutdown};
+use crate::server::{wait_for_shutdown, ServiceState, ServiceStateManager, ShutdownSignal, SHUTDOWN_TIMEOUT};
 use bytes::Bytes;
 use chrono::Datelike;
 use clap::Parser;
@@ -22,22 +22,22 @@ use common::{
     // error::{Error, Result},
     globals::set_global_addr,
 };
-use ecstore::StorageAPI;
 use ecstore::bucket::metadata_sys::init_bucket_metadata_sys;
 use ecstore::cmd::bucket_replication::init_bucket_replication_pool;
 use ecstore::config as ecconfig;
 use ecstore::config::GLOBAL_ConfigSys;
 use ecstore::heal::background_heal_ops::init_auto_heal;
+use ecstore::rpc::make_server;
 use ecstore::store_api::BucketOptions;
+use ecstore::StorageAPI;
 use ecstore::{
     endpoints::EndpointServerPools,
     heal::data_scanner::init_data_scanner,
     set_global_endpoints,
-    store::{ECStore, init_local_disks},
+    store::{init_local_disks, ECStore},
     update_erasure_type,
 };
 use ecstore::{global::set_global_rustfs_port, notification_sys::new_global_notification_sys};
-use grpc::make_server;
 use http::{HeaderMap, Request as HttpRequest, Response};
 use hyper_util::server::graceful::GracefulShutdown;
 use hyper_util::{
@@ -49,7 +49,7 @@ use iam::init_iam_sys;
 use license::init_license;
 use protos::proto_gen::node_service::node_service_server::NodeServiceServer;
 use rustfs_config::{DEFAULT_ACCESS_KEY, DEFAULT_SECRET_KEY, RUSTFS_TLS_CERT, RUSTFS_TLS_KEY};
-use rustfs_obs::{SystemObserver, init_obs, set_global_guard};
+use rustfs_obs::{init_obs, set_global_guard, SystemObserver};
 use rustfs_utils::net::parse_and_resolve_address;
 use rustls::ServerConfig;
 use s3s::{host::MultiDomain, service::S3ServiceBuilder};
@@ -60,13 +60,12 @@ use std::net::SocketAddr;
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::net::TcpListener;
-use tokio::signal::unix::{SignalKind, signal};
+use tokio::signal::unix::{signal, SignalKind};
 use tokio_rustls::TlsAcceptor;
-use tonic::{Request, Status, metadata::MetadataValue};
+use tonic::{metadata::MetadataValue, Request, Status};
 use tower_http::cors::CorsLayer;
 use tower_http::trace::TraceLayer;
-use tracing::{Span, instrument};
-use tracing::{debug, error, info, warn};
+use tracing::{debug, error, info, instrument, warn, Span};
 
 const MI_B: usize = 1024 * 1024;
 
@@ -119,9 +118,6 @@ async fn main() -> Result<()> {
 async fn run(opt: config::Opt) -> Result<()> {
     debug!("opt: {:?}", &opt);
 
-    // Initialize event notifier
-    event::init_event_notifier(opt.event_config).await;
-
     let server_addr = parse_and_resolve_address(opt.address.as_str()).map_err(Error::other)?;
     let server_port = server_addr.port();
     let server_address = server_addr.to_string();
@@ -129,7 +125,7 @@ async fn run(opt: config::Opt) -> Result<()> {
     debug!("server_address {}", &server_address);
 
     // Set up AK and SK
-    iam::init_global_action_cred(Some(opt.access_key.clone()), Some(opt.secret_key.clone()))?;
+    ecstore::global::init_global_action_cred(Some(opt.access_key.clone()), Some(opt.secret_key.clone()));
 
     set_global_rustfs_port(server_port);
 
@@ -502,15 +498,17 @@ async fn run(opt: config::Opt) -> Result<()> {
     });
 
     // init store
-    let store = ECStore::new(server_address.clone(), endpoint_pools.clone())
-        .await
-        .inspect_err(|err| {
-            error!("ECStore::new {:?}", err);
-        })?;
+    let store = ECStore::new(server_addr, endpoint_pools.clone()).await.inspect_err(|err| {
+        error!("ECStore::new {:?}", err);
+    })?;
 
     ecconfig::init();
+    // config system configuration
     GLOBAL_ConfigSys.init(store.clone()).await?;
 
+    // Initialize event notifier
+    event::init_event_notifier().await;
+
     let buckets_list = store
         .list_bucket(&BucketOptions {
             no_metadata: true,
@@ -570,14 +568,14 @@ async fn run(opt: config::Opt) -> Result<()> {
             // update the status to stopping first
             state_manager.update(ServiceState::Stopping);
 
-            // Stop the notification system
-            if rustfs_event_notifier::is_ready() {
-                // stop event notifier
-                rustfs_event_notifier::shutdown().await.map_err(|err| {
-                    error!("Failed to shut down the notification system: {}", err);
-                    Error::other(err)
-                })?;
-            }
+            // // Stop the notification system
+            // if rustfs_event::is_ready() {
+            //     // stop event notifier
+            //     rustfs_event::shutdown().await.map_err(|err| {
+            //         error!("Failed to shut down the notification system: {}", err);
+            //         Error::from_string(err.to_string())
+            //     })?;
+            // }
 
             info!("Server is stopping...");
             let _ = shutdown_tx.send(());
diff --git a/rustfs/src/storage/ecfs.rs b/rustfs/src/storage/ecfs.rs
index 8456404b..d087801c 100644
--- a/rustfs/src/storage/ecfs.rs
+++ b/rustfs/src/storage/ecfs.rs
@@ -8,6 +8,7 @@ use crate::storage::access::ReqInfo;
 use crate::storage::options::copy_dst_opts;
 use crate::storage::options::copy_src_opts;
 use crate::storage::options::{extract_metadata_from_mime, get_opts};
+use api::object_store::bytes_stream;
 use api::query::Context;
 use api::query::Query;
 use api::server::dbms::DatabaseManagerSystem;
@@ -30,10 +31,15 @@ use ecstore::bucket::metadata_sys;
 use ecstore::bucket::policy_sys::PolicySys;
 use ecstore::bucket::tagging::decode_tags;
 use ecstore::bucket::tagging::encode_tags;
+use ecstore::bucket::utils::serialize;
 use ecstore::bucket::versioning_sys::BucketVersioningSys;
+use ecstore::cmd::bucket_replication::ReplicationStatusType;
+use ecstore::cmd::bucket_replication::ReplicationType;
 use ecstore::cmd::bucket_replication::get_must_replicate_options;
 use ecstore::cmd::bucket_replication::must_replicate;
 use ecstore::cmd::bucket_replication::schedule_replication;
+use ecstore::compress::MIN_COMPRESSIBLE_SIZE;
+use ecstore::compress::is_compressible;
 use ecstore::error::StorageError;
 use ecstore::new_object_layer_fn;
 use ecstore::set_disk::DEFAULT_READ_BUFFER_SIZE;
@@ -65,8 +71,13 @@ use policy::policy::Validator;
 use policy::policy::action::Action;
 use policy::policy::action::S3Action;
 use query::instance::make_rustfsms;
+use rustfs_filemeta::headers::RESERVED_METADATA_PREFIX_LOWER;
 use rustfs_filemeta::headers::{AMZ_DECODED_CONTENT_LENGTH, AMZ_OBJECT_TAGGING};
+use rustfs_rio::CompressReader;
 use rustfs_rio::HashReader;
+use rustfs_rio::Reader;
+use rustfs_rio::WarpReader;
+use rustfs_utils::CompressionAlgorithm;
 use rustfs_utils::path::path_join_buf;
 use rustfs_zip::CompressionFormat;
 use s3s::S3;
@@ -92,7 +103,6 @@ use tracing::debug;
 use tracing::error;
 use tracing::info;
 use tracing::warn;
-use transform_stream::AsyncTryStream;
 use uuid::Uuid;
 
 use ecstore::bucket::{
@@ -186,14 +196,31 @@ impl FS {
                     fpath = format!("{}/{}", prefix, fpath);
                 }
 
-                let size = f.header().size().unwrap_or_default() as usize;
+                let mut size = f.header().size().unwrap_or_default() as i64;
 
                 println!("Extracted: {}, size {}", fpath, size);
 
-                // Wrap the tar entry with BufReader to make it compatible with Reader trait
-                let reader = Box::new(tokio::io::BufReader::new(f));
-                let hrd = HashReader::new(reader, size as i64, size as i64, None, false).map_err(ApiError::from)?;
-                let mut reader = PutObjReader::new(hrd, size);
+                let mut reader: Box<dyn Reader> = Box::new(WarpReader::new(f));
+
+                let mut metadata = HashMap::new();
+
+                let actual_size = size;
+
+                if is_compressible(&HeaderMap::new(), &fpath) && size > MIN_COMPRESSIBLE_SIZE as i64 {
+                    metadata.insert(
+                        format!("{}compression", RESERVED_METADATA_PREFIX_LOWER),
+                        CompressionAlgorithm::default().to_string(),
+                    );
+                    metadata.insert(format!("{}actual-size", RESERVED_METADATA_PREFIX_LOWER,), size.to_string());
+
+                    let hrd = HashReader::new(reader, size, actual_size, None, false).map_err(ApiError::from)?;
+
+                    reader = Box::new(CompressReader::new(hrd, CompressionAlgorithm::default()));
+                    size = -1;
+                }
+
+                let hrd = HashReader::new(reader, size, actual_size, None, false).map_err(ApiError::from)?;
+                let mut reader = PutObjReader::new(hrd);
 
                 let _obj_info = store
                     .put_object(&bucket, &fpath, &mut reader, &ObjectOptions::default())
@@ -208,6 +235,21 @@ impl FS {
                 //     e_tag,
                 //     ..Default::default()
                 // };
+
+                // let event_args = rustfs_notify::event::EventArgs {
+                //     event_name: EventName::ObjectCreatedPut, // 或者其他相应的事件类型
+                //     bucket_name: bucket.clone(),
+                //     object: _obj_info.clone(), // clone() 或传递所需字段
+                //     req_params: crate::storage::global::extract_req_params(&req), // 假设有一个辅助函数来提取请求参数
+                //     resp_elements: crate::storage::global::extract_resp_elements(&output), // 假设有一个辅助函数来提取响应元素
+                //     host: crate::storage::global::get_request_host(&req.headers), // 假设的辅助函数
+                //     user_agent: crate::storage::global::get_request_user_agent(&req.headers), // 假设的辅助函数
+                // };
+                //
+                // // 异步调用，不会阻塞当前请求的响应
+                // tokio::spawn(async move {
+                //     rustfs_notify::notifier::GLOBAL_NOTIFIER.notify(event_args).await;
+                // });
             }
         }
 
@@ -326,13 +368,10 @@ impl S3 for FS {
             src_info.metadata_only = true;
         }
 
-        let hrd = HashReader::new(gr.stream, gr.object_info.size as i64, gr.object_info.size as i64, None, false)
-            .map_err(ApiError::from)?;
+        let reader = Box::new(WarpReader::new(gr.stream));
+        let hrd = HashReader::new(reader, gr.object_info.size, gr.object_info.size, None, false).map_err(ApiError::from)?;
 
-        src_info.put_object_reader = Some(PutObjReader {
-            stream: hrd,
-            content_length: gr.object_info.size as usize,
-        });
+        src_info.put_object_reader = Some(PutObjReader::new(hrd));
 
         // check quota
         // TODO: src metadada
@@ -543,13 +582,13 @@ impl S3 for FS {
         let rs = range.map(|v| match v {
             Range::Int { first, last } => HTTPRangeSpec {
                 is_suffix_length: false,
-                start: first as usize,
-                end: last.map(|v| v as usize),
+                start: first as i64,
+                end: if let Some(last) = last { last as i64 } else { -1 },
             },
             Range::Suffix { length } => HTTPRangeSpec {
                 is_suffix_length: true,
-                start: length as usize,
-                end: None,
+                start: length as i64,
+                end: -1,
             },
         });
 
@@ -590,7 +629,7 @@ impl S3 for FS {
 
         let body = Some(StreamingBlob::wrap(bytes_stream(
             ReaderStream::with_capacity(reader.stream, DEFAULT_READ_BUFFER_SIZE),
-            info.size,
+            info.size as usize,
         )));
 
         let output = GetObjectOutput {
@@ -644,13 +683,13 @@ impl S3 for FS {
         let rs = range.map(|v| match v {
             Range::Int { first, last } => HTTPRangeSpec {
                 is_suffix_length: false,
-                start: first as usize,
-                end: last.map(|v| v as usize),
+                start: first as i64,
+                end: if let Some(last) = last { last as i64 } else { -1 },
             },
             Range::Suffix { length } => HTTPRangeSpec {
                 is_suffix_length: true,
-                start: length as usize,
-                end: None,
+                start: length as i64,
+                end: -1,
             },
         });
 
@@ -671,8 +710,8 @@ impl S3 for FS {
         // warn!("head_object info {:?}", &info);
 
         let content_type = {
-            if let Some(content_type) = info.content_type {
-                match ContentType::from_str(&content_type) {
+            if let Some(content_type) = &info.content_type {
+                match ContentType::from_str(content_type) {
                     Ok(res) => Some(res),
                     Err(err) => {
                         error!("parse content-type err {} {:?}", &content_type, err);
@@ -686,10 +725,14 @@ impl S3 for FS {
         };
         let last_modified = info.mod_time.map(Timestamp::from);
 
+        // TODO: range download
+
+        let content_length = info.get_actual_size().map_err(ApiError::from)?;
+
         let metadata = info.user_defined;
 
         let output = HeadObjectOutput {
-            content_length: Some(try_!(i64::try_from(info.size))),
+            content_length: Some(content_length),
             content_type,
             last_modified,
             e_tag: info.etag,
@@ -813,7 +856,7 @@ impl S3 for FS {
                 let mut obj = Object {
                     key: Some(v.name.to_owned()),
                     last_modified: v.mod_time.map(Timestamp::from),
-                    size: Some(v.size as i64),
+                    size: Some(v.size),
                     e_tag: v.etag.clone(),
                     ..Default::default()
                 };
@@ -892,7 +935,7 @@ impl S3 for FS {
                 ObjectVersion {
                     key: Some(v.name.to_owned()),
                     last_modified: v.mod_time.map(Timestamp::from),
-                    size: Some(v.size as i64),
+                    size: Some(v.size),
                     version_id: v.version_id.map(|v| v.to_string()),
                     is_latest: Some(v.is_latest),
                     e_tag: v.etag.clone(),
@@ -933,7 +976,6 @@ impl S3 for FS {
             return self.put_object_extract(req).await;
         }
 
-        info!("put object");
         let input = req.input;
 
         if let Some(ref storage_class) = input.storage_class {
@@ -956,7 +998,7 @@ impl S3 for FS {
 
         let Some(body) = body else { return Err(s3_error!(IncompleteBody)) };
 
-        let content_length = match content_length {
+        let mut size = match content_length {
             Some(c) => c,
             None => {
                 if let Some(val) = req.headers.get(AMZ_DECODED_CONTENT_LENGTH) {
@@ -971,9 +1013,6 @@ impl S3 for FS {
         };
 
         let body = StreamReader::new(body.map(|f| f.map_err(|e| std::io::Error::other(e.to_string()))));
-        let body = Box::new(tokio::io::BufReader::new(body));
-        let hrd = HashReader::new(body, content_length as i64, content_length as i64, None, false).map_err(ApiError::from)?;
-        let mut reader = PutObjReader::new(hrd, content_length as usize);
 
         // let body = Box::new(StreamReader::new(body.map(|f| f.map_err(|e| std::io::Error::other(e.to_string())))));
 
@@ -991,10 +1030,32 @@ impl S3 for FS {
             metadata.insert(AMZ_OBJECT_TAGGING.to_owned(), tags);
         }
 
+        let mut reader: Box<dyn Reader> = Box::new(WarpReader::new(body));
+
+        let actual_size = size;
+
+        if is_compressible(&req.headers, &key) && size > MIN_COMPRESSIBLE_SIZE as i64 {
+            metadata.insert(
+                format!("{}compression", RESERVED_METADATA_PREFIX_LOWER),
+                CompressionAlgorithm::default().to_string(),
+            );
+            metadata.insert(format!("{}actual-size", RESERVED_METADATA_PREFIX_LOWER,), size.to_string());
+
+            let hrd = HashReader::new(reader, size as i64, size as i64, None, false).map_err(ApiError::from)?;
+
+            reader = Box::new(CompressReader::new(hrd, CompressionAlgorithm::default()));
+            size = -1;
+        }
+
+        // TODO: md5 check
+        let reader = HashReader::new(reader, size, actual_size, None, false).map_err(ApiError::from)?;
+
+        let mut reader = PutObjReader::new(reader);
+
         let mt = metadata.clone();
         let mt2 = metadata.clone();
 
-        let opts: ObjectOptions = put_opts(&bucket, &key, version_id, &req.headers, Some(mt))
+        let mut opts: ObjectOptions = put_opts(&bucket, &key, version_id, &req.headers, Some(mt))
             .await
             .map_err(ApiError::from)?;
 
@@ -1002,8 +1063,9 @@ impl S3 for FS {
             get_must_replicate_options(&mt2, "", ReplicationStatusType::Unknown, ReplicationType::ObjectReplicationType, &opts);
 
         let dsc = must_replicate(&bucket, &key, &repoptions).await;
-        warn!("dsc {}", &dsc.replicate_any().clone());
+        // warn!("dsc {}", &dsc.replicate_any().clone());
         if dsc.replicate_any() {
+            if let Some(metadata) = opts.user_defined.as_mut() {
             let k = format!("{}{}", RESERVED_METADATA_PREFIX_LOWER, "replication-timestamp");
             let now: DateTime<Utc> = Utc::now();
             let formatted_time = now.to_rfc3339();
@@ -1011,8 +1073,7 @@ impl S3 for FS {
             let k = format!("{}{}", RESERVED_METADATA_PREFIX_LOWER, "replication-status");
             metadata.insert(k, dsc.pending_status());
         }
-
-        debug!("put_object opts {:?}", &opts);
+        }
 
         let obj_info = store
             .put_object(&bucket, &key, &mut reader, &opts)
@@ -1065,6 +1126,13 @@ impl S3 for FS {
             metadata.insert(AMZ_OBJECT_TAGGING.to_owned(), tags);
         }
 
+        if is_compressible(&req.headers, &key) {
+            metadata.insert(
+                format!("{}compression", RESERVED_METADATA_PREFIX_LOWER),
+                CompressionAlgorithm::default().to_string(),
+            );
+        }
+
         let opts: ObjectOptions = put_opts(&bucket, &key, version_id, &req.headers, Some(metadata))
             .await
             .map_err(ApiError::from)?;
@@ -1102,7 +1170,7 @@ impl S3 for FS {
         // let upload_id =
 
         let body = body.ok_or_else(|| s3_error!(IncompleteBody))?;
-        let content_length = match content_length {
+        let mut size = match content_length {
             Some(c) => c,
             None => {
                 if let Some(val) = req.headers.get(AMZ_DECODED_CONTENT_LENGTH) {
@@ -1117,21 +1185,42 @@ impl S3 for FS {
         };
 
         let body = StreamReader::new(body.map(|f| f.map_err(|e| std::io::Error::other(e.to_string()))));
-        let body = Box::new(tokio::io::BufReader::new(body));
-        let hrd = HashReader::new(body, content_length as i64, content_length as i64, None, false).map_err(ApiError::from)?;
 
         // mc cp step 4
-        let mut data = PutObjReader::new(hrd, content_length as usize);
+
         let opts = ObjectOptions::default();
 
         let Some(store) = new_object_layer_fn() else {
             return Err(S3Error::with_message(S3ErrorCode::InternalError, "Not init".to_string()));
         };
 
-        // TODO: hash_reader
+        let fi = store
+            .get_multipart_info(&bucket, &key, &upload_id, &opts)
+            .await
+            .map_err(ApiError::from)?;
+
+        let is_compressible = fi
+            .user_defined
+            .contains_key(format!("{}compression", RESERVED_METADATA_PREFIX_LOWER).as_str());
+
+        let mut reader: Box<dyn Reader> = Box::new(WarpReader::new(body));
+
+        let actual_size = size;
+
+        if is_compressible {
+            let hrd = HashReader::new(reader, size, actual_size, None, false).map_err(ApiError::from)?;
+
+            reader = Box::new(CompressReader::new(hrd, CompressionAlgorithm::default()));
+            size = -1;
+        }
+
+        // TODO: md5 check
+        let reader = HashReader::new(reader, size, actual_size, None, false).map_err(ApiError::from)?;
+
+        let mut reader = PutObjReader::new(reader);
 
         let info = store
-            .put_object_part(&bucket, &key, &upload_id, part_id, &mut data, &opts)
+            .put_object_part(&bucket, &key, &upload_id, part_id, &mut reader, &opts)
             .await
             .map_err(ApiError::from)?;
 
@@ -1749,7 +1838,7 @@ impl S3 for FS {
         let object_lock_configuration = match metadata_sys::get_object_lock_config(&bucket).await {
             Ok((cfg, _created)) => Some(cfg),
             Err(err) => {
-                warn!("get_object_lock_config err {:?}", err);
+                debug!("get_object_lock_config err {:?}", err);
                 None
             }
         };
@@ -2399,24 +2488,3 @@ impl S3 for FS {
         }))
     }
 }
-
-#[allow(dead_code)]
-pub fn bytes_stream<S, E>(stream: S, content_length: usize) -> impl Stream<Item = std::result::Result<Bytes, E>> + Send + 'static
-where
-    S: Stream<Item = std::result::Result<Bytes, E>> + Send + 'static,
-    E: Send + 'static,
-{
-    AsyncTryStream::<Bytes, E, _>::new(|mut y| async move {
-        pin_mut!(stream);
-        let mut remaining: usize = content_length;
-        while let Some(result) = stream.next().await {
-            let mut bytes = result?;
-            if bytes.len() > remaining {
-                bytes.truncate(remaining);
-            }
-            remaining -= bytes.len();
-            y.yield_ok(bytes).await;
-        }
-        Ok(())
-    })
-}
diff --git a/rustfs/src/storage/event_notifier.rs b/rustfs/src/storage/event_notifier.rs
deleted file mode 100644
index 292b45e3..00000000
--- a/rustfs/src/storage/event_notifier.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-use rustfs_event_notifier::{Event, Metadata};
-
-/// Create a new metadata object
-#[allow(dead_code)]
-pub(crate) fn create_metadata() -> Metadata {
-    // Create a new metadata object
-    let mut metadata = Metadata::new();
-    metadata.set_configuration_id("test-config".to_string());
-    // Return the created metadata object
-    metadata
-}
-
-/// Create a new event object
-#[allow(dead_code)]
-pub(crate) async fn send_event(event: Event) -> Result<(), Box<dyn std::error::Error>> {
-    rustfs_event_notifier::send_event(event).await.map_err(|e| e.into())
-}
diff --git a/rustfs/src/storage/global.rs b/rustfs/src/storage/global.rs
new file mode 100644
index 00000000..a6d7ad58
--- /dev/null
+++ b/rustfs/src/storage/global.rs
@@ -0,0 +1,47 @@
+use hyper::HeaderMap;
+use s3s::{S3Request, S3Response};
+use std::collections::HashMap;
+
+/// Extract request parameters from S3Request, mainly header information.
+#[allow(dead_code)]
+pub fn extract_req_params<T>(req: &S3Request<T>) -> HashMap<String, String> {
+    let mut params = HashMap::new();
+    for (key, value) in req.headers.iter() {
+        if let Ok(val_str) = value.to_str() {
+            params.insert(key.as_str().to_string(), val_str.to_string());
+        }
+    }
+    params
+}
+
+/// Extract response elements from S3Response, mainly header information.
+#[allow(dead_code)]
+pub fn extract_resp_elements<T>(resp: &S3Response<T>) -> HashMap<String, String> {
+    let mut params = HashMap::new();
+    for (key, value) in resp.headers.iter() {
+        if let Ok(val_str) = value.to_str() {
+            params.insert(key.as_str().to_string(), val_str.to_string());
+        }
+    }
+    params
+}
+
+/// Get host from header information.
+#[allow(dead_code)]
+pub fn get_request_host(headers: &HeaderMap) -> String {
+    headers
+        .get("host")
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or_default()
+        .to_string()
+}
+
+/// Get user-agent from header information.
+#[allow(dead_code)]
+pub fn get_request_user_agent(headers: &HeaderMap) -> String {
+    headers
+        .get("user-agent")
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or_default()
+        .to_string()
+}
diff --git a/rustfs/src/storage/mod.rs b/rustfs/src/storage/mod.rs
index 90f7135d..21af29ec 100644
--- a/rustfs/src/storage/mod.rs
+++ b/rustfs/src/storage/mod.rs
@@ -1,5 +1,5 @@
 pub mod access;
 pub mod ecfs;
 // pub mod error;
-mod event_notifier;
+mod global;
 pub mod options;
diff --git a/s3select/api/src/object_store.rs b/s3select/api/src/object_store.rs
index d62c99bc..d0753d78 100644
--- a/s3select/api/src/object_store.rs
+++ b/s3select/api/src/object_store.rs
@@ -108,7 +108,7 @@ impl ObjectStore for EcObjectStore {
         let meta = ObjectMeta {
             location: location.clone(),
             last_modified: Utc::now(),
-            size: reader.object_info.size,
+            size: reader.object_info.size as usize,
             e_tag: reader.object_info.etag,
             version: None,
         };
@@ -121,7 +121,7 @@ impl ObjectStore for EcObjectStore {
                         ConvertStream::new(reader.stream, self.delimiter.clone()),
                         DEFAULT_READ_BUFFER_SIZE,
                     ),
-                    reader.object_info.size,
+                    reader.object_info.size as usize,
                 )
                 .boxed(),
             )
@@ -129,7 +129,7 @@ impl ObjectStore for EcObjectStore {
             object_store::GetResultPayload::Stream(
                 bytes_stream(
                     ReaderStream::with_capacity(reader.stream, DEFAULT_READ_BUFFER_SIZE),
-                    reader.object_info.size,
+                    reader.object_info.size as usize,
                 )
                 .boxed(),
             )
@@ -137,7 +137,7 @@ impl ObjectStore for EcObjectStore {
         Ok(GetResult {
             payload,
             meta,
-            range: 0..reader.object_info.size,
+            range: 0..reader.object_info.size as usize,
             attributes,
         })
     }
@@ -161,7 +161,7 @@ impl ObjectStore for EcObjectStore {
         Ok(ObjectMeta {
             location: location.clone(),
             last_modified: Utc::now(),
-            size: info.size,
+            size: info.size as usize,
             e_tag: info.etag,
             version: None,
         })
diff --git a/scripts/build-docker-multiarch.sh b/scripts/build-docker-multiarch.sh
new file mode 100755
index 00000000..789202da
--- /dev/null
+++ b/scripts/build-docker-multiarch.sh
@@ -0,0 +1,242 @@
+#!/bin/bash
+set -euo pipefail
+
+# 多架构 Docker 构建脚本
+# 支持构建并推送 x86_64 和 ARM64 架构的镜像
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+cd "$PROJECT_ROOT"
+
+# 默认配置
+REGISTRY_IMAGE_DOCKERHUB="rustfs/rustfs"
+REGISTRY_IMAGE_GHCR="ghcr.io/rustfs/s3-rustfs"
+VERSION="${VERSION:-latest}"
+PUSH="${PUSH:-false}"
+IMAGE_TYPE="${IMAGE_TYPE:-production}"
+
+# 帮助信息
+show_help() {
+    cat << EOF
+用法: $0 [选项]
+
+选项:
+    -h, --help          显示此帮助信息
+    -v, --version TAG   设置镜像版本标签 (默认: latest)
+    -p, --push          推送镜像到仓库
+    -t, --type TYPE     镜像类型 (production|ubuntu|rockylinux|devenv, 默认: production)
+
+环境变量:
+    DOCKERHUB_USERNAME  Docker Hub 用户名
+    DOCKERHUB_TOKEN     Docker Hub 访问令牌
+    GITHUB_TOKEN        GitHub 访问令牌
+
+示例:
+    # 仅构建不推送
+    $0 --version v1.0.0
+
+    # 构建并推送到仓库
+    $0 --version v1.0.0 --push
+
+    # 构建 Ubuntu 版本
+    $0 --type ubuntu --version v1.0.0
+EOF
+}
+
+# 解析命令行参数
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        -h|--help)
+            show_help
+            exit 0
+            ;;
+        -v|--version)
+            VERSION="$2"
+            shift 2
+            ;;
+        -p|--push)
+            PUSH=true
+            shift
+            ;;
+        -t|--type)
+            IMAGE_TYPE="$2"
+            shift 2
+            ;;
+        *)
+            echo "未知参数: $1"
+            show_help
+            exit 1
+            ;;
+    esac
+done
+
+# 设置 Dockerfile 和后缀
+case "$IMAGE_TYPE" in
+    production)
+        DOCKERFILE="Dockerfile"
+        SUFFIX=""
+        ;;
+    ubuntu)
+        DOCKERFILE=".docker/Dockerfile.ubuntu22.04"
+        SUFFIX="-ubuntu22.04"
+        ;;
+    rockylinux)
+        DOCKERFILE=".docker/Dockerfile.rockylinux9.3"
+        SUFFIX="-rockylinux9.3"
+        ;;
+    devenv)
+        DOCKERFILE=".docker/Dockerfile.devenv"
+        SUFFIX="-devenv"
+        ;;
+    *)
+        echo "错误: 不支持的镜像类型: $IMAGE_TYPE"
+        echo "支持的类型: production, ubuntu, rockylinux, devenv"
+        exit 1
+        ;;
+esac
+
+echo "🚀 开始多架构 Docker 构建"
+echo "📋 构建信息:"
+echo "   - 镜像类型: $IMAGE_TYPE"
+echo "   - Dockerfile: $DOCKERFILE"
+echo "   - 版本标签: $VERSION$SUFFIX"
+echo "   - 推送: $PUSH"
+echo "   - 架构: linux/amd64, linux/arm64"
+
+# 检查必要的工具
+if ! command -v docker &> /dev/null; then
+    echo "❌ 错误: 未找到 docker 命令"
+    exit 1
+fi
+
+# 检查 Docker Buildx
+if ! docker buildx version &> /dev/null; then
+    echo "❌ 错误: Docker Buildx 不可用"
+    echo "请运行: docker buildx install"
+    exit 1
+fi
+
+# 创建并使用 buildx 构建器
+BUILDER_NAME="rustfs-multiarch-builder"
+if ! docker buildx inspect "$BUILDER_NAME" &> /dev/null; then
+    echo "🔨 创建多架构构建器..."
+    docker buildx create --name "$BUILDER_NAME" --use --bootstrap
+else
+    echo "🔨 使用现有构建器..."
+    docker buildx use "$BUILDER_NAME"
+fi
+
+# 构建多架构二进制文件
+echo "🔧 构建多架构二进制文件..."
+
+# 检查是否存在预构建的二进制文件
+if [[ ! -f "target/x86_64-unknown-linux-musl/release/rustfs" ]] || [[ ! -f "target/aarch64-unknown-linux-gnu/release/rustfs" ]]; then
+    echo "⚠️  未找到预构建的二进制文件，正在构建..."
+
+    # 安装构建依赖
+    if ! command -v cross &> /dev/null; then
+        echo "📦 安装 cross 工具..."
+        cargo install cross
+    fi
+
+    # 生成 protobuf 代码
+    echo "📝 生成 protobuf 代码..."
+    cargo run --bin gproto || true
+
+    # 构建 x86_64
+    echo "🔨 构建 x86_64 二进制文件..."
+    cargo build --release --target x86_64-unknown-linux-musl --bin rustfs
+
+    # 构建 ARM64
+    echo "🔨 构建 ARM64 二进制文件..."
+    cross build --release --target aarch64-unknown-linux-gnu --bin rustfs
+fi
+
+# 准备构建参数
+BUILD_ARGS=""
+TAGS=""
+
+# Docker Hub 标签
+if [[ -n "${DOCKERHUB_USERNAME:-}" ]]; then
+    TAGS="$TAGS -t $REGISTRY_IMAGE_DOCKERHUB:$VERSION$SUFFIX"
+fi
+
+# GitHub Container Registry 标签
+if [[ -n "${GITHUB_TOKEN:-}" ]]; then
+    TAGS="$TAGS -t $REGISTRY_IMAGE_GHCR:$VERSION$SUFFIX"
+fi
+
+# 如果没有设置标签，使用本地标签
+if [[ -z "$TAGS" ]]; then
+    TAGS="-t rustfs:$VERSION$SUFFIX"
+fi
+
+# 构建镜像
+echo "🏗️ 构建多架构 Docker 镜像..."
+BUILD_CMD="docker buildx build \
+    --platform linux/amd64,linux/arm64 \
+    --file $DOCKERFILE \
+    $TAGS \
+    --build-arg BUILDTIME=$(date -u +%Y-%m-%dT%H:%M:%SZ) \
+    --build-arg VERSION=$VERSION \
+    --build-arg REVISION=$(git rev-parse --short HEAD 2>/dev/null || echo 'unknown')"
+
+if [[ "$PUSH" == "true" ]]; then
+    # 登录到仓库
+    if [[ -n "${DOCKERHUB_USERNAME:-}" ]] && [[ -n "${DOCKERHUB_TOKEN:-}" ]]; then
+        echo "🔐 登录到 Docker Hub..."
+        echo "$DOCKERHUB_TOKEN" | docker login --username "$DOCKERHUB_USERNAME" --password-stdin
+    fi
+
+    if [[ -n "${GITHUB_TOKEN:-}" ]]; then
+        echo "🔐 登录到 GitHub Container Registry..."
+        echo "$GITHUB_TOKEN" | docker login ghcr.io --username "$(whoami)" --password-stdin
+    fi
+
+    BUILD_CMD="$BUILD_CMD --push"
+else
+    BUILD_CMD="$BUILD_CMD --load"
+fi
+
+BUILD_CMD="$BUILD_CMD ."
+
+echo "📋 执行构建命令:"
+echo "$BUILD_CMD"
+echo ""
+
+# 执行构建
+eval "$BUILD_CMD"
+
+echo ""
+echo "✅ 多架构 Docker 镜像构建完成!"
+
+if [[ "$PUSH" == "true" ]]; then
+    echo "🚀 镜像已推送到仓库"
+
+    # 显示推送的镜像信息
+    echo ""
+    echo "📦 推送的镜像:"
+    if [[ -n "${DOCKERHUB_USERNAME:-}" ]]; then
+        echo "   - $REGISTRY_IMAGE_DOCKERHUB:$VERSION$SUFFIX"
+    fi
+    if [[ -n "${GITHUB_TOKEN:-}" ]]; then
+        echo "   - $REGISTRY_IMAGE_GHCR:$VERSION$SUFFIX"
+    fi
+
+    echo ""
+    echo "🔍 验证多架构支持:"
+    if [[ -n "${DOCKERHUB_USERNAME:-}" ]]; then
+        echo "   docker buildx imagetools inspect $REGISTRY_IMAGE_DOCKERHUB:$VERSION$SUFFIX"
+    fi
+    if [[ -n "${GITHUB_TOKEN:-}" ]]; then
+        echo "   docker buildx imagetools inspect $REGISTRY_IMAGE_GHCR:$VERSION$SUFFIX"
+    fi
+else
+    echo "💾 镜像已构建到本地"
+    echo ""
+    echo "🔍 查看镜像:"
+    echo "   docker images rustfs:$VERSION$SUFFIX"
+fi
+
+echo ""
+echo "🎉 构建任务完成!"
diff --git a/scripts/dev_clear.sh b/scripts/dev_clear.sh
new file mode 100644
index 00000000..095f1d4d
--- /dev/null
+++ b/scripts/dev_clear.sh
@@ -0,0 +1,11 @@
+for i in {0..3}; do
+    DIR="/data/rustfs$i"
+    echo "处理 $DIR"
+    if [ -d "$DIR" ]; then
+        echo "清空 $DIR"
+        sudo rm -rf "$DIR"/* "$DIR"/.[!.]* "$DIR"/..?* 2>/dev/null || true
+        echo "已清空 $DIR"
+    else
+        echo "$DIR 不存在，跳过"
+    fi
+done
\ No newline at end of file
diff --git a/scripts/dev.sh b/scripts/dev_deploy.sh
similarity index 66%
rename from scripts/dev.sh
rename to scripts/dev_deploy.sh
index eb72331c..13cb3eb2 100755
--- a/scripts/dev.sh
+++ b/scripts/dev_deploy.sh
@@ -4,18 +4,20 @@
 
 rm ./target/x86_64-unknown-linux-musl/release/rustfs.zip
 # 压缩./target/x86_64-unknown-linux-musl/release/rustfs
-zip  ./target/x86_64-unknown-linux-musl/release/rustfs.zip ./target/x86_64-unknown-linux-musl/release/rustfs
-
+zip -j ./target/x86_64-unknown-linux-musl/release/rustfs.zip ./target/x86_64-unknown-linux-musl/release/rustfs
 
 # 本地文件路径
 LOCAL_FILE="./target/x86_64-unknown-linux-musl/release/rustfs.zip"
 REMOTE_PATH="~"
 
-# 定义服务器列表数组
-# 格式：服务器 IP 用户名 目标路径
-SERVER_LIST=(
-    "root@121.89.80.13"
-)
+# 必须传入IP参数，否则报错退出
+if [ -z "$1" ]; then
+    echo "用法: $0 <server_ip>"
+    echo "请传入目标服务器IP地址"
+    exit 1
+fi
+
+SERVER_LIST=("root@$1")
 
 # 遍历服务器列表
 for SERVER in "${SERVER_LIST[@]}"; do
@@ -26,7 +28,4 @@ for SERVER in "${SERVER_LIST[@]}"; do
     else
         echo "复制到 $SERVER 失败"
     fi
-done
-
-
-# ps -ef | grep rustfs | awk '{print $2}'| xargs kill -9
\ No newline at end of file
+done
\ No newline at end of file
diff --git a/scripts/dev_rustfs.env b/scripts/dev_rustfs.env
new file mode 100644
index 00000000..d45fa38c
--- /dev/null
+++ b/scripts/dev_rustfs.env
@@ -0,0 +1,12 @@
+RUSTFS_ROOT_USER=rustfsadmin
+RUSTFS_ROOT_PASSWORD=rustfsadmin
+
+RUSTFS_VOLUMES="http://node{1...4}:7000/data/rustfs{0...3}     http://node{5...8}:7000/data/rustfs{0...3}"
+RUSTFS_ADDRESS=":7000"
+RUSTFS_CONSOLE_ENABLE=true
+RUSTFS_CONSOLE_ADDRESS=":7001"
+RUST_LOG=warn
+RUSTFS_OBS_LOG_DIRECTORY="/var/logs/rustfs/"
+RUSTFS_NS_SCANNER_INTERVAL=60
+#RUSTFS_SKIP_BACKGROUND_TASK=true
+RUSTFS_COMPRESSION_ENABLED=true
\ No newline at end of file
diff --git a/scripts/dev_rustfs.sh b/scripts/dev_rustfs.sh
new file mode 100644
index 00000000..fcf2fb6d
--- /dev/null
+++ b/scripts/dev_rustfs.sh
@@ -0,0 +1,199 @@
+#!/bin/bash
+
+# ps -ef | grep rustfs | awk '{print $2}'| xargs kill -9
+
+# 本地 rustfs.zip 路径
+ZIP_FILE="./rustfs.zip"
+# 解压目标
+UNZIP_TARGET="./"
+
+
+SERVER_LIST=(
+    "root@node1" # node1
+    "root@node2" # node2
+    "root@node3" # node3
+    "root@node4" # node4
+    # "root@node5" # node5
+    # "root@node6" # node6
+    # "root@node7" # node7
+    # "root@node8" # node8
+)
+
+REMOTE_TMP="~/rustfs"
+
+# 部署 rustfs 到所有服务器
+deploy() {
+    echo "解压 $ZIP_FILE ..."
+    unzip -o "$ZIP_FILE" -d "$UNZIP_TARGET"
+    if [ $? -ne 0 ]; then
+        echo "解压失败，退出"
+        exit 1
+    fi
+
+    LOCAL_RUSTFS="${UNZIP_TARGET}rustfs"
+    if [ ! -f "$LOCAL_RUSTFS" ]; then
+        echo "未找到解压后的 rustfs 文件，退出"
+        exit 1
+    fi
+
+    for SERVER in "${SERVER_LIST[@]}"; do
+        echo "上传 $LOCAL_RUSTFS 到 $SERVER:$REMOTE_TMP"
+        scp "$LOCAL_RUSTFS" "${SERVER}:${REMOTE_TMP}"
+        if [ $? -ne 0 ]; then
+            echo "❌ 上传到 $SERVER 失败，跳过"
+            continue
+        fi
+
+        echo "在 $SERVER 上操作 systemctl 和文件替换"
+        ssh "$SERVER" bash <<EOF
+set -e
+echo "停止 rustfs 服务"
+sudo systemctl stop rustfs || true
+echo "覆盖 /usr/local/bin/rustfs"
+sudo cp ~/rustfs /usr/local/bin/rustfs
+sudo chmod +x /usr/local/bin/rustfs
+echo "启动 rustfs 服务"
+sudo systemctl start rustfs
+echo "检测 rustfs 服务状态"
+sudo systemctl status rustfs --no-pager --lines=10
+EOF
+
+        if [ $? -eq 0 ]; then
+            echo "✅ $SERVER 部署并重启 rustfs 成功"
+        else
+            echo "❌ $SERVER 部署或重启 rustfs 失败"
+        fi
+    done
+}
+
+# 清空 /data/rustfs0~3 目录下所有文件（包括隐藏文件）
+clear_data_dirs() {
+    for SERVER in "${SERVER_LIST[@]}"; do
+        echo "清空 $SERVER:/data/rustfs0~3 下所有文件"
+        ssh "$SERVER" bash <<EOF
+for i in {0..3}; do
+    DIR="/data/rustfs$i"
+    echo "处理 $DIR"
+    if [ -d "$DIR" ]; then
+        echo "清空 $DIR"
+        sudo rm -rf "$DIR"/* "$DIR"/.[!.]* "$DIR"/..?* 2>/dev/null || true
+        echo "已清空 $DIR"
+    else
+        echo "$DIR 不存在，跳过"
+    fi
+done
+EOF
+    done
+}
+
+# 控制 rustfs 服务
+stop_rustfs() {
+    for SERVER in "${SERVER_LIST[@]}"; do
+        echo "停止 $SERVER rustfs 服务"
+        ssh "$SERVER" "sudo systemctl stop rustfs"
+    done
+}
+
+start_rustfs() {
+    for SERVER in "${SERVER_LIST[@]}"; do
+        echo "启动 $SERVER rustfs 服务"
+        ssh "$SERVER" "sudo systemctl start rustfs"
+    done
+}
+
+restart_rustfs() {
+    for SERVER in "${SERVER_LIST[@]}"; do
+        echo "重启 $SERVER rustfs 服务"
+        ssh "$SERVER" "sudo systemctl restart rustfs"
+    done
+}
+
+# 向所有服务器追加公钥到 ~/.ssh/authorized_keys
+add_ssh_key() {
+    if [ -z "$2" ]; then
+        echo "用法: $0 addkey <pubkey_file>"
+        exit 1
+    fi
+    PUBKEY_FILE="$2"
+    if [ ! -f "$PUBKEY_FILE" ]; then
+        echo "指定的公钥文件不存在: $PUBKEY_FILE"
+        exit 1
+    fi
+    PUBKEY_CONTENT=$(cat "$PUBKEY_FILE")
+    for SERVER in "${SERVER_LIST[@]}"; do
+        echo "追加公钥到 $SERVER:~/.ssh/authorized_keys"
+        ssh "$SERVER" "mkdir -p ~/.ssh && chmod 700 ~/.ssh && echo '$PUBKEY_CONTENT' >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"
+        if [ $? -eq 0 ]; then
+            echo "✅ $SERVER 公钥追加成功"
+        else
+            echo "❌ $SERVER 公钥追加失败"
+        fi
+    done
+}
+
+monitor_logs() {
+    for SERVER in "${SERVER_LIST[@]}"; do
+        echo "监控 $SERVER:/var/logs/rustfs/rustfs.log ..."
+        ssh "$SERVER" "tail -F /var/logs/rustfs/rustfs.log" |
+            sed "s/^/[$SERVER] /" &
+    done
+    wait
+}
+
+set_env_file() {
+    if [ -z "$2" ]; then
+        echo "用法: $0 setenv <env_file>"
+        exit 1
+    fi
+    ENV_FILE="$2"
+    if [ ! -f "$ENV_FILE" ]; then
+        echo "指定的环境变量文件不存在: $ENV_FILE"
+        exit 1
+    fi
+    for SERVER in "${SERVER_LIST[@]}"; do
+        echo "上传 $ENV_FILE 到 $SERVER:~/rustfs.env"
+        scp "$ENV_FILE" "${SERVER}:~/rustfs.env"
+        if [ $? -ne 0 ]; then
+            echo "❌ 上传到 $SERVER 失败，跳过"
+            continue
+        fi
+        echo "覆盖 $SERVER:/etc/default/rustfs"
+        ssh "$SERVER" "sudo mv ~/rustfs.env /etc/default/rustfs"
+        if [ $? -eq 0 ]; then
+            echo "✅ $SERVER /etc/default/rustfs 覆盖成功"
+        else
+            echo "❌ $SERVER /etc/default/rustfs 覆盖失败"
+        fi
+    done
+}
+
+# 主命令分发
+case "$1" in
+    deploy)
+        deploy
+        ;;
+    clear)
+        clear_data_dirs
+        ;;
+    stop)
+        stop_rustfs
+        ;;
+    start)
+        start_rustfs
+        ;;
+    restart)
+        restart_rustfs
+        ;;
+    addkey)
+        add_ssh_key "$@"
+        ;;
+    monitor_logs)
+        monitor_logs
+        ;;
+    setenv)
+        set_env_file "$@"
+        ;;
+    *)
+        echo "用法: $0 {deploy|clear|stop|start|restart|addkey <pubkey_file>|monitor_logs|setenv <env_file>}"
+        ;;
+esac
\ No newline at end of file
diff --git a/scripts/run.sh b/scripts/run.sh
index 71c41a77..77ce8666 100755
--- a/scripts/run.sh
+++ b/scripts/run.sh
@@ -19,7 +19,7 @@ mkdir -p ./target/volume/test{0..4}
 
 if [ -z "$RUST_LOG" ]; then
     export RUST_BACKTRACE=1
-   export RUST_LOG="rustfs=debug,ecstore=debug,s3s=debug,iam=debug"
+    export RUST_LOG="rustfs=debug,ecstore=debug,s3s=debug,iam=debug"
 fi
 
 # export RUSTFS_ERASURE_SET_DRIVE_COUNT=5
@@ -55,11 +55,13 @@ export RUSTFS_OBS_LOG_ROTATION_SIZE_MB=1 # Log rotation size in MB
 #export RUSTFS_SINKS_FILE_FLUSH_INTERVAL_MS=1000
 #export RUSTFS_SINKS_FILE_FLUSH_THRESHOLD=100
 #
+# Kafka sink 配置
 #export RUSTFS_SINKS_KAFKA_BROKERS=localhost:9092
 #export RUSTFS_SINKS_KAFKA_TOPIC=logs
 #export RUSTFS_SINKS_KAFKA_BATCH_SIZE=100
 #export RUSTFS_SINKS_KAFKA_BATCH_TIMEOUT_MS=1000
 #
+# Webhook sink 配置
 #export RUSTFS_SINKS_WEBHOOK_ENDPOINT=http://localhost:8080/webhook
 #export RUSTFS_SINKS_WEBHOOK_AUTH_TOKEN=you-auth-token
 #export RUSTFS_SINKS_WEBHOOK_BATCH_SIZE=100
@@ -72,6 +74,11 @@ export OTEL_INSTRUMENTATION_VERSION="0.1.1"
 export OTEL_INSTRUMENTATION_SCHEMA_URL="https://opentelemetry.io/schemas/1.31.0"
 export OTEL_INSTRUMENTATION_ATTRIBUTES="env=production"
 
+export RUSTFS_NS_SCANNER_INTERVAL=60  # 对象扫描间隔时间，单位为秒
+# exportRUSTFS_SKIP_BACKGROUND_TASK=true
+
+export RUSTFS_COMPRESSION_ENABLED=true # 是否启用压缩
+
 # 事件消息配置
 #export RUSTFS_EVENT_CONFIG="./deploy/config/event.example.toml"
 
@@ -80,6 +87,6 @@ if [ -n "$1" ]; then
 fi
 
 # 启动 webhook 服务器
-#cargo run --example webhook -p rustfs-event-notifier &
+#cargo run --example webhook -p rustfs-event &
 # 启动主服务
 cargo run --bin rustfs
\ No newline at end of file