chore: update star history

.copilot-rules.md

@@ -1,58 +0,0 @@
-# GitHub Copilot Rules for RustFS Project
-
-## Core Rules Reference
-
-This project follows the comprehensive AI coding rules defined in `.rules.md`. Please refer to that file for the complete set of development guidelines, coding standards, and best practices.
-
-## Copilot-Specific Configuration
-
-When using GitHub Copilot for this project, ensure you:
-
-1. **Review the unified rules**: Always check `.rules.md` for the latest project guidelines
-2. **Follow branch protection**: Never attempt to commit directly to main/master branch
-3. **Use English**: All code comments, documentation, and variable names must be in English
-4. **Clean code practices**: Only make modifications you're confident about
-5. **Test thoroughly**: Ensure all changes pass formatting, linting, and testing requirements
-
-## Quick Reference
-
-### Critical Rules
-- 🚫 **NEVER commit directly to main/master branch**
-- ✅ **ALWAYS work on feature branches**
-- 📝 **ALWAYS use English for code and documentation**
-- 🧹 **ALWAYS clean up temporary files after use**
-- 🎯 **ONLY make confident, necessary modifications**
-
-### Pre-commit Checklist
-```bash
-# Before committing, always run:
-cargo fmt --all
-cargo clippy --all-targets --all-features -- -D warnings
-cargo check --all-targets
-cargo test
-```
-
-### Branch Workflow
-```bash
-git checkout main
-git pull origin main
-git checkout -b feat/your-feature-name
-# Make your changes
-git add .
-git commit -m "feat: your feature description"
-git push origin feat/your-feature-name
-gh pr create
-```
-
-## Important Notes
-
-- This file serves as an entry point for GitHub Copilot
-- All detailed rules and guidelines are maintained in `.rules.md`
-- Updates to coding standards should be made in `.rules.md` to ensure consistency across all AI tools
-- When in doubt, always refer to `.rules.md` for authoritative guidance
-
-## See Also
-
-- [.rules.md](./.rules.md) - Complete AI coding rules and guidelines
-- [CONTRIBUTING.md](./CONTRIBUTING.md) - Contribution guidelines
-- [README.md](./README.md) - Project overview and setup instructions

.cursorrules

@@ -1,927 +0,0 @@
-# RustFS Project Cursor Rules
-
-## 🚨🚨🚨 CRITICAL DEVELOPMENT RULES - ZERO TOLERANCE 🚨🚨🚨
-
-### ⛔️ ABSOLUTE PROHIBITION: NEVER COMMIT DIRECTLY TO MASTER/MAIN BRANCH ⛔️
-
-**🔥 THIS IS THE MOST CRITICAL RULE - VIOLATION WILL RESULT IN IMMEDIATE REVERSAL 🔥**
-
-- **🚫 ZERO DIRECT COMMITS TO MAIN/MASTER BRANCH - ABSOLUTELY FORBIDDEN**
-- **🚫 ANY DIRECT COMMIT TO MAIN BRANCH MUST BE IMMEDIATELY REVERTED**
-- **🚫 NO EXCEPTIONS FOR HOTFIXES, EMERGENCIES, OR URGENT CHANGES**
-- **🚫 NO EXCEPTIONS FOR SMALL CHANGES, TYPOS, OR DOCUMENTATION UPDATES**
-- **🚫 NO EXCEPTIONS FOR ANYONE - MAINTAINERS, CONTRIBUTORS, OR ADMINS**
-
-### 📋 MANDATORY WORKFLOW - STRICTLY ENFORCED
-
-**EVERY SINGLE CHANGE MUST FOLLOW THIS WORKFLOW:**
-
-1. **Check current branch**: `git branch` (MUST NOT be on main/master)
-2. **Switch to main**: `git checkout main`
-3. **Pull latest**: `git pull origin main`
-4. **Create feature branch**: `git checkout -b feat/your-feature-name`
-5. **Make changes ONLY on feature branch**
-6. **Test thoroughly before committing**
-7. **Commit and push to feature branch**: `git push origin feat/your-feature-name`
-8. **Create Pull Request**: Use `gh pr create` (MANDATORY)
-9. **Wait for PR approval**: NO self-merging allowed
-10. **Merge through GitHub interface**: ONLY after approval
-
-### 🔒 ENFORCEMENT MECHANISMS
-
-- **Branch protection rules**: Main branch is protected
-- **Pre-commit hooks**: Will block direct commits to main
-- **CI/CD checks**: All PRs must pass before merging
-- **Code review requirement**: At least one approval needed
-- **Automated reversal**: Direct commits to main will be automatically reverted
-
-## 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
-- Use `Result<T>` type aliases for consistency within each module
-- Error conversion between modules should use explicit `From` implementations
-- Follow the pattern: `pub type Result<T> = core::result::Result<T, Error>`
-- Use `#[error("description")]` attributes for clear error messages
-- Support error downcasting when needed through `other()` helper methods
-- Implement `Clone` for errors when required by the domain logic
-- **Current module error types:**
-  - `ecstore::error::StorageError` - Storage layer errors
-  - `ecstore::disk::error::DiskError` - Disk operation errors
-  - `iam::error::Error` - Identity and access management errors
-  - `policy::error::Error` - Policy-related errors
-  - `crypto::error::Error` - Cryptographic operation errors
-  - `filemeta::error::Error` - File metadata errors
-  - `rustfs::error::ApiError` - API layer errors
-  - Module-specific error types for specialized functionality
-
-## Code Style Guidelines
-
-### 1. Formatting Configuration
-
-```toml
-max_width = 130
-fn_call_width = 90
-single_line_let_else_max_width = 100
-```
-
-### 2. **🔧 MANDATORY Code Formatting Rules**
-
-**CRITICAL**: All code must be properly formatted before committing. This project enforces strict formatting standards to maintain code consistency and readability.
-
-#### Pre-commit Requirements (MANDATORY)
-
-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
-   ```
-
-#### Quick Commands
-
-Use these convenient Makefile targets for common tasks:
-
-```bash
-# Format all code
-make fmt
-
-# Check if code is properly formatted
-make fmt-check
-
-# Run clippy checks
-make clippy
-
-# Run compilation check
-make check
-
-# Run tests
-make test
-
-# Run all pre-commit checks (format + clippy + check + test)
-make pre-commit
-
-# Setup git hooks (one-time setup)
-make setup-hooks
-```
-
-#### 🔒 Automated Pre-commit Hooks
-
-This project includes a pre-commit hook that automatically runs before each commit to ensure:
-
-- ✅ Code is properly formatted (`cargo fmt --all --check`)
-- ✅ No clippy warnings (`cargo clippy --all-targets --all-features -- -D warnings`)
-- ✅ Code compiles successfully (`cargo check --all-targets`)
-
-**Setting Up Pre-commit Hooks** (MANDATORY for all developers):
-
-Run this command once after cloning the repository:
-
-```bash
-make setup-hooks
-```
-
-Or manually:
-
-```bash
-chmod +x .git/hooks/pre-commit
-```
-
-#### 🚫 Commit Prevention
-
-If your code doesn't meet the formatting requirements, the pre-commit hook will:
-
-1. **Block the commit** and show clear error messages
-2. **Provide exact commands** to fix the issues
-3. **Guide you through** the resolution process
-
-Example output when formatting fails:
-
-```
-❌ Code formatting check failed!
-💡 Please run 'cargo fmt --all' to format your code before committing.
-
-🔧 Quick fix:
-   cargo fmt --all
-   git add .
-   git commit
-```
-
-### 3. Naming Conventions
-
-- Use `snake_case` for functions, variables, modules
-- Use `PascalCase` for types, traits, enums
-- Constants use `SCREAMING_SNAKE_CASE`
-- Global variables prefix `GLOBAL_`, e.g., `GLOBAL_Endpoints`
-- Use meaningful and descriptive names for variables, functions, and methods
-- Avoid meaningless names like `temp`, `data`, `foo`, `bar`, `test123`
-- 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:
-  - The type cannot be inferred by the compiler
-  - Explicit typing improves code clarity and readability
-  - Required for API boundaries (function signatures, public struct fields)
-  - 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];
-let config = Config::default();
-let result = process_data(&input);
-
-// Iterator chains with clear context
-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];
-let config: Config = Config::default();
-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> { ... }
-
-// Ambiguous cases - explicit type needed
-let value: f64 = "3.14".parse().unwrap();
-
-// Complex generic types - explicit for clarity
-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
-- Error cases use `# Errors` descriptions
-- Always use English for all comments and documentation
-- 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
-- Group `use` statements with blank lines between groups
-
-## Asynchronous Programming Guidelines
-
-### 1. Trait Definition
-
-```rust
-#[async_trait::async_trait]
-pub trait StorageAPI: Send + Sync {
-    async fn get_object(&self, bucket: &str, object: &str) -> Result<ObjectInfo>;
-}
-```
-
-### 2. Error Handling
-
-```rust
-// Use ? operator to propagate errors
-async fn example_function() -> Result<()> {
-    let data = read_file("path").await?;
-    process_data(data).await?;
-    Ok(())
-}
-```
-
-### 3. Concurrency Control
-
-- Use `Arc` and `Mutex`/`RwLock` for shared state management
-- Prioritize async locks from `tokio::sync`
-- Avoid holding locks for long periods
-
-## Logging and Tracing Guidelines
-
-### 1. Tracing Usage
-
-```rust
-#[tracing::instrument(skip(self, data))]
-async fn process_data(&self, data: &[u8]) -> Result<()> {
-    info!("Processing {} bytes", data.len());
-    // Implementation logic
-}
-```
-
-### 2. Log Levels
-
-- `error!`: System errors requiring immediate attention
-- `warn!`: Warning information that may affect functionality
-- `info!`: Important business information
-- `debug!`: Debug information for development use
-- `trace!`: Detailed execution paths
-
-### 3. Structured Logging
-
-```rust
-info!(
-    counter.rustfs_api_requests_total = 1_u64,
-    key_request_method = %request.method(),
-    key_request_uri_path = %request.uri().path(),
-    "API request processed"
-);
-```
-
-## 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),
-}
-
-// Provide Result type alias for the module
-pub type Result<T> = core::result::Result<T, MyError>;
-```
-
-### 2. Error Helper Methods
-
-```rust
-impl MyError {
-    /// Create error from any compatible error type
-    pub fn other<E>(error: E) -> Self
-    where
-        E: Into<Box<dyn std::error::Error + Send + Sync>>,
-    {
-        MyError::Io(std::io::Error::other(error))
-    }
-}
-```
-
-### 3. Error Conversion Between Modules
-
-```rust
-// Convert between different module error types
-impl From<ecstore::error::StorageError> for MyError {
-    fn from(e: ecstore::error::StorageError) -> Self {
-        match e {
-            ecstore::error::StorageError::FileNotFound => {
-                MyError::FileNotFound { path: "unknown".to_string() }
-            }
-            _ => MyError::Storage(e),
-        }
-    }
-}
-
-// Provide reverse conversion when needed
-impl From<MyError> for ecstore::error::StorageError {
-    fn from(e: MyError) -> Self {
-        match e {
-            MyError::FileNotFound { .. } => ecstore::error::StorageError::FileNotFound,
-            MyError::Storage(e) => e,
-            _ => ecstore::error::StorageError::other(e),
-        }
-    }
-}
-```
-
-### 4. Error Context and Propagation
-
-```rust
-// Use ? operator for clean error propagation
-async fn example_function() -> Result<()> {
-    let data = read_file("path").await?;
-    process_data(data).await?;
-    Ok(())
-}
-
-// 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)
-        })?;
-    Ok(())
-}
-```
-
-### 5. API Error Conversion (S3 Example)
-
-```rust
-// Convert storage errors to API-specific errors
-use s3s::{S3Error, S3ErrorCode};
-
-#[derive(Debug)]
-pub struct ApiError {
-    pub code: S3ErrorCode,
-    pub message: String,
-    pub source: Option<Box<dyn std::error::Error + Send + Sync>>,
-}
-
-impl From<ecstore::error::StorageError> for ApiError {
-    fn from(err: ecstore::error::StorageError) -> Self {
-        let code = match &err {
-            ecstore::error::StorageError::BucketNotFound(_) => S3ErrorCode::NoSuchBucket,
-            ecstore::error::StorageError::ObjectNotFound(_, _) => S3ErrorCode::NoSuchKey,
-            ecstore::error::StorageError::BucketExists(_) => S3ErrorCode::BucketAlreadyExists,
-            ecstore::error::StorageError::InvalidArgument(_, _, _) => S3ErrorCode::InvalidArgument,
-            ecstore::error::StorageError::MethodNotAllowed => S3ErrorCode::MethodNotAllowed,
-            ecstore::error::StorageError::StorageFull => S3ErrorCode::ServiceUnavailable,
-            _ => S3ErrorCode::InternalError,
-        };
-
-        ApiError {
-            code,
-            message: err.to_string(),
-            source: Some(Box::new(err)),
-        }
-    }
-}
-
-impl From<ApiError> for S3Error {
-    fn from(err: ApiError) -> Self {
-        let mut s3e = S3Error::with_message(err.code, err.message);
-        if let Some(source) = err.source {
-            s3e.set_source(source);
-        }
-        s3e
-    }
-}
-```
-
-### 6. Error Handling Best Practices
-
-#### Pattern Matching and Error Classification
-
-```rust
-// Use pattern matching for specific error handling
-async fn handle_storage_operation() -> Result<()> {
-    match storage.get_object("bucket", "key").await {
-        Ok(object) => process_object(object),
-        Err(ecstore::error::StorageError::ObjectNotFound(bucket, key)) => {
-            warn!("Object not found: {}/{}", bucket, key);
-            create_default_object(bucket, key).await
-        }
-        Err(ecstore::error::StorageError::BucketNotFound(bucket)) => {
-            error!("Bucket not found: {}", bucket);
-            Err(MyError::Custom {
-                message: format!("Bucket {} does not exist", bucket)
-            })
-        }
-        Err(e) => {
-            error!("Storage operation failed: {}", e);
-            Err(MyError::Storage(e))
-        }
-    }
-}
-```
-
-#### 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))]
-async fn upload_file(&self, bucket: &str, key: &str, data: Vec<u8>) -> Result<()> {
-    self.storage
-        .put_object(bucket, key, data)
-        .await
-        .map_err(|e| MyError::Custom {
-            message: format!("Failed to upload {}/{}: {}", bucket, key, e)
-        })
-}
-```
-
-## 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());
-let results = join_all(futures).await;
-```
-
-### 3. Caching Strategy
-
-- Use `LazyLock` for global caching
-- Implement LRU cache to avoid memory leaks
-
-## Testing Guidelines
-
-### 1. Unit Tests
-
-```rust
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use test_case::test_case;
-
-    #[tokio::test]
-    async fn test_async_function() {
-        let result = async_function().await;
-        assert!(result.is_ok());
-    }
-
-    #[test_case("input1", "expected1")]
-    #[test_case("input2", "expected2")]
-    fn test_with_cases(input: &str, expected: &str) {
-        assert_eq!(function(input), expected);
-    }
-
-    #[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());
-    }
-
-    #[test]
-    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
-            _ => panic!("Unexpected error type"),
-        }
-    }
-
-    #[test]
-    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 } => {
-                assert!(message.contains("Failed to read"));
-                assert!(message.contains("nonexistent_file.txt"));
-            }
-            _ => panic!("Expected Custom error"),
-        }
-    }
-}
-```
-
-### 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
-- Each test should have a clear purpose and verify specific behavior
-- Test data should be realistic and representative of actual use cases
-
-## 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 */ }
-
-#[cfg(target_arch = "aarch64")]
-fn optimized_aarch64_function() { /* ARM64 specific implementation */ }
-
-#[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
-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
-
-## 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?;
-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 {
-    pub address: String,
-    pub volumes: String,
-    #[serde(default)]
-    pub console_enable: bool,
-}
-```
-
-## 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"]
-gpu = ["dep:nvml-wrapper"]
-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> {
-    // Check component status
-}
-```
-
-## 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)
-- [ ] **Pre-commit hooks are working** and all checks pass
-- [ ] **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
-- [ ] Is PR description provided in copyable markdown format for easy copying?
-
-## Common Patterns and Best Practices
-
-### 1. Resource Management
-
-```rust
-// Use RAII pattern for resource management
-pub struct ResourceGuard {
-    resource: Resource,
-}
-
-impl Drop for ResourceGuard {
-    fn drop(&mut self) {
-        // Clean up resources
-    }
-}
-```
-
-### 2. Dependency Injection
-
-```rust
-// Use dependency injection pattern
-pub struct Service {
-    config: Arc<Config>,
-    storage: Arc<dyn StorageAPI>,
-}
-```
-
-### 3. Graceful Shutdown
-
-```rust
-// Implement graceful shutdown
-async fn shutdown_gracefully(shutdown_rx: &mut Receiver<()>) {
-    tokio::select! {
-        _ = shutdown_rx.recv() => {
-            info!("Received shutdown signal");
-            // Perform cleanup operations
-        }
-        _ = tokio::time::sleep(SHUTDOWN_TIMEOUT) => {
-            warn!("Shutdown timeout reached");
-        }
-    }
-}
-```
-
-## 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
-
-These rules should serve as guiding principles when developing the RustFS project, ensuring code quality, performance, and maintainability.
-
-### 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 ⚠️**
-- **🔒 ALL CHANGES MUST GO THROUGH PULL REQUESTS - NO DIRECT COMMITS TO MAIN UNDER ANY CIRCUMSTANCES 🔒**
-- **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)
-   4. Make your changes ONLY on the feature branch
-   5. Test thoroughly before committing
-   6. Commit and push to the feature branch
-   7. **Create a pull request for code review - THIS IS THE ONLY WAY TO MERGE TO MAIN**
-   8. **Wait for PR approval before merging - NEVER merge your own PRs without 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**
-- **Pull Request Requirements:**
-  - All changes must be submitted via PR regardless of size or urgency
-  - PRs must include comprehensive description and testing information
-  - PRs must pass all CI/CD checks before merging
-  - PRs require at least one approval from code reviewers
-  - Even hotfixes and emergency changes must go through PR process
-- **Enforcement:**
-  - Main branch should be protected with branch protection rules
-  - Direct pushes to main should be blocked by repository settings
-  - Any accidental direct commits to main must be immediately reverted via PR
-
-#### Development Workflow
-
-## 🎯 **Core Development Principles**
-
-- **🔴 Every change must be precise - don't modify unless you're confident**
-  - Carefully analyze code logic and ensure complete understanding before making changes
-  - When uncertain, prefer asking users or consulting documentation over blind modifications
-  - Use small iterative steps, modify only necessary parts at a time
-  - Evaluate impact scope before changes to ensure no new issues are introduced
-
-- **🚀 GitHub PR creation prioritizes gh command usage**
-  - Prefer using `gh pr create` command to create Pull Requests
-  - Avoid having users manually create PRs through web interface
-  - Provide clear and professional PR titles and descriptions
-  - Using `gh` commands ensures better integration and automation
-
-## 📝 **Code Quality Requirements**
-
-- 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）

.docker/README.md

@@ -1,261 +0,0 @@
-# RustFS Docker Images
-
-This directory contains Docker configuration files and supporting infrastructure for building and running RustFS container images.
-
-## 📁 Directory Structure
-
-```
-rustfs/
-├── Dockerfile           # Production image (Alpine + pre-built binaries)
-├── Dockerfile.source    # Development image (Debian + source build)
-├── docker-buildx.sh     # Multi-architecture build script
-├── Makefile             # Build automation with simplified commands
-└── .docker/             # Supporting infrastructure
-    ├── observability/   # Monitoring and observability configs
-    ├── compose/         # Docker Compose configurations
-    ├── mqtt/            # MQTT broker configs
-    └── openobserve-otel/ # OpenObserve + OpenTelemetry configs
-```
-
-## 🎯 Image Variants
-
-### Core Images
-
-| Image | Base OS | Build Method | Size | Use Case |
-|-------|---------|--------------|------|----------|
-| `production` (default) | Alpine 3.18 | GitHub Releases | Smallest | Production deployment |
-| `source` | Debian Bookworm | Source build | Medium | Custom builds with cross-compilation |
-| `dev` | Debian Bookworm | Development tools | Large | Interactive development |
-
-## 🚀 Usage Examples
-
-### Quick Start (Production)
-
-```bash
-# Default production image (Alpine + GitHub Releases)
-docker run -p 9000:9000 rustfs/rustfs:latest
-
-# Specific version
-docker run -p 9000:9000 rustfs/rustfs:1.2.3
-```
-
-### Complete Tag Strategy Examples
-
-```bash
-# Stable Releases
-docker run rustfs/rustfs:1.2.3           # Main version (production)
-docker run rustfs/rustfs:1.2.3-production # Explicit production variant
-docker run rustfs/rustfs:1.2.3-source   # Source build variant
-docker run rustfs/rustfs:latest          # Latest stable
-
-# Prerelease Versions
-docker run rustfs/rustfs:1.3.0-alpha.2  # Specific alpha version
-docker run rustfs/rustfs:alpha           # Latest alpha
-docker run rustfs/rustfs:beta            # Latest beta
-docker run rustfs/rustfs:rc              # Latest release candidate
-
-# Development Versions
-docker run rustfs/rustfs:dev             # Latest main branch development
-docker run rustfs/rustfs:dev-13e4a0b     # Specific commit
-docker run rustfs/rustfs:dev-latest      # Latest development
-docker run rustfs/rustfs:main-latest     # Main branch latest
-```
-
-### Development Environment
-
-```bash
-# Quick setup using Makefile (recommended)
-make docker-dev-local     # Build development image locally
-make dev-env-start        # Start development container
-
-# Manual Docker commands
-docker run -it -v $(pwd):/workspace -p 9000:9000 rustfs/rustfs:latest-dev
-
-# Build from source locally
-docker build -f Dockerfile.source -t rustfs:custom .
-
-# Development with hot reload
-docker-compose up rustfs-dev
-```
-
-## 🏗️ Build Arguments and Scripts
-
-### Using Makefile Commands (Recommended)
-
-The easiest way to build images using simplified commands:
-
-```bash
-# Development images (build from source)
-make docker-dev-local             # Build for local use (single arch)
-make docker-dev                   # Build multi-arch (for CI/CD)
-make docker-dev-push REGISTRY=xxx # Build and push to registry
-
-# Production images (using pre-built binaries)
-make docker-buildx                # Build multi-arch production images
-make docker-buildx-push           # Build and push production images
-make docker-buildx-version VERSION=v1.0.0  # Build specific version
-
-# Development environment
-make dev-env-start                # Start development container
-make dev-env-stop                 # Stop development container
-make dev-env-restart              # Restart development container
-
-# Help
-make help-docker                  # Show all Docker-related commands
-```
-
-### Using docker-buildx.sh (Advanced)
-
-For direct script usage and advanced scenarios:
-
-```bash
-# Build latest version for all architectures
-./docker-buildx.sh
-
-# Build and push to registry
-./docker-buildx.sh --push
-
-# Build specific version
-./docker-buildx.sh --release v1.2.3
-
-# Build and push specific version
-./docker-buildx.sh --release v1.2.3 --push
-```
-
-### Manual Docker Builds
-
-All images support dynamic version selection:
-
-```bash
-# Build production image with latest release
-docker build --build-arg RELEASE="latest" -t rustfs:latest .
-
-# Build from source with specific target
-docker build -f Dockerfile.source \
-  --build-arg TARGETPLATFORM="linux/amd64" \
-  -t rustfs:source .
-
-# Development build
-docker build -f Dockerfile.source -t rustfs:dev .
-```
-
-## 🔧 Binary Download Sources
-
-### Unified GitHub Releases
-
-The production image downloads from GitHub Releases for reliability and transparency:
-
-- ✅ **production** → GitHub Releases API with automatic latest detection
-- ✅ **Checksum verification** → SHA256SUMS validation when available
-- ✅ **Multi-architecture** → Supports amd64 and arm64
-
-### Source Build
-
-The source variant compiles from source code with advanced features:
-
-- 🔧 **Cross-compilation** → Supports multiple target platforms via `TARGETPLATFORM`
-- ⚡ **Build caching** → sccache for faster compilation
-- 🎯 **Optimized builds** → Release optimizations with LTO and symbol stripping
-
-## 📋 Architecture Support
-
-All variants support multi-architecture builds:
-
-- **linux/amd64** (x86_64)
-- **linux/arm64** (aarch64)
-
-Architecture is automatically detected during build using Docker's `TARGETARCH` build argument.
-
-## 🔐 Security Features
-
-- **Checksum Verification**: Production image verifies SHA256SUMS when available
-- **Non-root User**: All images run as user `rustfs` (UID 1000)
-- **Minimal Runtime**: Production image only includes necessary dependencies
-- **Secure Defaults**: No hardcoded credentials or keys
-
-## 🛠️ Development Workflow
-
-### Quick Start with Makefile (Recommended)
-
-```bash
-# 1. Start development environment
-make dev-env-start
-
-# 2. Your development container is now running with:
-#    - Port 9000 exposed for RustFS
-#    - Port 9010 exposed for admin console
-#    - Current directory mounted as /workspace
-
-# 3. Stop when done
-make dev-env-stop
-```
-
-### Manual Development Setup
-
-```bash
-# Build development image from source
-make docker-dev-local
-
-# Or use traditional Docker commands
-docker build -f Dockerfile.source -t rustfs:dev .
-
-# Run with development tools
-docker run -it -v $(pwd):/workspace -p 9000:9000 rustfs:dev bash
-
-# Or use docker-compose for complex setups
-docker-compose up rustfs-dev
-```
-
-### Common Development Tasks
-
-```bash
-# Build and test locally
-make build                        # Build binary natively
-make docker-dev-local            # Build development Docker image
-make test                        # Run tests
-make fmt                         # Format code
-make clippy                      # Run linter
-
-# Get help
-make help                        # General help
-make help-docker                 # Docker-specific help
-make help-build                  # Build-specific help
-```
-
-## 🚀 CI/CD Integration
-
-The project uses GitHub Actions for automated multi-architecture Docker builds:
-
-### Automated Builds
-
-- **Tags**: Automatic builds triggered on version tags (e.g., `v1.2.3`)
-- **Main Branch**: Development builds with `dev-latest` and `main-latest` tags
-- **Pull Requests**: Test builds without registry push
-
-### Build Variants
-
-Each build creates three image variants:
-
-- `rustfs/rustfs:v1.2.3` (production - Alpine-based)
-- `rustfs/rustfs:v1.2.3-source` (source build - Debian-based)
-- `rustfs/rustfs:v1.2.3-dev` (development - Debian-based with tools)
-
-### Manual Builds
-
-Trigger custom builds via GitHub Actions:
-
-```bash
-# Use workflow_dispatch to build specific versions
-# Available options: latest, main-latest, dev-latest, v1.2.3, dev-abc123
-```
-
-## 📦 Supporting Infrastructure
-
-The `.docker/` directory contains supporting configuration files:
-
-- **observability/** - Prometheus, Grafana, OpenTelemetry configs
-- **compose/** - Multi-service Docker Compose setups
-- **mqtt/** - MQTT broker configurations
-- **openobserve-otel/** - Log aggregation and tracing setup
-
-See individual README files in each subdirectory for specific usage instructions.

.docker/compose/README.md

@@ -1,80 +0,0 @@
-# Docker Compose Configurations
-
-This directory contains specialized Docker Compose configurations for different use cases.
-
-## 📁 Configuration Files
-
-This directory contains specialized Docker Compose configurations and their associated Dockerfiles, keeping related files organized together.
-
-### Main Configuration (Root Directory)
-
-- **`../../docker-compose.yml`** - **Default Production Setup**
-  - Complete production-ready configuration
-  - Includes RustFS server + full observability stack
-  - Supports multiple profiles: `dev`, `observability`, `cache`, `proxy`
-  - Recommended for most users
-
-### Specialized Configurations
-
-- **`docker-compose.cluster.yaml`** - **Distributed Testing**
-  - 4-node cluster setup for testing distributed storage
-  - Uses local compiled binaries
-  - Simulates multi-node environment
-  - Ideal for development and cluster testing
-
-- **`docker-compose.observability.yaml`** - **Observability Focus**
-  - Specialized setup for testing observability features
-  - Includes OpenTelemetry, Jaeger, Prometheus, Loki, Grafana
-  - Uses `../../Dockerfile.source` for builds
-  - Perfect for observability development
-
-## 🚀 Usage Examples
-
-### Production Setup
-
-```bash
-# Start main service
-docker-compose up -d
-
-# Start with development profile
-docker-compose --profile dev up -d
-
-# Start with full observability
-docker-compose --profile observability up -d
-```
-
-### Cluster Testing
-
-```bash
-# Build and start 4-node cluster (run from project root)
-cd .docker/compose
-docker-compose -f docker-compose.cluster.yaml up -d
-
-# Or run directly from project root
-docker-compose -f .docker/compose/docker-compose.cluster.yaml up -d
-```
-
-### Observability Testing
-
-```bash
-# Start observability-focused environment (run from project root)
-cd .docker/compose
-docker-compose -f docker-compose.observability.yaml up -d
-
-# Or run directly from project root
-docker-compose -f .docker/compose/docker-compose.observability.yaml up -d
-```
-
-## 🔧 Configuration Overview
-
-| Configuration | Nodes | Storage | Observability | Use Case |
-|---------------|-------|---------|---------------|----------|
-| **Main** | 1 | Volume mounts | Full stack | Production |
-| **Cluster** | 4 | HTTP endpoints | Basic | Testing |
-| **Observability** | 4 | Local data | Advanced | Development |
-
-## 📝 Notes
-
-- Always ensure you have built the required binaries before starting cluster tests
-- The main configuration is sufficient for most use cases
-- Specialized configurations are for specific testing scenarios

.docker/compose/docker-compose.cluster.yaml

@@ -1,82 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-services:
-  node0:
-    image: rustfs/rustfs:latest # Replace with your image name and label
-    container_name: node0
-    hostname: node0
-    environment:
-      - RUSTFS_VOLUMES=http://node{0...3}:9000/data/rustfs{0...3}
-      - RUSTFS_ADDRESS=0.0.0.0:9000
-      - RUSTFS_CONSOLE_ENABLE=true
-      - RUSTFS_ACCESS_KEY=rustfsadmin
-      - RUSTFS_SECRET_KEY=rustfsadmin
-    platform: linux/amd64
-    ports:
-      - "9000:9000" # Map port 9001 of the host to port 9000 of the container
-    volumes:
-      - ../../target/x86_64-unknown-linux-gnu/release/rustfs:/app/rustfs
-    command: "/app/rustfs"
-
-  node1:
-    image: rustfs/rustfs:latest
-    container_name: node1
-    hostname: node1
-    environment:
-      - RUSTFS_VOLUMES=http://node{0...3}:9000/data/rustfs{0...3}
-      - RUSTFS_ADDRESS=0.0.0.0:9000
-      - RUSTFS_CONSOLE_ENABLE=true
-      - RUSTFS_ACCESS_KEY=rustfsadmin
-      - RUSTFS_SECRET_KEY=rustfsadmin
-    platform: linux/amd64
-    ports:
-      - "9001:9000" # Map port 9002 of the host to port 9000 of the container
-    volumes:
-      - ../../target/x86_64-unknown-linux-gnu/release/rustfs:/app/rustfs
-    command: "/app/rustfs"
-
-  node2:
-    image: rustfs/rustfs:latest
-    container_name: node2
-    hostname: node2
-    environment:
-      - RUSTFS_VOLUMES=http://node{0...3}:9000/data/rustfs{0...3}
-      - RUSTFS_ADDRESS=0.0.0.0:9000
-      - RUSTFS_CONSOLE_ENABLE=true
-      - RUSTFS_ACCESS_KEY=rustfsadmin
-      - RUSTFS_SECRET_KEY=rustfsadmin
-    platform: linux/amd64
-    ports:
-      - "9002:9000" # Map port 9003 of the host to port 9000 of the container
-    volumes:
-      - ../../target/x86_64-unknown-linux-gnu/release/rustfs:/app/rustfs
-    command: "/app/rustfs"
-
-  node3:
-    image: rustfs/rustfs:latest
-    container_name: node3
-    hostname: node3
-    environment:
-      - RUSTFS_VOLUMES=http://node{0...3}:9000/data/rustfs{0...3}
-      - RUSTFS_ADDRESS=0.0.0.0:9000
-      - RUSTFS_CONSOLE_ENABLE=true
-      - RUSTFS_ACCESS_KEY=rustfsadmin
-      - RUSTFS_SECRET_KEY=rustfsadmin
-    platform: linux/amd64
-    ports:
-      - "9003:9000" # Map port 9004 of the host to port 9000 of the container
-    volumes:
-      - ../../target/x86_64-unknown-linux-gnu/release/rustfs:/app/rustfs
-    command: "/app/rustfs"

.docker/compose/docker-compose.observability.yaml

@@ -1,146 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-services:
-  otel-collector:
-    image: otel/opentelemetry-collector-contrib:0.129.1
-    environment:
-      - TZ=Asia/Shanghai
-    volumes:
-      - ../../.docker/observability/otel-collector-config.yaml:/etc/otelcol-contrib/config.yaml
-    ports:
-      - 1888:1888
-      - 8888:8888
-      - 8889:8889
-      - 13133:13133
-      - 4317:4317
-      - 4318:4318
-      - 55679:55679
-    networks:
-      - rustfs-network
-  jaeger:
-    image: jaegertracing/jaeger:2.8.0
-    environment:
-      - TZ=Asia/Shanghai
-    ports:
-      - "16686:16686"
-      - "14317:4317"
-      - "14318:4318"
-    networks:
-      - rustfs-network
-  prometheus:
-    image: prom/prometheus:v3.4.2
-    environment:
-      - TZ=Asia/Shanghai
-    volumes:
-      - ../../.docker/observability/prometheus.yml:/etc/prometheus/prometheus.yml
-    ports:
-      - "9090:9090"
-    networks:
-      - rustfs-network
-  loki:
-    image: grafana/loki:3.5.1
-    environment:
-      - TZ=Asia/Shanghai
-    volumes:
-      - ../../.docker/observability/loki-config.yaml:/etc/loki/local-config.yaml
-    ports:
-      - "3100:3100"
-    command: -config.file=/etc/loki/local-config.yaml
-    networks:
-      - rustfs-network
-  grafana:
-    image: grafana/grafana:12.0.2
-    ports:
-      - "3000:3000" # Web UI
-    environment:
-      - GF_SECURITY_ADMIN_PASSWORD=admin
-      - TZ=Asia/Shanghai
-    networks:
-      - rustfs-network
-
-  node1:
-    build:
-      context: ../..
-      dockerfile: Dockerfile.source
-    container_name: node1
-    environment:
-      - RUSTFS_VOLUMES=http://node{1...4}:9000/root/data/target/volume/test{1...4}
-      - RUSTFS_ADDRESS=:9000
-      - RUSTFS_CONSOLE_ENABLE=true
-      - RUSTFS_OBS_ENDPOINT=http://otel-collector:4317
-      - RUSTFS_OBS_LOGGER_LEVEL=debug
-    platform: linux/amd64
-    ports:
-      - "9001:9000" # Map port 9001 of the host to port 9000 of the container
-    networks:
-      - rustfs-network
-
-  node2:
-    build:
-      context: ../..
-      dockerfile: Dockerfile.source
-    container_name: node2
-    environment:
-      - RUSTFS_VOLUMES=http://node{1...4}:9000/root/data/target/volume/test{1...4}
-      - RUSTFS_ADDRESS=:9000
-      - RUSTFS_CONSOLE_ENABLE=true
-      - RUSTFS_OBS_ENDPOINT=http://otel-collector:4317
-      - RUSTFS_OBS_LOGGER_LEVEL=debug
-    platform: linux/amd64
-    ports:
-      - "9002:9000" # Map port 9002 of the host to port 9000 of the container
-    networks:
-      - rustfs-network
-
-  node3:
-    build:
-      context: ../..
-      dockerfile: Dockerfile.source
-    container_name: node3
-    environment:
-      - RUSTFS_VOLUMES=http://node{1...4}:9000/root/data/target/volume/test{1...4}
-      - RUSTFS_ADDRESS=:9000
-      - RUSTFS_CONSOLE_ENABLE=true
-      - RUSTFS_OBS_ENDPOINT=http://otel-collector:4317
-      - RUSTFS_OBS_LOGGER_LEVEL=debug
-    platform: linux/amd64
-    ports:
-      - "9003:9000" # Map port 9003 of the host to port 9000 of the container
-    networks:
-      - rustfs-network
-
-  node4:
-    build:
-      context: ../..
-      dockerfile: Dockerfile.source
-    container_name: node4
-    environment:
-      - RUSTFS_VOLUMES=http://node{1...4}:9000/root/data/target/volume/test{1...4}
-      - RUSTFS_ADDRESS=:9000
-      - RUSTFS_CONSOLE_ENABLE=true
-      - RUSTFS_OBS_ENDPOINT=http://otel-collector:4317
-      - RUSTFS_OBS_LOGGER_LEVEL=debug
-    platform: linux/amd64
-    ports:
-      - "9004:9000" # Map port 9004 of the host to port 9000 of the container
-    networks:
-      - rustfs-network
-
-networks:
-  rustfs-network:
-    driver: bridge
-    name: "network_rustfs_config"
-    driver_opts:
-      com.docker.network.enable_ipv6: "true"

.docker/mqtt/config/emqx.conf

@@ -1,37 +0,0 @@
-# 节点配置
-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

.docker/mqtt/config/vm.args

@@ -1,9 +0,0 @@
--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"

.docker/mqtt/docker-compose-more.yml

@@ -1,74 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-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

.docker/mqtt/docker-compose.yml

@@ -1,29 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-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

.docker/observability/README.md

@@ -1,109 +0,0 @@
-# Observability
-
-This directory contains the observability stack for the application. The stack is composed of the following components:
-
-- Prometheus v3.2.1
-- Grafana 11.6.0
-- Loki 3.4.2
-- Jaeger 2.4.0
-- Otel Collector 0.120.0 # 0.121.0 remove loki
-
-## Prometheus
-
-Prometheus is a monitoring and alerting toolkit. It scrapes metrics from instrumented jobs, either directly or via an
-intermediary push gateway for short-lived jobs. It stores all scraped samples locally and runs rules over this data to
-either aggregate and record new time series from existing data or generate alerts. Grafana or other API consumers can be
-used to visualize the collected data.
-
-## Grafana
-
-Grafana is a multi-platform open-source analytics and interactive visualization web application. It provides charts,
-graphs, and alerts for the web when connected to supported data sources.
-
-## Loki
-
-Loki is a horizontally-scalable, highly-available, multi-tenant log aggregation system inspired by Prometheus. It is
-designed to be very cost-effective and easy to operate. It does not index the contents of the logs, but rather a set of
-labels for each log stream.
-
-## Jaeger
-
-Jaeger is a distributed tracing system released as open source by Uber Technologies. It is used for monitoring and
-troubleshooting microservices-based distributed systems, including:
-
-- Distributed context propagation
-- Distributed transaction monitoring
-- Root cause analysis
-- Service dependency analysis
-- Performance / latency optimization
-
-## Otel Collector
-
-The OpenTelemetry Collector offers a vendor-agnostic implementation on how to receive, process, and export telemetry
-data. It removes the need to run, operate, and maintain multiple agents/collectors in order to support open-source
-observability data formats (e.g. Jaeger, Prometheus, etc.) sending to one or more open-source or commercial back-ends.
-
-## How to use
-
-To deploy the observability stack, run the following command:
-
-- docker latest version
-
-```bash
-docker compose -f docker-compose.yml -f docker-compose.override.yml up -d
-```
-
-- docker compose v2.0.0 or before
-
-```bash
-docke-compose -f docker-compose.yml -f docker-compose.override.yml up -d
-```
-
-To access the Grafana dashboard, navigate to `http://localhost:3000` in your browser. The default username and password
-are `admin` and `admin`, respectively.
-
-To access the Jaeger dashboard, navigate to `http://localhost:16686` in your browser.
-
-To access the Prometheus dashboard, navigate to `http://localhost:9090` in your browser.
-
-## How to stop
-
-To stop the observability stack, run the following command:
-
-```bash
-docker compose -f docker-compose.yml -f docker-compose.override.yml down
-```
-
-## How to remove data
-
-To remove the data generated by the observability stack, run the following command:
-
-```bash
-docker compose -f docker-compose.yml -f docker-compose.override.yml down -v
-```
-
-## How to configure
-
-To configure the observability stack, modify the `docker-compose.override.yml` file. The file contains the following
-
-```yaml
-services:
-  prometheus:
-    environment:
-      - PROMETHEUS_CONFIG_FILE=/etc/prometheus/prometheus.yml
-    volumes:
-      - ./prometheus.yml:/etc/prometheus/prometheus.yml
-
-  grafana:
-    environment:
-      - GF_SECURITY_ADMIN_PASSWORD=admin
-    volumes:
-      - ./grafana/provisioning:/etc/grafana/provisioning
-```
-
-The `prometheus` service mounts the `prometheus.yml` file to `/etc/prometheus/prometheus.yml`. The `grafana` service
-mounts the `grafana/provisioning` directory to `/etc/grafana/provisioning`. You can modify these files to configure the
-observability stack.
-
-
-

.docker/observability/README_ZH.md

@@ -1,27 +0,0 @@
-## 部署可观测性系统
-
-OpenTelemetry Collector 提供了一个厂商中立的遥测数据处理方案，用于接收、处理和导出遥测数据。它消除了为支持多种开源可观测性数据格式（如
-Jaeger、Prometheus 等）而需要运行和维护多个代理/收集器的必要性。
-
-### 快速部署
-
-1. 进入 `.docker/observability` 目录
-2. 执行以下命令启动服务：
-
-```bash
-docker compose -f docker-compose.yml  up -d
-```
-
-### 访问监控面板
-
-服务启动后，可通过以下地址访问各个监控面板：
-
-- Grafana: `http://localhost:3000` (默认账号/密码：`admin`/`admin`)
-- Jaeger: `http://localhost:16686`
-- Prometheus: `http://localhost:9090`
-
-## 配置可观测性
-
-```shell
-export RUSTFS_OBS_ENDPOINT="http://localhost:4317" # OpenTelemetry Collector 地址
-```

.docker/observability/docker-compose.yml

@@ -1,97 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-services:
-
-  tempo:
-    image: grafana/tempo:latest
-    #user: root # The container must be started with root to execute chown in the script
-    #entrypoint: [ "/etc/tempo/entrypoint.sh" ]  # Specify a custom entry point
-    command: [ "-config.file=/etc/tempo.yaml" ] # This is passed as a parameter to the entry point script
-    volumes:
-      - ./tempo-entrypoint.sh:/etc/tempo/entrypoint.sh # Mount entry point script
-      - ./tempo.yaml:/etc/tempo.yaml
-      - ./tempo-data:/var/tempo
-    ports:
-      - "3200:3200" # tempo
-      - "24317:4317" # otlp grpc
-    networks:
-      - otel-network
-
-  otel-collector:
-    image: otel/opentelemetry-collector-contrib:0.129.1
-    environment:
-      - TZ=Asia/Shanghai
-    volumes:
-      - ./otel-collector-config.yaml:/etc/otelcol-contrib/config.yaml
-    ports:
-      - "1888:1888"
-      - "8888:8888"
-      - "8889:8889"
-      - "13133:13133"
-      - "4317:4317"
-      - "4318:4318"
-      - "55679:55679"
-    networks:
-      - otel-network
-  jaeger:
-    image: jaegertracing/jaeger:2.8.0
-    environment:
-      - TZ=Asia/Shanghai
-    ports:
-      - "16686:16686"
-      - "14317:4317"
-      - "14318:4318"
-    networks:
-      - otel-network
-  prometheus:
-    image: prom/prometheus:v3.4.2
-    environment:
-      - TZ=Asia/Shanghai
-    volumes:
-      - ./prometheus.yml:/etc/prometheus/prometheus.yml
-    ports:
-      - "9090:9090"
-    networks:
-      - otel-network
-  loki:
-    image: grafana/loki:3.5.1
-    environment:
-      - TZ=Asia/Shanghai
-    volumes:
-      - ./loki-config.yaml:/etc/loki/local-config.yaml
-    ports:
-      - "3100:3100"
-    command: -config.file=/etc/loki/local-config.yaml
-    networks:
-      - otel-network
-  grafana:
-    image: grafana/grafana:12.0.2
-    ports:
-      - "3000:3000"  # Web UI
-    volumes:
-      - ./grafana-datasources.yaml:/etc/grafana/provisioning/datasources/datasources.yaml
-    environment:
-      - GF_SECURITY_ADMIN_PASSWORD=admin
-      - TZ=Asia/Shanghai
-    networks:
-      - otel-network
-
-
-networks:
-  otel-network:
-    driver: bridge
-    name: "network_otel_config"
-    driver_opts:
-      com.docker.network.enable_ipv6: "true"    

.docker/observability/grafana-datasources.yaml

@@ -1,32 +0,0 @@
-apiVersion: 1
-
-datasources:
-  - name: Prometheus
-    type: prometheus
-    uid: prometheus
-    access: proxy
-    orgId: 1
-    url: http://prometheus:9090
-    basicAuth: false
-    isDefault: false
-    version: 1
-    editable: false
-    jsonData:
-      httpMethod: GET
-  - name: Tempo
-    type: tempo
-    access: proxy
-    orgId: 1
-    url: http://tempo:3200
-    basicAuth: false
-    isDefault: true
-    version: 1
-    editable: false
-    apiVersion: 1
-    uid: tempo
-    jsonData:
-      httpMethod: GET
-      serviceMap:
-        datasourceUid: prometheus
-      streamingEnabled:
-        search: true

.docker/observability/jaeger-config.yaml

@@ -1,112 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-service:
-  extensions: [ jaeger_storage, jaeger_query, remote_sampling, healthcheckv2 ]
-  pipelines:
-    traces:
-      receivers: [ otlp, jaeger, zipkin ]
-      processors: [ batch, adaptive_sampling ]
-      exporters: [ jaeger_storage_exporter ]
-  telemetry:
-    resource:
-      service.name: jaeger
-    metrics:
-      level: detailed
-      readers:
-        - pull:
-            exporter:
-              prometheus:
-                host: 0.0.0.0
-                port: 8888
-    logs:
-      level: debug
-    # TODO Initialize telemetry tracer once OTEL released new feature.
-    # https://github.com/open-telemetry/opentelemetry-collector/issues/10663
-
-extensions:
-  healthcheckv2:
-    use_v2: true
-    http:
-
-  # pprof:
-  #   endpoint: 0.0.0.0:1777
-  # zpages:
-  #   endpoint: 0.0.0.0:55679
-
-  jaeger_query:
-    storage:
-      traces: some_store
-      traces_archive: another_store
-    ui:
-      config_file: ./cmd/jaeger/config-ui.json
-      log_access: true
-    # The maximum duration that is considered for clock skew adjustments.
-    # Defaults to 0 seconds, which means it's disabled.
-    max_clock_skew_adjust: 0s
-    grpc:
-      endpoint: 0.0.0.0:16685
-    http:
-      endpoint: 0.0.0.0:16686
-
-  jaeger_storage:
-    backends:
-      some_store:
-        memory:
-          max_traces: 1000000
-      another_store:
-        memory:
-          max_traces: 1000000
-    metric_backends:
-      some_metrics_storage:
-        prometheus:
-          endpoint: http://prometheus:9090
-          normalize_calls: true
-          normalize_duration: true
-
-  remote_sampling:
-    # You can either use file or adaptive sampling strategy in remote_sampling
-    # file:
-    #   path: ./cmd/jaeger/sampling-strategies.json
-    adaptive:
-      sampling_store: some_store
-      initial_sampling_probability: 0.1
-    http:
-    grpc:
-
-receivers:
-  otlp:
-    protocols:
-      grpc:
-      http:
-
-  jaeger:
-    protocols:
-      grpc:
-      thrift_binary:
-      thrift_compact:
-      thrift_http:
-
-  zipkin:
-
-processors:
-  batch:
-  # Adaptive Sampling Processor is required to support adaptive sampling.
-  # It expects remote_sampling extension with `adaptive:` config to be enabled.
-  adaptive_sampling:
-
-exporters:
-  jaeger_storage_exporter:
-    trace_storage: some_store
-

.docker/observability/loki-config.yaml

@@ -1,77 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-auth_enabled: false
-
-server:
-  http_listen_port: 3100
-  grpc_listen_port: 9096
-  log_level: debug
-  grpc_server_max_concurrent_streams: 1000
-
-common:
-  instance_addr: 127.0.0.1
-  path_prefix: /tmp/loki
-  storage:
-    filesystem:
-      chunks_directory: /tmp/loki/chunks
-      rules_directory: /tmp/loki/rules
-  replication_factor: 1
-  ring:
-    kvstore:
-      store: inmemory
-
-query_range:
-  results_cache:
-    cache:
-      embedded_cache:
-        enabled: true
-        max_size_mb: 100
-
-limits_config:
-  metric_aggregation_enabled: true
-
-schema_config:
-  configs:
-    - from: 2020-10-24
-      store: tsdb
-      object_store: filesystem
-      schema: v13
-      index:
-        prefix: index_
-        period: 24h
-
-pattern_ingester:
-  enabled: true
-  metric_aggregation:
-    loki_address: localhost:3100
-
-ruler:
-  alertmanager_url: http://localhost:9093
-
-frontend:
-  encoding: protobuf
-
-# By default, Loki will send anonymous, but uniquely-identifiable usage and configuration
-# analytics to Grafana Labs. These statistics are sent to https://stats.grafana.org/
-#
-# Statistics help us better understand how Loki is used, and they show us performance
-# levels for most users. This helps us prioritize features and documentation.
-# For more information on what's sent, look at
-# https://github.com/grafana/loki/blob/main/pkg/analytics/stats.go
-# Refer to the buildReport method to see what goes into a report.
-#
-# If you would like to disable reporting, uncomment the following lines:
-#analytics:
-#  reporting_enabled: false

.docker/observability/otel-collector-config.yaml

@@ -1,81 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-receivers:
-  otlp:
-    protocols:
-      grpc: # OTLP gRPC 接收器
-        endpoint: 0.0.0.0:4317
-      http: # OTLP HTTP 接收器
-        endpoint: 0.0.0.0:4318
-
-processors:
-  batch: # 批处理处理器，提升吞吐量
-    timeout: 5s
-    send_batch_size: 1000
-  memory_limiter:
-    check_interval: 1s
-    limit_mib: 512
-
-exporters:
-  otlp/traces: # OTLP 导出器，用于跟踪数据
-    endpoint: "jaeger:4317"  # Jaeger 的 OTLP gRPC 端点
-    tls:
-      insecure: true  # 开发环境禁用 TLS，生产环境需配置证书
-  otlp/tempo: # OTLP 导出器，用于跟踪数据
-    endpoint: "tempo:4317"  # tempo 的 OTLP gRPC 端点
-    tls:
-      insecure: true  # 开发环境禁用 TLS，生产环境需配置证书
-  prometheus: # Prometheus 导出器，用于指标数据
-    endpoint: "0.0.0.0:8889"  # Prometheus 刮取端点
-    namespace: "rustfs"  # 指标前缀
-    send_timestamps: true  # 发送时间戳
-    # enable_open_metrics: true
-  loki: # Loki 导出器，用于日志数据
-    # endpoint: "http://loki:3100/otlp/v1/logs"
-    endpoint: "http://loki:3100/loki/api/v1/push"
-    tls:
-      insecure: true
-extensions:
-  health_check:
-  pprof:
-  zpages:
-service:
-  extensions: [ health_check, pprof, zpages ]  # 启用扩展
-  pipelines:
-    traces:
-      receivers: [ otlp ]
-      processors: [ memory_limiter,batch ]
-      exporters: [ otlp/traces,otlp/tempo ]
-    metrics:
-      receivers: [ otlp ]
-      processors: [ batch ]
-      exporters: [ prometheus ]
-    logs:
-      receivers: [ otlp ]
-      processors: [ batch ]
-      exporters: [ loki ]
-  telemetry:
-    logs:
-      level: "info"  # Collector 日志级别
-    metrics:
-      level: "detailed" # 可以是 basic, normal, detailed
-      readers:
-        - periodic:
-            exporter:
-              otlp:
-                protocol: http/protobuf
-                endpoint: http://otel-collector:4318
-
-

.docker/observability/prometheus.yml

@@ -1,28 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-global:
-  scrape_interval: 5s  # 刮取间隔
-
-scrape_configs:
-  - job_name: 'otel-collector'
-    static_configs:
-      - targets: [ 'otel-collector:8888' ]  # 从 Collector 刮取指标
-  - job_name: 'otel-metrics'
-    static_configs:
-      - targets: [ 'otel-collector:8889' ]  # 应用指标
-  - job_name: 'tempo'
-    static_configs:
-      - targets: [ 'tempo:3200' ]
-      

.docker/observability/tempo-data/.gitignore

@@ -1 +0,0 @@
-*

.docker/observability/tempo-entrypoint.sh

@@ -1,8 +0,0 @@
-#!/bin/sh
-# Run as root to fix directory permissions
-chown -R 10001:10001 /var/tempo
-
-# Use su-exec (a lightweight sudo/gosu alternative, commonly used in Alpine mirroring)
-# Switch to user 10001 and execute the original command (CMD) passed to the script
-# "$@" represents all parameters passed to this script, i.e. command in docker-compose
-exec su-exec 10001:10001 /tempo "$@"

.docker/observability/tempo.yaml

@@ -1,55 +0,0 @@
-stream_over_http_enabled: true
-server:
-  http_listen_port: 3200
-  log_level: info
-
-query_frontend:
-  search:
-    duration_slo: 5s
-    throughput_bytes_slo: 1.073741824e+09
-    metadata_slo:
-      duration_slo: 5s
-      throughput_bytes_slo: 1.073741824e+09
-  trace_by_id:
-    duration_slo: 5s
-
-distributor:
-  receivers:
-    otlp:
-      protocols:
-        grpc:
-          endpoint: "tempo:4317"
-
-ingester:
-  max_block_duration: 5m # cut the headblock when this much time passes. this is being set for demo purposes and should probably be left alone normally
-
-compactor:
-  compaction:
-    block_retention: 1h # overall Tempo trace retention. set for demo purposes
-
-metrics_generator:
-  registry:
-    external_labels:
-      source: tempo
-      cluster: docker-compose
-  storage:
-    path: /var/tempo/generator/wal
-    remote_write:
-      - url: http://prometheus:9090/api/v1/write
-        send_exemplars: true
-  traces_storage:
-    path: /var/tempo/generator/traces
-
-storage:
-  trace:
-    backend: local # backend configuration to use
-    wal:
-      path: /var/tempo/wal # where to store the wal locally
-    local:
-      path: /var/tempo/blocks
-
-overrides:
-  defaults:
-    metrics_generator:
-      processors: [ service-graphs, span-metrics, local-blocks ] # enables metrics generator
-      generate_native_histograms: both

.docker/openobserve-otel/README.md

@@ -1,75 +0,0 @@
-# OpenObserve + OpenTelemetry Collector
-
-[![OpenObserve](https://img.shields.io/badge/OpenObserve-OpenSource-blue.svg)](https://openobserve.org)
-[![OpenTelemetry](https://img.shields.io/badge/OpenTelemetry-Collector-green.svg)](https://opentelemetry.io/)
-
-English | [中文](README_ZH.md)
-
-This directory contains the configuration files for setting up an observability stack with OpenObserve and OpenTelemetry
-Collector.
-
-### Overview
-
-This setup provides a complete observability solution for your applications:
-
-- **OpenObserve**: A modern, open-source observability platform for logs, metrics, and traces.
-- **OpenTelemetry Collector**: Collects and processes telemetry data before sending it to OpenObserve.
-
-### Setup Instructions
-
-1. **Prerequisites**:
-    - Docker and Docker Compose installed
-    - Sufficient memory resources (minimum 2GB recommended)
-
-2. **Starting the Services**:
-   ```bash
-   cd .docker/openobserve-otel
-   docker compose -f docker-compose.yml  up -d
-   ```
-
-3. **Accessing the Dashboard**:
-    - OpenObserve UI: http://localhost:5080
-    - Default credentials:
-        - Username: root@rustfs.com
-        - Password: rustfs123
-
-### Configuration
-
-#### OpenObserve Configuration
-
-The OpenObserve service is configured with:
-
-- Root user credentials
-- Data persistence through a volume mount
-- Memory cache enabled
-- Health checks
-- Exposed ports:
-    - 5080: HTTP API and UI
-    - 5081: OTLP gRPC
-
-#### OpenTelemetry Collector Configuration
-
-The collector is configured to:
-
-- Receive telemetry data via OTLP (HTTP and gRPC)
-- Collect logs from files
-- Process data in batches
-- Export data to OpenObserve
-- Manage memory usage
-
-### Integration with Your Application
-
-To send telemetry data from your application, configure your OpenTelemetry SDK to send data to:
-
-- OTLP gRPC: `localhost:4317`
-- OTLP HTTP: `localhost:4318`
-
-For example, in a Rust application using the `rustfs-obs` library:
-
-```bash
-export RUSTFS_OBS_ENDPOINT=http://localhost:4317
-export RUSTFS_OBS_SERVICE_NAME=yourservice
-export RUSTFS_OBS_SERVICE_VERSION=1.0.0
-export RUSTFS_OBS_ENVIRONMENT=development
-```
-

.docker/openobserve-otel/README_ZH.md

@@ -1,75 +0,0 @@
-# OpenObserve + OpenTelemetry Collector
-
-[![OpenObserve](https://img.shields.io/badge/OpenObserve-OpenSource-blue.svg)](https://openobserve.org)
-[![OpenTelemetry](https://img.shields.io/badge/OpenTelemetry-Collector-green.svg)](https://opentelemetry.io/)
-
-[English](README.md) | 中文
-
-## 中文
-
-本目录包含搭建 OpenObserve 和 OpenTelemetry Collector 可观测性栈的配置文件。
-
-### 概述
-
-此设置为应用程序提供了完整的可观测性解决方案：
-
-- **OpenObserve**：现代化、开源的可观测性平台，用于日志、指标和追踪。
-- **OpenTelemetry Collector**：收集和处理遥测数据，然后将其发送到 OpenObserve。
-
-### 设置说明
-
-1. **前提条件**：
-    - 已安装 Docker 和 Docker Compose
-    - 足够的内存资源（建议至少 2GB）
-
-2. **启动服务**：
-   ```bash
-   cd .docker/openobserve-otel
-   docker compose -f docker-compose.yml  up -d
-   ```
-
-3. **访问仪表板**：
-    - OpenObserve UI：http://localhost:5080
-    - 默认凭据：
-        - 用户名：root@rustfs.com
-        - 密码：rustfs123
-
-### 配置
-
-#### OpenObserve 配置
-
-OpenObserve 服务配置：
-
-- 根用户凭据
-- 通过卷挂载实现数据持久化
-- 启用内存缓存
-- 健康检查
-- 暴露端口：
-    - 5080：HTTP API 和 UI
-    - 5081：OTLP gRPC
-
-#### OpenTelemetry Collector 配置
-
-收集器配置为：
-
-- 通过 OTLP（HTTP 和 gRPC）接收遥测数据
-- 从文件中收集日志
-- 批处理数据
-- 将数据导出到 OpenObserve
-- 管理内存使用
-
-### 与应用程序集成
-
-要从应用程序发送遥测数据，将 OpenTelemetry SDK 配置为发送数据到：
-
-- OTLP gRPC:`localhost:4317`
-- OTLP HTTP:`localhost:4318`
-
-例如，在使用 `rustfs-obs` 库的 Rust 应用程序中：
-
-```bash
-export RUSTFS_OBS_ENDPOINT=http://localhost:4317
-export RUSTFS_OBS_SERVICE_NAME=yourservice
-export RUSTFS_OBS_SERVICE_VERSION=1.0.0
-export RUSTFS_OBS_ENVIRONMENT=development
-```

.docker/openobserve-otel/docker-compose.yml

@@ -1,87 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-services:
-  openobserve:
-    image: public.ecr.aws/zinclabs/openobserve:latest
-    restart: unless-stopped
-    environment:
-      ZO_ROOT_USER_EMAIL: "root@rustfs.com"
-      ZO_ROOT_USER_PASSWORD: "rustfs123"
-      ZO_TRACING_HEADER_KEY: "Authorization"
-      ZO_TRACING_HEADER_VALUE: "Basic cm9vdEBydXN0ZnMuY29tOmQ4SXlCSEJTUkk3RGVlcEQ="
-      ZO_DATA_DIR: "/data"
-      ZO_MEMORY_CACHE_ENABLED: "true"
-      ZO_MEMORY_CACHE_MAX_SIZE: "256"
-      RUST_LOG: "info"
-      TZ: Asia/Shanghai
-    ports:
-      - "5080:5080"
-      - "5081:5081"
-    volumes:
-      - ./data:/data
-    healthcheck:
-      test: [ "CMD", "curl", "-f", "http://localhost:5080/health" ]
-      start_period: 60s
-      interval: 10s
-      timeout: 5s
-      retries: 6
-    networks:
-      - otel-network
-    deploy:
-      resources:
-        limits:
-          memory: 1024M
-        reservations:
-          memory: 512M
-
-  otel-collector:
-    image: otel/opentelemetry-collector-contrib:latest
-    restart: unless-stopped
-    environment:
-      - TZ=Asia/Shanghai
-    volumes:
-      - ./otel-collector-config.yaml:/etc/otelcol-contrib/config.yaml
-    ports:
-      - "4317:4317" # OTLP gRPC
-      - "4318:4318" # OTLP HTTP
-      - "13133:13133" # Health check
-      - "1777:1777" # pprof
-      - "55679:55679" # zpages
-      - "1888:1888" # Metrics
-      - "8888:8888" # Prometheus metrics
-      - "8889:8889" # Additional metrics endpoint
-    depends_on:
-      - openobserve
-    networks:
-      - otel-network
-    deploy:
-      resources:
-        limits:
-          memory: 10240M
-        reservations:
-          memory: 512M
-
-networks:
-  otel-network:
-    driver: bridge
-    name: otel-network
-    ipam:
-      config:
-        - subnet: 172.28.0.0/16
-          gateway: 172.28.0.1
-    labels:
-      com.example.description: "Network for OpenObserve and OpenTelemetry Collector"
-volumes:
-  data:

.docker/openobserve-otel/otel-collector-config.yaml

@@ -1,92 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-receivers:
-  otlp:
-    protocols:
-      grpc:
-        endpoint: 0.0.0.0:4317
-      http:
-        endpoint: 0.0.0.0:4318
-  filelog:
-    include: [ "/var/log/app/*.log" ]
-    start_at: end
-
-processors:
-  batch:
-    timeout: 1s
-    send_batch_size: 1024
-  memory_limiter:
-    check_interval: 1s
-    limit_mib: 400
-    spike_limit_mib: 100
-
-exporters:
-  otlphttp/openobserve:
-    endpoint: http://openobserve:5080/api/default # http://127.0.0.1:5080/api/default
-    headers:
-      Authorization: "Basic cm9vdEBydXN0ZnMuY29tOmQ4SXlCSEJTUkk3RGVlcEQ="
-      stream-name: default
-      organization: default
-    compression: gzip
-    retry_on_failure:
-      enabled: true
-      initial_interval: 5s
-      max_interval: 30s
-      max_elapsed_time: 300s
-    timeout: 10s
-  otlp/openobserve:
-    endpoint: openobserve:5081 # http://127.0.0.1:5080/api/default
-    headers:
-      Authorization: "Basic cm9vdEBydXN0ZnMuY29tOmQ4SXlCSEJTUkk3RGVlcEQ="
-      stream-name: default
-      organization: default
-    compression: gzip
-    retry_on_failure:
-      enabled: true
-      initial_interval: 5s
-      max_interval: 30s
-      max_elapsed_time: 300s
-    timeout: 10s
-    tls:
-      insecure: true
-
-extensions:
-  health_check:
-    endpoint: 0.0.0.0:13133
-  pprof:
-    endpoint: 0.0.0.0:1777
-  zpages:
-    endpoint: 0.0.0.0:55679
-
-service:
-  extensions: [ health_check, pprof, zpages ]
-  pipelines:
-    traces:
-      receivers: [ otlp ]
-      processors: [ memory_limiter, batch ]
-      exporters: [ otlp/openobserve ]
-    metrics:
-      receivers: [ otlp ]
-      processors: [ memory_limiter, batch ]
-      exporters: [ otlp/openobserve ]
-    logs:
-      receivers: [ otlp, filelog ]
-      processors: [ memory_limiter, batch ]
-      exporters: [ otlp/openobserve ]
-  telemetry:
-    logs:
-      level: "info"  # Collector 日志级别
-    metrics:
-      address: "0.0.0.0:8888"  # Collector 自身指标暴露

.dockerignore

@@ -1 +0,0 @@
-target

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,38 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Desktop (please complete the following information):**
- - OS: [e.g. iOS]
- - Browser [e.g. chrome, safari]
- - Version [e.g. 22]
-
-**Smartphone (please complete the following information):**
- - Device: [e.g. iPhone6]
- - OS: [e.g. iOS8.1]
- - Browser [e.g. stock browser, safari]
- - Version [e.g. 22]
-
-**Additional context**
-Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/actions/setup/action.yml

@@ -1,98 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-name: "Setup Rust Environment"
-description: "Setup Rust development environment with caching for RustFS"
-
-inputs:
-  rust-version:
-    description: "Rust version to install"
-    required: false
-    default: "stable"
-  cache-shared-key:
-    description: "Shared cache key for Rust dependencies"
-    required: false
-    default: "rustfs-deps"
-  cache-save-if:
-    description: "Condition for saving cache"
-    required: false
-    default: "true"
-  install-cross-tools:
-    description: "Install cross-compilation tools"
-    required: false
-    default: "false"
-  target:
-    description: "Target architecture to add"
-    required: false
-    default: ""
-  github-token:
-    description: "GitHub token for API access"
-    required: false
-    default: ""
-
-runs:
-  using: "composite"
-  steps:
-    - name: Install system dependencies (Ubuntu)
-      if: runner.os == 'Linux'
-      shell: bash
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y \
-          musl-tools \
-          build-essential \
-          lld \
-          libdbus-1-dev \
-          libwayland-dev \
-          libwebkit2gtk-4.1-dev \
-          libxdo-dev \
-          pkg-config \
-          libssl-dev
-
-    - name: Install protoc
-      uses: arduino/setup-protoc@v3
-      with:
-        version: "31.1"
-        repo-token: ${{ inputs.github-token }}
-
-    - name: Install flatc
-      uses: Nugine/setup-flatc@v1
-      with:
-        version: "25.2.10"
-
-    - name: Install Rust toolchain
-      uses: dtolnay/rust-toolchain@stable
-      with:
-        toolchain: ${{ inputs.rust-version }}
-        targets: ${{ inputs.target }}
-        components: rustfmt, clippy
-
-    - name: Install Zig
-      if: inputs.install-cross-tools == 'true'
-      uses: mlugg/setup-zig@v2
-
-    - name: Install cargo-zigbuild
-      if: inputs.install-cross-tools == 'true'
-      uses: taiki-e/install-action@cargo-zigbuild
-
-    - name: Install cargo-nextest
-      uses: taiki-e/install-action@cargo-nextest
-
-    - name: Setup Rust cache
-      uses: Swatinem/rust-cache@v2
-      with:
-        cache-all-crates: true
-        cache-on-failure: true
-        shared-key: ${{ inputs.cache-shared-key }}
-        save-if: ${{ inputs.cache-save-if }}

.github/dependabot.yml

@@ -1,29 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
-
-version: 2
-updates:
-  - package-ecosystem: "cargo" # See documentation for possible values
-    directory: "/" # Location of package manifests
-    schedule:
-      interval: "monthly"
-    groups:
-      dependencies:
-        patterns:
-          - "*"

.github/pull_request_template.md

@@ -1,37 +0,0 @@
-<!--
-Pull Request Template for RustFS
--->
-
-## Type of Change
-- [ ] New Feature
-- [ ] Bug Fix
-- [ ] Documentation
-- [ ] Performance Improvement
-- [ ] Test/CI
-- [ ] Refactor
-- [ ] Other:
-
-## Related Issues
-<!-- List related Issue numbers, e.g. #123 -->
-
-## Summary of Changes
-<!-- Briefly describe the main changes and motivation for this PR -->
-
-## Checklist
-- [ ] I have read and followed the [CONTRIBUTING.md](CONTRIBUTING.md) guidelines
-- [ ] Passed `make pre-commit`
-- [ ] Added/updated necessary tests
-- [ ] Documentation updated (if needed)
-- [ ] CI/CD passed (if applicable)
-
-## Impact
-- [ ] Breaking change (compatibility)
-- [ ] Requires doc/config/deployment update
-- [ ] Other impact:
-
-## Additional Notes
-<!-- Any extra information for reviewers -->
-
----
-
-Thank you for your contribution! Please ensure your PR follows the community standards ([CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md)) and sign the CLA if this is your first contribution.

.github/workflows/audit.yml

@@ -1,81 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-name: Security Audit
-
-on:
-  push:
-    branches: [ main ]
-    paths:
-      - '**/Cargo.toml'
-      - '**/Cargo.lock'
-      - '.github/workflows/audit.yml'
-  pull_request:
-    branches: [ main ]
-    paths:
-      - '**/Cargo.toml'
-      - '**/Cargo.lock'
-      - '.github/workflows/audit.yml'
-  schedule:
-    - cron: '0 0 * * 0' # Weekly on Sunday at midnight UTC
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  security-audit:
-    name: Security Audit
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-
-      - name: Install cargo-audit
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-audit
-
-      - name: Run security audit
-        run: |
-          cargo audit -D warnings --json | tee audit-results.json
-
-      - name: Upload audit results
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: security-audit-results-${{ github.run_number }}
-          path: audit-results.json
-          retention-days: 30
-
-  dependency-review:
-    name: Dependency Review
-    runs-on: ubuntu-latest
-    if: github.event_name == 'pull_request'
-    permissions:
-      contents: read
-      pull-requests: write
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-
-      - name: Dependency Review
-        uses: actions/dependency-review-action@v4
-        with:
-          fail-on-severity: moderate
-          comment-summary-in-pr: true

.github/workflows/build.yml

@@ -1,850 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Build and Release Workflow
-#
-# This workflow builds RustFS binaries and automatically triggers Docker image builds.
-#
-# Flow:
-# 1. Build binaries for multiple platforms
-# 2. Upload binaries to OSS storage
-# 3. Trigger docker.yml to build and push images using the uploaded binaries
-#
-# Manual Parameters:
-# - build_docker: Build and push Docker images (default: true)
-
-name: Build and Release
-
-on:
-  push:
-    tags: [ "*.*.*" ]
-    branches: [ main ]
-    paths-ignore:
-      - "**.md"
-      - "**.txt"
-      - ".github/**"
-      - "docs/**"
-      - "deploy/**"
-      - "scripts/dev_*.sh"
-      - "LICENSE*"
-      - "README*"
-      - "**/*.png"
-      - "**/*.jpg"
-      - "**/*.svg"
-      - ".gitignore"
-      - ".dockerignore"
-  pull_request:
-    branches: [ main ]
-    paths-ignore:
-      - "**.md"
-      - "**.txt"
-      - ".github/**"
-      - "docs/**"
-      - "deploy/**"
-      - "scripts/dev_*.sh"
-      - "LICENSE*"
-      - "README*"
-      - "**/*.png"
-      - "**/*.jpg"
-      - "**/*.svg"
-      - ".gitignore"
-      - ".dockerignore"
-  schedule:
-    - cron: "0 0 * * 0" # Weekly on Sunday at midnight UTC
-  workflow_dispatch:
-    inputs:
-      build_docker:
-        description: "Build and push Docker images after binary build"
-        required: false
-        default: true
-        type: boolean
-
-permissions:
-  contents: read
-
-env:
-  CARGO_TERM_COLOR: always
-  RUST_BACKTRACE: 1
-  # Optimize build performance
-  CARGO_INCREMENTAL: 0
-
-jobs:
-  # Build strategy check - determine build type based on trigger
-  build-check:
-    name: Build Strategy Check
-    runs-on: ubuntu-latest
-    outputs:
-      should_build: ${{ steps.check.outputs.should_build }}
-      build_type: ${{ steps.check.outputs.build_type }}
-      version: ${{ steps.check.outputs.version }}
-      short_sha: ${{ steps.check.outputs.short_sha }}
-      is_prerelease: ${{ steps.check.outputs.is_prerelease }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-
-      - name: Determine build strategy
-        id: check
-        run: |
-          should_build=false
-          build_type="none"
-          version=""
-          short_sha=""
-          is_prerelease=false
-
-          # Get short SHA for all builds
-          short_sha=$(git rev-parse --short HEAD)
-
-          # Determine build type based on trigger
-          if [[ "${{ startsWith(github.ref, 'refs/tags/') }}" == "true" ]]; then
-            # Tag push - release or prerelease
-            should_build=true
-            tag_name="${GITHUB_REF#refs/tags/}"
-            version="${tag_name}"
-
-            # Check if this is a prerelease
-            if [[ "$tag_name" == *"alpha"* ]] || [[ "$tag_name" == *"beta"* ]] || [[ "$tag_name" == *"rc"* ]]; then
-              build_type="prerelease"
-              is_prerelease=true
-              echo "🚀 Prerelease build detected: $tag_name"
-            else
-              build_type="release"
-              echo "📦 Release build detected: $tag_name"
-            fi
-          elif [[ "${{ github.ref }}" == "refs/heads/main" ]]; then
-            # Main branch push - development build
-            should_build=true
-            build_type="development"
-            version="dev-${short_sha}"
-            echo "🛠️  Development build detected"
-          elif [[ "${{ github.event_name }}" == "schedule" ]] || \
-               [[ "${{ github.event_name }}" == "workflow_dispatch" ]] || \
-               [[ "${{ contains(github.event.head_commit.message, '--build') }}" == "true" ]]; then
-            # Scheduled or manual build
-            should_build=true
-            build_type="development"
-            version="dev-${short_sha}"
-            echo "⚡ Manual/scheduled build detected"
-          fi
-
-          echo "should_build=$should_build" >> $GITHUB_OUTPUT
-          echo "build_type=$build_type" >> $GITHUB_OUTPUT
-          echo "version=$version" >> $GITHUB_OUTPUT
-          echo "short_sha=$short_sha" >> $GITHUB_OUTPUT
-          echo "is_prerelease=$is_prerelease" >> $GITHUB_OUTPUT
-
-          echo "📊 Build Summary:"
-          echo "  - Should build: $should_build"
-          echo "  - Build type: $build_type"
-          echo "  - Version: $version"
-          echo "  - Short SHA: $short_sha"
-          echo "  - Is prerelease: $is_prerelease"
-
-  # Build RustFS binaries
-  build-rustfs:
-    name: Build RustFS
-    needs: [ build-check ]
-    if: needs.build-check.outputs.should_build == 'true'
-    runs-on: ${{ matrix.os }}
-    timeout-minutes: 60
-    env:
-      RUSTFLAGS: ${{ matrix.cross == 'false' && '-C target-cpu=native' || '' }}
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          # Linux builds
-          - os: ubuntu-latest
-            target: x86_64-unknown-linux-musl
-            cross: false
-            platform: linux
-          - os: ubuntu-latest
-            target: aarch64-unknown-linux-musl
-            cross: true
-            platform: linux
-          - os: ubuntu-latest
-            target: x86_64-unknown-linux-gnu
-            cross: false
-            platform: linux
-          - os: ubuntu-latest
-            target: aarch64-unknown-linux-gnu
-            cross: true
-            platform: linux
-          # macOS builds
-          - os: macos-latest
-            target: aarch64-apple-darwin
-            cross: false
-            platform: macos
-          - os: macos-latest
-            target: x86_64-apple-darwin
-            cross: false
-            platform: macos
-          # Windows builds (temporarily disabled)
-          - os: windows-latest
-            target: x86_64-pc-windows-msvc
-            cross: false
-            platform: windows
-          #- os: windows-latest
-          #  target: aarch64-pc-windows-msvc
-          #  cross: true
-          #  platform: windows
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-
-      - name: Setup Rust environment
-        uses: ./.github/actions/setup
-        with:
-          rust-version: stable
-          target: ${{ matrix.target }}
-          cache-shared-key: build-${{ matrix.target }}-${{ hashFiles('**/Cargo.lock') }}
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          cache-save-if: ${{ github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/') }}
-          install-cross-tools: ${{ matrix.cross }}
-
-      - name: Download static console assets
-        shell: bash
-        run: |
-          mkdir -p ./rustfs/static
-          if [[ "${{ matrix.platform }}" == "windows" ]]; then
-            curl.exe -L "https://dl.rustfs.com/artifacts/console/rustfs-console-latest.zip" -o console.zip --retry 3 --retry-delay 5 --max-time 300
-            if [[ $? -eq 0 ]]; then
-              unzip -o console.zip -d ./rustfs/static
-              rm console.zip
-            else
-              echo "Warning: Failed to download console assets, continuing without them"
-              echo "// Static assets not available" > ./rustfs/static/empty.txt
-            fi
-          else
-            chmod +w ./rustfs/static/LICENSE || true
-            curl -L "https://dl.rustfs.com/artifacts/console/rustfs-console-latest.zip" \
-              -o console.zip --retry 3 --retry-delay 5 --max-time 300
-            if [[ $? -eq 0 ]]; then
-              unzip -o console.zip -d ./rustfs/static
-              rm console.zip
-            else
-              echo "Warning: Failed to download console assets, continuing without them"
-              echo "// Static assets not available" > ./rustfs/static/empty.txt
-            fi
-          fi
-
-      - name: Build RustFS
-        shell: bash
-        run: |
-          # Force rebuild by touching build.rs
-          touch rustfs/build.rs
-
-          if [[ "${{ matrix.cross }}" == "true" ]]; then
-            if [[ "${{ matrix.platform }}" == "windows" ]]; then
-              # Use cross for Windows ARM64
-              cargo install cross --git https://github.com/cross-rs/cross
-              cross build --release --target ${{ matrix.target }} -p rustfs --bins
-            else
-              # Use zigbuild for other cross-compilation
-              cargo zigbuild --release --target ${{ matrix.target }} -p rustfs --bins
-            fi
-          else
-            cargo build --release --target ${{ matrix.target }} -p rustfs --bins
-          fi
-
-      - name: Create release package
-        id: package
-        shell: bash
-        run: |
-          BUILD_TYPE="${{ needs.build-check.outputs.build_type }}"
-          VERSION="${{ needs.build-check.outputs.version }}"
-          SHORT_SHA="${{ needs.build-check.outputs.short_sha }}"
-
-          # Extract platform and arch from target
-          TARGET="${{ matrix.target }}"
-          PLATFORM="${{ matrix.platform }}"
-          # Map target to architecture and variant
-          case "$TARGET" in
-            *x86_64*musl*)
-              ARCH="x86_64"
-              VARIANT="musl"
-              ;;
-            *x86_64*gnu*)
-              ARCH="x86_64"
-              VARIANT="gnu"
-              ;;
-            *x86_64*)
-              ARCH="x86_64"
-              VARIANT=""
-              ;;
-            *aarch64*musl*|*arm64*musl*)
-              ARCH="aarch64"
-              VARIANT="musl"
-              ;;
-            *aarch64*gnu*|*arm64*gnu*)
-              ARCH="aarch64"
-              VARIANT="gnu"
-              ;;
-            *aarch64*|*arm64*)
-              ARCH="aarch64"
-              VARIANT=""
-              ;;
-            *armv7*)
-              ARCH="armv7"
-              VARIANT=""
-              ;;
-            *)
-              ARCH="unknown"
-              VARIANT=""
-              ;;
-          esac
-
-          # Generate package name based on build type
-          if [[ -n "$VARIANT" ]]; then
-            ARCH_WITH_VARIANT="${ARCH}-${VARIANT}"
-          else
-            ARCH_WITH_VARIANT="${ARCH}"
-          fi
-
-          if [[ "$BUILD_TYPE" == "development" ]]; then
-            # Development build: rustfs-${platform}-${arch}-${variant}-dev-${short_sha}.zip
-            PACKAGE_NAME="rustfs-${PLATFORM}-${ARCH_WITH_VARIANT}-dev-${SHORT_SHA}"
-          else
-            # Release/Prerelease build: rustfs-${platform}-${arch}-${variant}-v${version}.zip
-            PACKAGE_NAME="rustfs-${PLATFORM}-${ARCH_WITH_VARIANT}-v${VERSION}"
-          fi
-
-          # Create zip packages for all platforms
-          # Ensure zip is available
-          if ! command -v zip &> /dev/null; then
-            if [[ "${{ matrix.os }}" == "ubuntu-latest" ]]; then
-              sudo apt-get update && sudo apt-get install -y zip
-            fi
-          fi
-
-          cd target/${{ matrix.target }}/release
-          # Determine the binary name based on platform
-          if [[ "${{ matrix.platform }}" == "windows" ]]; then
-            BINARY_NAME="rustfs.exe"
-          else
-            BINARY_NAME="rustfs"
-          fi
-
-          # Verify the binary exists before packaging
-          if [[ ! -f "$BINARY_NAME" ]]; then
-            echo "❌ Binary $BINARY_NAME not found in $(pwd)"
-            if [[ "${{ matrix.platform }}" == "windows" ]]; then
-              dir
-            else
-              ls -la
-            fi
-            exit 1
-          fi
-
-          # Universal packaging function
-          package_zip() {
-            local src=$1
-            local dst=$2
-            if [[ "${{ matrix.platform }}" == "windows" ]]; then
-              # Windows uses PowerShell Compress-Archive
-              powershell -Command "Compress-Archive -Path '$src' -DestinationPath '$dst' -Force"
-            elif command -v zip &> /dev/null; then
-              # Unix systems use zip command
-              zip "$dst" "$src"
-            else
-              echo "❌ No zip utility available"
-              exit 1
-            fi
-          }
-
-          # Create the zip package
-          echo "Start packaging: $BINARY_NAME -> ../../../${PACKAGE_NAME}.zip"
-          package_zip "$BINARY_NAME" "../../../${PACKAGE_NAME}.zip"
-
-          cd ../../..
-
-          # Verify the package was created
-          if [[ -f "${PACKAGE_NAME}.zip" ]]; then
-            echo "✅ Package created successfully: ${PACKAGE_NAME}.zip"
-            if [[ "${{ matrix.platform }}" == "windows" ]]; then
-              dir
-            else
-              ls -lh ${PACKAGE_NAME}.zip
-            fi
-          else
-            echo "❌ Failed to create package: ${PACKAGE_NAME}.zip"
-            exit 1
-          fi
-
-          # Create latest version files right after the main package
-          LATEST_FILES=""
-          if [[ "$BUILD_TYPE" == "release" ]] || [[ "$BUILD_TYPE" == "prerelease" ]]; then
-            # Create latest version filename
-            # Convert from rustfs-linux-x86_64-musl-v1.0.0 to rustfs-linux-x86_64-musl-latest
-            LATEST_FILE="${PACKAGE_NAME%-v*}-latest.zip"
-
-            echo "🔄 Creating latest version: ${PACKAGE_NAME}.zip -> $LATEST_FILE"
-            cp "${PACKAGE_NAME}.zip" "$LATEST_FILE"
-
-            if [[ -f "$LATEST_FILE" ]]; then
-              echo "✅ Latest version created: $LATEST_FILE"
-              LATEST_FILES="$LATEST_FILE"
-            fi
-          elif [[ "$BUILD_TYPE" == "development" ]]; then
-            # Development builds (only main branch triggers development builds)
-            # Create main-latest version filename
-            # Convert from rustfs-linux-x86_64-dev-abc123 to rustfs-linux-x86_64-main-latest
-            MAIN_LATEST_FILE="${PACKAGE_NAME%-dev-*}-main-latest.zip"
-
-            echo "🔄 Creating main-latest version: ${PACKAGE_NAME}.zip -> $MAIN_LATEST_FILE"
-            cp "${PACKAGE_NAME}.zip" "$MAIN_LATEST_FILE"
-
-            if [[ -f "$MAIN_LATEST_FILE" ]]; then
-              echo "✅ Main-latest version created: $MAIN_LATEST_FILE"
-              LATEST_FILES="$MAIN_LATEST_FILE"
-
-              # Also create a generic main-latest for Docker builds (Linux only)
-              if [[ "${{ matrix.platform }}" == "linux" ]]; then
-                DOCKER_MAIN_LATEST_FILE="rustfs-linux-${ARCH_WITH_VARIANT}-main-latest.zip"
-
-                echo "🔄 Creating Docker main-latest version: ${PACKAGE_NAME}.zip -> $DOCKER_MAIN_LATEST_FILE"
-                cp "${PACKAGE_NAME}.zip" "$DOCKER_MAIN_LATEST_FILE"
-
-                if [[ -f "$DOCKER_MAIN_LATEST_FILE" ]]; then
-                  echo "✅ Docker main-latest version created: $DOCKER_MAIN_LATEST_FILE"
-                  LATEST_FILES="$LATEST_FILES $DOCKER_MAIN_LATEST_FILE"
-                fi
-              fi
-            fi
-          fi
-
-          echo "package_name=${PACKAGE_NAME}" >> $GITHUB_OUTPUT
-          echo "package_file=${PACKAGE_NAME}.zip" >> $GITHUB_OUTPUT
-          echo "latest_files=${LATEST_FILES}" >> $GITHUB_OUTPUT
-          echo "build_type=${BUILD_TYPE}" >> $GITHUB_OUTPUT
-          echo "version=${VERSION}" >> $GITHUB_OUTPUT
-
-          echo "📦 Package created: ${PACKAGE_NAME}.zip"
-          if [[ -n "$LATEST_FILES" ]]; then
-            echo "📦 Latest files created: $LATEST_FILES"
-          fi
-          echo "🔧 Build type: ${BUILD_TYPE}"
-          echo "📊 Version: ${VERSION}"
-
-      - name: Upload to GitHub artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          name: ${{ steps.package.outputs.package_name }}
-          path: "rustfs-*.zip"
-          retention-days: ${{ startsWith(github.ref, 'refs/tags/') && 30 || 7 }}
-
-      - name: Upload to Aliyun OSS
-        if: env.OSS_ACCESS_KEY_ID != '' && (needs.build-check.outputs.build_type == 'release' || needs.build-check.outputs.build_type == 'prerelease' || needs.build-check.outputs.build_type == 'development')
-        env:
-          OSS_ACCESS_KEY_ID: ${{ secrets.ALICLOUDOSS_KEY_ID }}
-          OSS_ACCESS_KEY_SECRET: ${{ secrets.ALICLOUDOSS_KEY_SECRET }}
-          OSS_REGION: cn-beijing
-          OSS_ENDPOINT: https://oss-cn-beijing.aliyuncs.com
-        shell: bash
-        run: |
-          BUILD_TYPE="${{ needs.build-check.outputs.build_type }}"
-
-          # Install ossutil (platform-specific)
-          OSSUTIL_VERSION="2.1.1"
-          case "${{ matrix.platform }}" in
-            linux)
-              if [[ "$(uname -m)" == "arm64" ]]; then
-                ARCH="arm64"
-              else
-                ARCH="amd64"
-              fi
-              OSSUTIL_ZIP="ossutil-${OSSUTIL_VERSION}-linux-${ARCH}.zip"
-              OSSUTIL_DIR="ossutil-${OSSUTIL_VERSION}-linux-${ARCH}"
-
-              curl -o "$OSSUTIL_ZIP" "https://gosspublic.alicdn.com/ossutil/v2/${OSSUTIL_VERSION}/${OSSUTIL_ZIP}"
-              unzip "$OSSUTIL_ZIP"
-              mv "${OSSUTIL_DIR}/ossutil" /usr/local/bin/
-              rm -rf "$OSSUTIL_DIR" "$OSSUTIL_ZIP"
-              chmod +x /usr/local/bin/ossutil
-              OSSUTIL_BIN=ossutil
-              ;;
-            macos)
-              if [[ "$(uname -m)" == "arm64" ]]; then
-                ARCH="arm64"
-              else
-                ARCH="amd64"
-              fi
-              OSSUTIL_ZIP="ossutil-${OSSUTIL_VERSION}-mac-${ARCH}.zip"
-              OSSUTIL_DIR="ossutil-${OSSUTIL_VERSION}-mac-${ARCH}"
-
-              curl -o "$OSSUTIL_ZIP" "https://gosspublic.alicdn.com/ossutil/v2/${OSSUTIL_VERSION}/${OSSUTIL_ZIP}"
-              unzip "$OSSUTIL_ZIP"
-              mv "${OSSUTIL_DIR}/ossutil" /usr/local/bin/
-              rm -rf "$OSSUTIL_DIR" "$OSSUTIL_ZIP"
-              chmod +x /usr/local/bin/ossutil
-              OSSUTIL_BIN=ossutil
-              ;;
-            windows)
-              OSSUTIL_ZIP="ossutil-${OSSUTIL_VERSION}-windows-amd64.zip"
-              OSSUTIL_DIR="ossutil-${OSSUTIL_VERSION}-windows-amd64"
-
-              curl -o "$OSSUTIL_ZIP" "https://gosspublic.alicdn.com/ossutil/v2/${OSSUTIL_VERSION}/${OSSUTIL_ZIP}"
-              unzip "$OSSUTIL_ZIP"
-              mv "${OSSUTIL_DIR}/ossutil.exe" ./ossutil.exe
-              rm -rf "$OSSUTIL_DIR" "$OSSUTIL_ZIP"
-              OSSUTIL_BIN=./ossutil.exe
-              ;;
-          esac
-
-          # Determine upload path based on build type
-          if [[ "$BUILD_TYPE" == "development" ]]; then
-            OSS_PATH="oss://rustfs-artifacts/artifacts/rustfs/dev/"
-            echo "📤 Uploading development build to OSS dev directory"
-          else
-            OSS_PATH="oss://rustfs-artifacts/artifacts/rustfs/release/"
-            echo "📤 Uploading release build to OSS release directory"
-          fi
-
-          # Upload all rustfs zip files to OSS using glob pattern
-          echo "📤 Uploading all rustfs-*.zip files to $OSS_PATH..."
-          for zip_file in rustfs-*.zip; do
-            if [[ -f "$zip_file" ]]; then
-              echo "Uploading: $zip_file to $OSS_PATH..."
-              $OSSUTIL_BIN cp "$zip_file" "$OSS_PATH" --force
-              echo "✅ Uploaded: $zip_file"
-            fi
-          done
-
-          echo "✅ Upload completed successfully"
-
-  # Build summary
-  build-summary:
-    name: Build Summary
-    needs: [ build-check, build-rustfs ]
-    if: always() && needs.build-check.outputs.should_build == 'true'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Build completion summary
-        shell: bash
-        run: |
-          BUILD_TYPE="${{ needs.build-check.outputs.build_type }}"
-          VERSION="${{ needs.build-check.outputs.version }}"
-
-          echo "🎉 Build completed successfully!"
-          echo "📦 Build type: $BUILD_TYPE"
-          echo "🔢 Version: $VERSION"
-          echo ""
-
-          # Check build status
-          BUILD_STATUS="${{ needs.build-rustfs.result }}"
-
-          echo "📊 Build Results:"
-          echo "  📦 All platforms: $BUILD_STATUS"
-          echo ""
-
-          case "$BUILD_TYPE" in
-            "development")
-              echo "🛠️  Development build artifacts have been uploaded to OSS dev directory"
-              echo "⚠️  This is a development build - not suitable for production use"
-              ;;
-            "release")
-              echo "🚀 Release build artifacts have been uploaded to OSS release directory"
-              echo "✅ This build is ready for production use"
-              echo "🏷️  GitHub Release will be created in this workflow"
-              ;;
-            "prerelease")
-              echo "🧪 Prerelease build artifacts have been uploaded to OSS release directory"
-              echo "⚠️  This is a prerelease build - use with caution"
-              echo "🏷️  GitHub Release will be created in this workflow"
-              ;;
-          esac
-
-          echo ""
-          echo "🐳 Docker Images:"
-          if [[ "${{ github.event.inputs.build_docker }}" == "false" ]]; then
-            echo "⏭️  Docker image build was skipped (binary only build)"
-          elif [[ "$BUILD_STATUS" == "success" ]]; then
-            echo "🔄 Docker images will be built and pushed automatically via workflow_run event"
-          else
-            echo "❌ Docker image build will be skipped due to build failure"
-          fi
-
-  # Create GitHub Release (only for tag pushes)
-  create-release:
-    name: Create GitHub Release
-    needs: [ build-check, build-rustfs ]
-    if: startsWith(github.ref, 'refs/tags/') && needs.build-check.outputs.build_type != 'development'
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    outputs:
-      release_id: ${{ steps.create.outputs.release_id }}
-      release_url: ${{ steps.create.outputs.release_url }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-
-      - name: Create GitHub Release
-        id: create
-        env:
-          GH_TOKEN: ${{ github.token }}
-        shell: bash
-        run: |
-          TAG="${{ needs.build-check.outputs.version }}"
-          VERSION="${{ needs.build-check.outputs.version }}"
-          IS_PRERELEASE="${{ needs.build-check.outputs.is_prerelease }}"
-          BUILD_TYPE="${{ needs.build-check.outputs.build_type }}"
-
-          # Determine release type for title
-          if [[ "$BUILD_TYPE" == "prerelease" ]]; then
-            if [[ "$TAG" == *"alpha"* ]]; then
-              RELEASE_TYPE="alpha"
-            elif [[ "$TAG" == *"beta"* ]]; then
-              RELEASE_TYPE="beta"
-            elif [[ "$TAG" == *"rc"* ]]; then
-              RELEASE_TYPE="rc"
-            else
-              RELEASE_TYPE="prerelease"
-            fi
-          else
-            RELEASE_TYPE="release"
-          fi
-
-          # Check if release already exists
-          if gh release view "$TAG" >/dev/null 2>&1; then
-            echo "Release $TAG already exists"
-            RELEASE_ID=$(gh release view "$TAG" --json databaseId --jq '.databaseId')
-            RELEASE_URL=$(gh release view "$TAG" --json url --jq '.url')
-          else
-            # Get release notes from tag message
-            RELEASE_NOTES=$(git tag -l --format='%(contents)' "${TAG}")
-            if [[ -z "$RELEASE_NOTES" || "$RELEASE_NOTES" =~ ^[[:space:]]*$ ]]; then
-              if [[ "$IS_PRERELEASE" == "true" ]]; then
-                RELEASE_NOTES="Pre-release ${VERSION} (${RELEASE_TYPE})"
-              else
-                RELEASE_NOTES="Release ${VERSION}"
-              fi
-            fi
-
-            # Create release title
-            if [[ "$IS_PRERELEASE" == "true" ]]; then
-              TITLE="RustFS $VERSION (${RELEASE_TYPE})"
-            else
-              TITLE="RustFS $VERSION"
-            fi
-
-            # Create the release
-            PRERELEASE_FLAG=""
-            if [[ "$IS_PRERELEASE" == "true" ]]; then
-              PRERELEASE_FLAG="--prerelease"
-            fi
-
-            gh release create "$TAG" \
-              --title "$TITLE" \
-              --notes "$RELEASE_NOTES" \
-              $PRERELEASE_FLAG \
-              --draft
-
-            RELEASE_ID=$(gh release view "$TAG" --json databaseId --jq '.databaseId')
-            RELEASE_URL=$(gh release view "$TAG" --json url --jq '.url')
-          fi
-
-          echo "release_id=$RELEASE_ID" >> $GITHUB_OUTPUT
-          echo "release_url=$RELEASE_URL" >> $GITHUB_OUTPUT
-          echo "Created release: $RELEASE_URL"
-
-  # Prepare and upload release assets
-  upload-release-assets:
-    name: Upload Release Assets
-    needs: [ build-check, build-rustfs, create-release ]
-    if: startsWith(github.ref, 'refs/tags/') && needs.build-check.outputs.build_type != 'development'
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      actions: read
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-
-      - name: Download all build artifacts
-        uses: actions/download-artifact@v5
-        with:
-          path: ./artifacts
-          pattern: rustfs-*
-          merge-multiple: true
-
-      - name: Prepare release assets
-        id: prepare
-        shell: bash
-        run: |
-          VERSION="${{ needs.build-check.outputs.version }}"
-          TAG="${{ needs.build-check.outputs.version }}"
-
-          mkdir -p ./release-assets
-
-          # Copy and verify artifacts (including latest files created during build)
-          ASSETS_COUNT=0
-          for file in ./artifacts/*.zip; do
-            if [[ -f "$file" ]]; then
-              cp "$file" ./release-assets/
-              ASSETS_COUNT=$((ASSETS_COUNT + 1))
-            fi
-          done
-
-          if [[ $ASSETS_COUNT -eq 0 ]]; then
-            echo "❌ No artifacts found!"
-            exit 1
-          fi
-
-          cd ./release-assets
-
-          # Generate checksums for all files (including latest versions)
-          if ls *.zip >/dev/null 2>&1; then
-            sha256sum *.zip > SHA256SUMS
-            sha512sum *.zip > SHA512SUMS
-          fi
-
-          # Create signature placeholder files
-          for file in *.zip; do
-            echo "# Signature for $file" > "${file}.asc"
-            echo "# GPG signature will be added in future versions" >> "${file}.asc"
-          done
-
-          echo "📦 Prepared assets:"
-          ls -la
-
-          echo "🔢 Total asset count: $ASSETS_COUNT"
-
-      - name: Upload to GitHub Release
-        env:
-          GH_TOKEN: ${{ github.token }}
-        shell: bash
-        run: |
-          TAG="${{ needs.build-check.outputs.version }}"
-
-          cd ./release-assets
-
-          # Upload all files
-          for file in *; do
-            if [[ -f "$file" ]]; then
-              echo "📤 Uploading $file..."
-              gh release upload "$TAG" "$file" --clobber
-            fi
-          done
-
-          echo "✅ All assets uploaded successfully"
-
-  # Update latest.json for stable releases only
-  update-latest-version:
-    name: Update Latest Version
-    needs: [ build-check, upload-release-assets ]
-    if: startsWith(github.ref, 'refs/tags/')
-    runs-on: ubuntu-latest
-    steps:
-      - name: Update latest.json
-        env:
-          OSS_ACCESS_KEY_ID: ${{ secrets.ALICLOUDOSS_KEY_ID }}
-          OSS_ACCESS_KEY_SECRET: ${{ secrets.ALICLOUDOSS_KEY_SECRET }}
-          OSS_REGION: cn-beijing
-          OSS_ENDPOINT: https://oss-cn-beijing.aliyuncs.com
-        shell: bash
-        run: |
-          if [[ -z "$OSS_ACCESS_KEY_ID" ]]; then
-            echo "⚠️ OSS credentials not available, skipping latest.json update"
-            exit 0
-          fi
-
-          VERSION="${{ needs.build-check.outputs.version }}"
-          TAG="${{ needs.build-check.outputs.version }}"
-
-          # Install ossutil
-          OSSUTIL_VERSION="2.1.1"
-          OSSUTIL_ZIP="ossutil-${OSSUTIL_VERSION}-linux-amd64.zip"
-          OSSUTIL_DIR="ossutil-${OSSUTIL_VERSION}-linux-amd64"
-
-          curl -o "$OSSUTIL_ZIP" "https://gosspublic.alicdn.com/ossutil/v2/${OSSUTIL_VERSION}/${OSSUTIL_ZIP}"
-          unzip "$OSSUTIL_ZIP"
-          mv "${OSSUTIL_DIR}/ossutil" /usr/local/bin/
-          rm -rf "$OSSUTIL_DIR" "$OSSUTIL_ZIP"
-          chmod +x /usr/local/bin/ossutil
-
-          # Create latest.json
-          cat > latest.json << EOF
-          {
-            "version": "${VERSION}",
-            "tag": "${TAG}",
-            "release_date": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
-            "release_type": "stable",
-            "download_url": "https://github.com/${{ github.repository }}/releases/tag/${TAG}"
-          }
-          EOF
-
-          # Upload to OSS
-          ossutil cp latest.json oss://rustfs-version/latest.json --force
-
-          echo "✅ Updated latest.json for stable release $VERSION"
-
-  # Publish release (remove draft status)
-  publish-release:
-    name: Publish Release
-    needs: [ build-check, create-release, upload-release-assets ]
-    if: startsWith(github.ref, 'refs/tags/') && needs.build-check.outputs.build_type != 'development'
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-
-      - name: Update release notes and publish
-        env:
-          GH_TOKEN: ${{ github.token }}
-        shell: bash
-        run: |
-          TAG="${{ needs.build-check.outputs.version }}"
-          VERSION="${{ needs.build-check.outputs.version }}"
-          IS_PRERELEASE="${{ needs.build-check.outputs.is_prerelease }}"
-          BUILD_TYPE="${{ needs.build-check.outputs.build_type }}"
-
-          # Determine release type
-          if [[ "$BUILD_TYPE" == "prerelease" ]]; then
-            if [[ "$TAG" == *"alpha"* ]]; then
-              RELEASE_TYPE="alpha"
-            elif [[ "$TAG" == *"beta"* ]]; then
-              RELEASE_TYPE="beta"
-            elif [[ "$TAG" == *"rc"* ]]; then
-              RELEASE_TYPE="rc"
-            else
-              RELEASE_TYPE="prerelease"
-            fi
-          else
-            RELEASE_TYPE="release"
-          fi
-
-          # Get original release notes from tag
-          ORIGINAL_NOTES=$(git tag -l --format='%(contents)' "${TAG}")
-          if [[ -z "$ORIGINAL_NOTES" || "$ORIGINAL_NOTES" =~ ^[[:space:]]*$ ]]; then
-            if [[ "$IS_PRERELEASE" == "true" ]]; then
-              ORIGINAL_NOTES="Pre-release ${VERSION} (${RELEASE_TYPE})"
-            else
-              ORIGINAL_NOTES="Release ${VERSION}"
-            fi
-          fi
-
-          # Publish the release (remove draft status)
-          gh release edit "$TAG" --draft=false
-
-          echo "🎉 Released $TAG successfully!"
-          echo "📄 Release URL: ${{ needs.create-release.outputs.release_url }}"

.github/workflows/ci.yml

@@ -1,169 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-name: Continuous Integration
-
-on:
-  push:
-    branches: [ main ]
-    paths-ignore:
-      - "**.md"
-      - "**.txt"
-      - "docs/**"
-      - "deploy/**"
-      - "scripts/dev_*.sh"
-      - "scripts/probe.sh"
-      - "LICENSE*"
-      - ".gitignore"
-      - ".dockerignore"
-      - "README*"
-      - "**/*.png"
-      - "**/*.jpg"
-      - "**/*.svg"
-      - ".github/workflows/build.yml"
-      - ".github/workflows/docker.yml"
-      - ".github/workflows/audit.yml"
-      - ".github/workflows/performance.yml"
-  pull_request:
-    branches: [ main ]
-    paths-ignore:
-      - "**.md"
-      - "**.txt"
-      - "docs/**"
-      - "deploy/**"
-      - "scripts/dev_*.sh"
-      - "scripts/probe.sh"
-      - "LICENSE*"
-      - ".gitignore"
-      - ".dockerignore"
-      - "README*"
-      - "**/*.png"
-      - "**/*.jpg"
-      - "**/*.svg"
-      - ".github/workflows/build.yml"
-      - ".github/workflows/docker.yml"
-      - ".github/workflows/audit.yml"
-      - ".github/workflows/performance.yml"
-  schedule:
-    - cron: "0 0 * * 0" # Weekly on Sunday at midnight UTC
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-env:
-  CARGO_TERM_COLOR: always
-  RUST_BACKTRACE: 1
-
-jobs:
-  skip-check:
-    name: Skip Duplicate Actions
-    permissions:
-      actions: write
-      contents: read
-    runs-on: ubuntu-latest
-    outputs:
-      should_skip: ${{ steps.skip_check.outputs.should_skip }}
-    steps:
-      - name: Skip duplicate actions
-        id: skip_check
-        uses: fkirc/skip-duplicate-actions@v5
-        with:
-          concurrent_skipping: "same_content_newer"
-          cancel_others: true
-          paths_ignore: '["*.md", "docs/**", "deploy/**"]'
-          # Never skip release events and tag pushes
-          do_not_skip: '["workflow_dispatch", "schedule", "merge_group", "release", "push"]'
-
-
-  typos:
-    name: Typos
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v5
-      - uses: dtolnay/rust-toolchain@stable
-      - name: Typos check with custom config file
-        uses: crate-ci/typos@master
-
-  test-and-lint:
-    name: Test and Lint
-    needs: skip-check
-    if: needs.skip-check.outputs.should_skip != 'true'
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-
-      - name: Setup Rust environment
-        uses: ./.github/actions/setup
-        with:
-          rust-version: stable
-          cache-shared-key: ci-test-${{ hashFiles('**/Cargo.lock') }}
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          cache-save-if: ${{ github.ref == 'refs/heads/main' }}
-
-      - name: Run tests
-        run: |
-          cargo nextest run --all --exclude e2e_test
-          cargo test --all --doc
-
-      - name: Check code formatting
-        run: cargo fmt --all --check
-
-      - name: Run clippy lints
-        run: cargo clippy --all-targets --all-features -- -D warnings
-
-  e2e-tests:
-    name: End-to-End Tests
-    needs: skip-check
-    if: needs.skip-check.outputs.should_skip != 'true'
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-
-      - name: Setup Rust environment
-        uses: ./.github/actions/setup
-        with:
-          rust-version: stable
-          cache-shared-key: ci-e2e-${{ hashFiles('**/Cargo.lock') }}
-          cache-save-if: ${{ github.ref == 'refs/heads/main' }}
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Install s3s-e2e test tool
-        uses: taiki-e/cache-cargo-install-action@v2
-        with:
-          tool: s3s-e2e
-          git: https://github.com/Nugine/s3s.git
-          rev: b7714bfaa17ddfa9b23ea01774a1e7bbdbfc2ca3
-
-      - name: Build debug binary
-        run: |
-          touch rustfs/build.rs
-          cargo build -p rustfs --bins
-
-      - name: Run end-to-end tests
-        run: |
-          s3s-e2e --version
-          ./scripts/e2e-run.sh ./target/debug/rustfs /tmp/rustfs
-
-      - name: Upload test logs
-        if: failure()
-        uses: actions/upload-artifact@v4
-        with:
-          name: e2e-test-logs-${{ github.run_number }}
-          path: /tmp/rustfs.log
-          retention-days: 3

.github/workflows/docker.yml

@@ -1,421 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Docker Images Workflow
-#
-# This workflow builds Docker images using pre-built binaries from the build workflow.
-#
-# Trigger Types:
-# 1. workflow_run: Automatically triggered when "Build and Release" workflow completes
-# 2. workflow_dispatch: Manual trigger for standalone Docker builds
-#
-# Key Features:
-# - Only triggers when Linux builds (x86_64 + aarch64) are successful
-# - Independent of macOS/Windows build status
-# - Uses workflow_run event for precise control
-# - Only builds Docker images for releases and prereleases (development builds are skipped)
-
-name: Docker Images
-
-# Permissions needed for workflow_run event and Docker registry access
-permissions:
-  contents: read
-  packages: write
-
-on:
-  # Automatically triggered when build workflow completes
-  workflow_run:
-    workflows: [ "Build and Release" ]
-    types: [ completed ]
-  # Manual trigger with same parameters for consistency
-  workflow_dispatch:
-    inputs:
-      push_images:
-        description: "Push images to registries"
-        required: false
-        default: true
-        type: boolean
-      version:
-        description: "Version to build (latest for stable release, or specific version like v1.0.0, v1.0.0-alpha1)"
-        required: false
-        default: "latest"
-        type: string
-      force_rebuild:
-        description: "Force rebuild even if binary exists (useful for testing)"
-        required: false
-        default: false
-        type: boolean
-
-env:
-  CONCLUSION: ${{ github.event.workflow_run.conclusion }}
-  HEAD_BRANCH: ${{ github.event.workflow_run.head_branch }}
-  HEAD_SHA: ${{ github.event.workflow_run.head_sha }}
-  TRIGGERING_EVENT: ${{ github.event.workflow_run.event }}
-  DOCKERHUB_USERNAME: rustfs
-  CARGO_TERM_COLOR: always
-  REGISTRY_DOCKERHUB: rustfs/rustfs
-  REGISTRY_GHCR: ghcr.io/${{ github.repository }}
-  DOCKER_PLATFORMS: linux/amd64,linux/arm64
-
-jobs:
-  # Check if we should build Docker images
-  build-check:
-    name: Docker Build Check
-    runs-on: ubuntu-latest
-    outputs:
-      should_build: ${{ steps.check.outputs.should_build }}
-      should_push: ${{ steps.check.outputs.should_push }}
-      build_type: ${{ steps.check.outputs.build_type }}
-      version: ${{ steps.check.outputs.version }}
-      short_sha: ${{ steps.check.outputs.short_sha }}
-      is_prerelease: ${{ steps.check.outputs.is_prerelease }}
-      create_latest: ${{ steps.check.outputs.create_latest }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-          # For workflow_run events, checkout the specific commit that triggered the workflow
-          ref: ${{ github.event.workflow_run.head_sha || github.sha }}
-
-      - name: Check build conditions
-        id: check
-        run: |
-          should_build=false
-          should_push=false
-          build_type="none"
-          version=""
-          short_sha=""
-          is_prerelease=false
-          create_latest=false
-
-          if [[ "${{ github.event_name }}" == "workflow_run" ]]; then
-            # Triggered by build workflow completion
-            echo "🔗 Triggered by build workflow completion"
-
-            # Check if the triggering workflow was successful
-            # If the workflow succeeded, it means ALL builds (including Linux x86_64 and aarch64) succeeded
-            if [[ "$CONCLUSION" == "success" ]]; then
-              echo "✅ Build workflow succeeded, all builds including Linux are successful"
-              should_build=true
-              should_push=true
-            else
-              echo "❌ Build workflow failed (conclusion: $CONCLUSION), skipping Docker build"
-              should_build=false
-            fi
-
-            # Extract version info from commit message or use commit SHA
-            # Use Git to generate consistent short SHA (ensures uniqueness like build.yml)
-            short_sha=$(git rev-parse --short "$HEAD_SHA")
-
-            # Determine build type based on triggering workflow event and ref
-            triggering_event="$TRIGGERING_EVENT"
-            head_branch="$HEAD_BRANCH"
-
-            echo "🔍 Analyzing triggering workflow:"
-            echo "   📋 Event: $triggering_event"
-            echo "   🌿 Head branch: $head_branch"
-            echo "   📎 Head SHA: $HEAD_SHA"
-
-            # Check if this was triggered by a tag push
-            if [[ "$triggering_event" == "push" ]]; then
-              # For tag pushes, head_branch will be like "refs/tags/v1.0.0" or just "v1.0.0"
-              if [[ "$head_branch" == refs/tags/* ]]; then
-                # Extract tag name from refs/tags/TAG_NAME
-                tag_name="${head_branch#refs/tags/}"
-                version="$tag_name"
-              elif [[ "$head_branch" =~ ^v?[0-9]+\.[0-9]+\.[0-9]+ ]]; then
-                # Direct tag name like "v1.0.0" or "1.0.0-alpha.1"
-                version="$head_branch"
-              elif [[ "$head_branch" == "main" ]]; then
-                # Regular branch push to main
-                build_type="development"
-                version="dev-${short_sha}"
-                should_build=false
-                echo "⏭️  Skipping Docker build for development version (main branch push)"
-              else
-                # Other branch push
-                build_type="development"
-                version="dev-${short_sha}"
-                should_build=false
-                echo "⏭️  Skipping Docker build for development version (branch: $head_branch)"
-              fi
-
-              # If we extracted a version (tag), determine release type
-              if [[ -n "$version" ]] && [[ "$version" != "dev-${short_sha}" ]]; then
-                # Remove 'v' prefix if present for consistent version format
-                if [[ "$version" == v* ]]; then
-                  version="${version#v}"
-                fi
-
-                if [[ "$version" == *"alpha"* ]] || [[ "$version" == *"beta"* ]] || [[ "$version" == *"rc"* ]]; then
-                  build_type="prerelease"
-                  is_prerelease=true
-                  echo "🧪 Building Docker image for prerelease: $version"
-                else
-                  build_type="release"
-                  create_latest=true
-                  echo "🚀 Building Docker image for release: $version"
-                fi
-              fi
-            else
-              # Non-push events
-              build_type="development"
-              version="dev-${short_sha}"
-              should_build=false
-              echo "⏭️  Skipping Docker build for development version (event: $triggering_event)"
-            fi
-
-            echo "🔄 Build triggered by workflow_run:"
-            echo "   📋 Conclusion: $CONCLUSION"
-            echo "   🌿 Branch: $HEAD_BRANCH"
-            echo "   📎 SHA: $HEAD_SHA"
-            echo "   🎯 Event: $TRIGGERING_EVENT"
-
-          elif [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
-            # Manual trigger
-            input_version="${{ github.event.inputs.version }}"
-            version="${input_version}"
-            should_push="${{ github.event.inputs.push_images }}"
-            should_build=true
-
-            # Get short SHA
-            short_sha=$(git rev-parse --short HEAD)
-
-            echo "🎯 Manual Docker build triggered:"
-            echo "   📋 Requested version: $input_version"
-            echo "   🔧 Force rebuild: ${{ github.event.inputs.force_rebuild }}"
-            echo "   🚀 Push images: $should_push"
-
-            case "$input_version" in
-              "latest")
-                build_type="release"
-                create_latest=true
-                echo "🚀 Building with latest stable release version"
-                ;;
-              # Prerelease versions (must match first, more specific)
-              v*alpha*|v*beta*|v*rc*|*alpha*|*beta*|*rc*)
-                build_type="prerelease"
-                is_prerelease=true
-                echo "🧪 Building with prerelease version: $input_version"
-                ;;
-              # Release versions (match after prereleases, more general)
-              v[0-9]*|[0-9]*.*.*)
-                build_type="release"
-                create_latest=true
-                echo "📦 Building with specific release version: $input_version"
-                ;;
-              *)
-                # Invalid version for Docker build
-                should_build=false
-                echo "❌ Invalid version for Docker build: $input_version"
-                echo "⚠️  Only release versions (latest, v1.0.0, 1.0.0) and prereleases (v1.0.0-alpha1, 1.0.0-beta2) are supported"
-                ;;
-            esac
-          fi
-
-          echo "should_build=$should_build" >> $GITHUB_OUTPUT
-          echo "should_push=$should_push" >> $GITHUB_OUTPUT
-          echo "build_type=$build_type" >> $GITHUB_OUTPUT
-          echo "version=$version" >> $GITHUB_OUTPUT
-          echo "short_sha=$short_sha" >> $GITHUB_OUTPUT
-          echo "is_prerelease=$is_prerelease" >> $GITHUB_OUTPUT
-          echo "create_latest=$create_latest" >> $GITHUB_OUTPUT
-
-          echo "🐳 Docker Build Summary:"
-          echo "  - Should build: $should_build"
-          echo "  - Should push: $should_push"
-          echo "  - Build type: $build_type"
-          echo "  - Version: $version"
-          echo "  - Short SHA: $short_sha"
-          echo "  - Is prerelease: $is_prerelease"
-          echo "  - Create latest: $create_latest"
-
-  # Build multi-arch Docker images
-  # Strategy: Build images using pre-built binaries from dl.rustfs.com
-  # Supports both release and dev channel binaries based on build context
-  # Only runs when should_build is true (which includes workflow success check)
-  build-docker:
-    name: Build Docker Images
-    needs: build-check
-    if: needs.build-check.outputs.should_build == 'true'
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ env.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      # - name: Login to GitHub Container Registry
-      #   uses: docker/login-action@v3
-      #   with:
-      #     registry: ghcr.io
-      #     username: ${{ github.actor }}
-      #     password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Extract metadata and generate tags
-        id: meta
-        run: |
-          BUILD_TYPE="${{ needs.build-check.outputs.build_type }}"
-          VERSION="${{ needs.build-check.outputs.version }}"
-          SHORT_SHA="${{ needs.build-check.outputs.short_sha }}"
-          CREATE_LATEST="${{ needs.build-check.outputs.create_latest }}"
-
-          # Convert version format for Dockerfile compatibility
-          case "$VERSION" in
-            "latest")
-              # For stable latest, use RELEASE=latest + release CHANNEL
-              DOCKER_RELEASE="latest"
-              DOCKER_CHANNEL="release"
-              ;;
-            v*)
-              # For versioned releases (v1.0.0), remove 'v' prefix for Dockerfile
-              DOCKER_RELEASE="${VERSION#v}"
-              DOCKER_CHANNEL="release"
-              ;;
-            *)
-              # For other versions, pass as-is
-              DOCKER_RELEASE="${VERSION}"
-              DOCKER_CHANNEL="release"
-              ;;
-          esac
-
-          echo "docker_release=$DOCKER_RELEASE" >> $GITHUB_OUTPUT
-          echo "docker_channel=$DOCKER_CHANNEL" >> $GITHUB_OUTPUT
-
-          echo "🐳 Docker build parameters:"
-          echo "  - Original version: $VERSION"
-          echo "  - Docker RELEASE: $DOCKER_RELEASE"
-          echo "  - Docker CHANNEL: $DOCKER_CHANNEL"
-
-          # Generate tags based on build type
-          # Only support release and prerelease builds (no development builds)
-          TAGS="${{ env.REGISTRY_DOCKERHUB }}:${VERSION}"
-
-          # Add channel tags for prereleases and latest for stable
-          if [[ "$CREATE_LATEST" == "true" ]]; then
-            # Stable release
-            TAGS="$TAGS,${{ env.REGISTRY_DOCKERHUB }}:latest"
-          elif [[ "$BUILD_TYPE" == "prerelease" ]]; then
-            # Prerelease channel tags (alpha, beta, rc)
-            if [[ "$VERSION" == *"alpha"* ]]; then
-              CHANNEL="alpha"
-            elif [[ "$VERSION" == *"beta"* ]]; then
-              CHANNEL="beta"
-            elif [[ "$VERSION" == *"rc"* ]]; then
-              CHANNEL="rc"
-            fi
-
-            if [[ -n "$CHANNEL" ]]; then
-              TAGS="$TAGS,${{ env.REGISTRY_DOCKERHUB }}:${CHANNEL}"
-            fi
-          fi
-
-          # Output tags
-          echo "tags=$TAGS" >> $GITHUB_OUTPUT
-
-          # Generate labels
-          LABELS="org.opencontainers.image.title=RustFS"
-          LABELS="$LABELS,org.opencontainers.image.description=RustFS distributed object storage system"
-          LABELS="$LABELS,org.opencontainers.image.version=$VERSION"
-          LABELS="$LABELS,org.opencontainers.image.revision=${{ github.sha }}"
-          LABELS="$LABELS,org.opencontainers.image.source=${{ github.server_url }}/${{ github.repository }}"
-          LABELS="$LABELS,org.opencontainers.image.created=$(date -u +'%Y-%m-%dT%H:%M:%SZ')"
-          LABELS="$LABELS,org.opencontainers.image.build-type=$BUILD_TYPE"
-
-          echo "labels=$LABELS" >> $GITHUB_OUTPUT
-
-          echo "🐳 Generated Docker tags:"
-          echo "$TAGS" | tr ',' '\n' | sed 's/^/  - /'
-          echo "📋 Build type: $BUILD_TYPE"
-          echo "🔖 Version: $VERSION"
-
-      - name: Build and push Docker image
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: Dockerfile
-          platforms: ${{ env.DOCKER_PLATFORMS }}
-          push: ${{ needs.build-check.outputs.should_push == 'true' }}
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          cache-from: |
-            type=gha,scope=docker-binary
-          cache-to: |
-            type=gha,mode=max,scope=docker-binary
-          build-args: |
-            BUILDTIME=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
-            VERSION=${{ needs.build-check.outputs.version }}
-            BUILD_TYPE=${{ needs.build-check.outputs.build_type }}
-            REVISION=${{ github.sha }}
-            RELEASE=${{ steps.meta.outputs.docker_release }}
-            CHANNEL=${{ steps.meta.outputs.docker_channel }}
-            BUILDKIT_INLINE_CACHE=1
-          # Enable advanced BuildKit features for better performance
-          provenance: false
-          sbom: false
-          # Add retry mechanism by splitting the build process
-          no-cache: false
-          pull: true
-
-  # Note: Manifest creation is no longer needed as we only build one variant
-  # Multi-arch manifests are automatically created by docker/build-push-action
-
-  # Docker build summary
-  docker-summary:
-    name: Docker Build Summary
-    needs: [ build-check, build-docker ]
-    if: always() && needs.build-check.outputs.should_build == 'true'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Docker build completion summary
-        run: |
-          BUILD_TYPE="${{ needs.build-check.outputs.build_type }}"
-          VERSION="${{ needs.build-check.outputs.version }}"
-          CREATE_LATEST="${{ needs.build-check.outputs.create_latest }}"
-
-          echo "🐳 Docker build completed successfully!"
-          echo "📦 Build type: $BUILD_TYPE"
-          echo "🔢 Version: $VERSION"
-          echo "🚀 Strategy: Images using pre-built binaries (release channel only)"
-          echo ""
-
-          case "$BUILD_TYPE" in
-            "release")
-              echo "🚀 Release Docker image has been built with ${VERSION} tags"
-              echo "✅ This image is ready for production use"
-              if [[ "$CREATE_LATEST" == "true" ]]; then
-                echo "🏷️  Latest tag has been created for stable release"
-              fi
-              ;;
-            "prerelease")
-              echo "🧪 Prerelease Docker image has been built with ${VERSION} tags"
-              echo "⚠️  This is a prerelease image - use with caution"
-              echo "🚫 Latest tag NOT created for prerelease"
-              ;;
-            *)
-              echo "❌ Unexpected build type: $BUILD_TYPE"
-              ;;
-          esac

.github/workflows/issue-translator.yml

@@ -1,36 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-name: "issue-translator"
-on:
-  issue_comment:
-    types: [ created ]
-  issues:
-    types: [ opened ]
-
-permissions:
-  contents: read
-  issues: write
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: usthe/issues-translate-action@v2.7
-        with:
-          IS_MODIFY_TITLE: false
-          # not require, default false, . Decide whether to modify the issue title
-          # if true, the robot account @Issues-translate-bot must have modification permissions, invite @Issues-translate-bot to your project or use your custom bot.
-          CUSTOM_BOT_NOTE: Bot detected the issue body's language is not English, translate it automatically.
-          # not require. Customize the translation robot prefix message.

.github/workflows/performance.yml

@@ -1,142 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-name: Performance Testing
-
-on:
-  push:
-    branches: [ main ]
-    paths:
-      - "**/*.rs"
-      - "**/Cargo.toml"
-      - "**/Cargo.lock"
-      - ".github/workflows/performance.yml"
-  workflow_dispatch:
-    inputs:
-      profile_duration:
-        description: "Profiling duration in seconds"
-        required: false
-        default: "120"
-        type: string
-
-permissions:
-  contents: read
-
-env:
-  CARGO_TERM_COLOR: always
-  RUST_BACKTRACE: 1
-
-jobs:
-  performance-profile:
-    name: Performance Profiling
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-
-      - name: Setup Rust environment
-        uses: ./.github/actions/setup
-        with:
-          rust-version: nightly
-          cache-shared-key: perf-${{ hashFiles('**/Cargo.lock') }}
-          cache-save-if: ${{ github.ref == 'refs/heads/main' }}
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Install additional nightly components
-        run: rustup component add llvm-tools-preview
-
-      - name: Install samply profiler
-        uses: taiki-e/cache-cargo-install-action@v2
-        with:
-          tool: samply
-
-      - name: Configure kernel for profiling
-        run: echo '1' | sudo tee /proc/sys/kernel/perf_event_paranoid
-
-      - name: Prepare test environment
-        run: |
-          # Create test volumes
-          for i in {0..4}; do
-            mkdir -p ./target/volume/test$i
-          done
-
-          # Set environment variables
-          echo "RUSTFS_VOLUMES=./target/volume/test{0...4}" >> $GITHUB_ENV
-          echo "RUST_LOG=rustfs=info,ecstore=info,s3s=info,iam=info,rustfs-obs=info" >> $GITHUB_ENV
-
-      - name: Verify console static assets
-        run: |
-          # Console static assets are already embedded in the repository
-          echo "Console static assets size: $(du -sh rustfs/static/)"
-          echo "Console static assets are embedded via rust-embed, no external download needed"
-
-      - name: Build with profiling optimizations
-        run: |
-          RUSTFLAGS="-C force-frame-pointers=yes -C debug-assertions=off" \
-          cargo +nightly build --profile profiling -p rustfs --bins
-
-      - name: Run performance profiling
-        id: profiling
-        run: |
-          DURATION="${{ github.event.inputs.profile_duration || '120' }}"
-          echo "Running profiling for ${DURATION} seconds..."
-
-          timeout "${DURATION}s" samply record \
-            --output samply-profile.json \
-            ./target/profiling/rustfs ${RUSTFS_VOLUMES} || true
-
-          if [ -f "samply-profile.json" ]; then
-            echo "profile_generated=true" >> $GITHUB_OUTPUT
-            echo "Profile generated successfully"
-          else
-            echo "profile_generated=false" >> $GITHUB_OUTPUT
-            echo "::warning::Profile data not generated"
-          fi
-
-      - name: Upload profile data
-        if: steps.profiling.outputs.profile_generated == 'true'
-        uses: actions/upload-artifact@v4
-        with:
-          name: performance-profile-${{ github.run_number }}
-          path: samply-profile.json
-          retention-days: 30
-
-  benchmark:
-    name: Benchmark Tests
-    runs-on: ubuntu-latest
-    timeout-minutes: 45
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-
-      - name: Setup Rust environment
-        uses: ./.github/actions/setup
-        with:
-          rust-version: stable
-          cache-shared-key: bench-${{ hashFiles('**/Cargo.lock') }}
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          cache-save-if: ${{ github.ref == 'refs/heads/main' }}
-
-      - name: Run benchmarks
-        run: |
-          cargo bench --package ecstore --bench comparison_benchmark -- --output-format json | \
-          tee benchmark-results.json
-
-      - name: Upload benchmark results
-        uses: actions/upload-artifact@v4
-        with:
-          name: benchmark-results-${{ github.run_number }}
-          path: benchmark-results.json
-          retention-days: 7

.gitignore

@@ -1,23 +0,0 @@
-/target
-.DS_Store
-.idea
-.vscode
-/test
-/logs
-/data
-.devcontainer
-rustfs/static/*
-!rustfs/static/.gitkeep
-vendor
-cli/rustfs-gui/embedded-rustfs/rustfs
-*.log
-deploy/certs/*
-*jsonl
-.env
-.rustfs.sys
-.cargo
-profile.json
-.docker/openobserve-otel/data
-*.zst
-.secrets
-*.go

.rules.md

@@ -1,702 +0,0 @@
-# RustFS Project AI Coding Rules
-
-## 🚨🚨🚨 CRITICAL DEVELOPMENT RULES - ZERO TOLERANCE 🚨🚨🚨
-
-### ⛔️ ABSOLUTE PROHIBITION: NEVER COMMIT DIRECTLY TO MASTER/MAIN BRANCH ⛔️
-
-**🔥 THIS IS THE MOST CRITICAL RULE - VIOLATION WILL RESULT IN IMMEDIATE REVERSAL 🔥**
-
-- **🚫 ZERO DIRECT COMMITS TO MAIN/MASTER BRANCH - ABSOLUTELY FORBIDDEN**
-- **🚫 ANY DIRECT COMMIT TO MAIN BRANCH MUST BE IMMEDIATELY REVERTED**
-- **🚫 NO EXCEPTIONS FOR HOTFIXES, EMERGENCIES, OR URGENT CHANGES**
-- **🚫 NO EXCEPTIONS FOR SMALL CHANGES, TYPOS, OR DOCUMENTATION UPDATES**
-- **🚫 NO EXCEPTIONS FOR ANYONE - MAINTAINERS, CONTRIBUTORS, OR ADMINS**
-
-### 📋 MANDATORY WORKFLOW - STRICTLY ENFORCED
-
-**EVERY SINGLE CHANGE MUST FOLLOW THIS WORKFLOW:**
-
-1. **Check current branch**: `git branch` (MUST NOT be on main/master)
-2. **Switch to main**: `git checkout main`
-3. **Pull latest**: `git pull origin main`
-4. **Create feature branch**: `git checkout -b feat/your-feature-name`
-5. **Make changes ONLY on feature branch**
-6. **Test thoroughly before committing**
-7. **Commit and push to feature branch**: `git push origin feat/your-feature-name`
-8. **Create Pull Request**: Use `gh pr create` (MANDATORY)
-9. **Wait for PR approval**: NO self-merging allowed
-10. **Merge through GitHub interface**: ONLY after approval
-
-### 🔒 ENFORCEMENT MECHANISMS
-
-- **Branch protection rules**: Main branch is protected
-- **Pre-commit hooks**: Will block direct commits to main
-- **CI/CD checks**: All PRs must pass before merging
-- **Code review requirement**: At least one approval needed
-- **Automated reversal**: Direct commits to main will be automatically reverted
-
-## 🎯 Core AI Development Principles
-
-### Five Execution Steps
-
-#### 1. Task Analysis and Planning
-- **Clear Objectives**: Deeply understand task requirements and expected results before starting coding
-- **Plan Development**: List specific files, components, and functions that need modification, explaining the reasons for changes
-- **Risk Assessment**: Evaluate the impact of changes on existing functionality, develop rollback plans
-
-#### 2. Precise Code Location
-- **File Identification**: Determine specific files and line numbers that need modification
-- **Impact Analysis**: Avoid modifying irrelevant files, clearly state the reason for each file modification
-- **Minimization Principle**: Unless explicitly required by the task, do not create new abstraction layers or refactor existing code
-
-#### 3. Minimal Code Changes
-- **Focus on Core**: Only write code directly required by the task
-- **Avoid Redundancy**: Do not add unnecessary logs, comments, tests, or error handling
-- **Isolation**: Ensure new code does not interfere with existing functionality, maintain code independence
-
-#### 4. Strict Code Review
-- **Correctness Check**: Verify the correctness and completeness of code logic
-- **Style Consistency**: Ensure code conforms to established project coding style
-- **Side Effect Assessment**: Evaluate the impact of changes on downstream systems
-
-#### 5. Clear Delivery Documentation
-- **Change Summary**: Detailed explanation of all modifications and reasons
-- **File List**: List all modified files and their specific changes
-- **Risk Statement**: Mark any assumptions or potential risk points
-
-### Core Principles
-- **🎯 Precise Execution**: Strictly follow task requirements, no arbitrary innovation
-- **⚡ Efficient Development**: Avoid over-design, only do necessary work
-- **🛡️ Safe and Reliable**: Always follow development processes, ensure code quality and system stability
-- **🔒 Cautious Modification**: Only modify when clearly knowing what needs to be changed and having confidence
-
-### Additional AI Behavior Rules
-
-1. **Use English for all code comments and documentation** - All comments, variable names, function names, documentation, and user-facing text in code should be in English
-2. **Clean up temporary scripts after use** - Any temporary scripts, test files, or helper files created during AI work should be removed after task completion
-3. **Only make confident modifications** - Do not make speculative changes or "convenient" modifications outside the task scope. If uncertain about a change, ask for clarification rather than guessing
-
-## 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
-- Use `Result<T>` type aliases for consistency within each module
-- Error conversion between modules should use explicit `From` implementations
-- Follow the pattern: `pub type Result<T> = core::result::Result<T, Error>`
-- Use `#[error("description")]` attributes for clear error messages
-- Support error downcasting when needed through `other()` helper methods
-- Implement `Clone` for errors when required by the domain logic
-
-## Code Style Guidelines
-
-### 1. Formatting Configuration
-
-```toml
-max_width = 130
-fn_call_width = 90
-single_line_let_else_max_width = 100
-```
-
-### 2. **🔧 MANDATORY Code Formatting Rules**
-
-**CRITICAL**: All code must be properly formatted before committing. This project enforces strict formatting standards to maintain code consistency and readability.
-
-#### Pre-commit Requirements (MANDATORY)
-
-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
-   ```
-
-#### Quick Commands
-
-Use these convenient Makefile targets for common tasks:
-
-```bash
-# Format all code
-make fmt
-
-# Check if code is properly formatted
-make fmt-check
-
-# Run clippy checks
-make clippy
-
-# Run compilation check
-make check
-
-# Run tests
-make test
-
-# Run all pre-commit checks (format + clippy + check + test)
-make pre-commit
-
-# Setup git hooks (one-time setup)
-make setup-hooks
-```
-
-### 3. Naming Conventions
-
-- Use `snake_case` for functions, variables, modules
-- Use `PascalCase` for types, traits, enums
-- Constants use `SCREAMING_SNAKE_CASE`
-- Global variables prefix `GLOBAL_`, e.g., `GLOBAL_Endpoints`
-- Use meaningful and descriptive names for variables, functions, and methods
-- Avoid meaningless names like `temp`, `data`, `foo`, `bar`, `test123`
-- 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:
-  - The type cannot be inferred by the compiler
-  - Explicit typing improves code clarity and readability
-  - Required for API boundaries (function signatures, public struct fields)
-  - Needed to resolve ambiguity between multiple possible types
-
-### 5. Documentation Comments
-
-- Public APIs must have documentation comments
-- Use `///` for documentation comments
-- Complex functions add `# Examples` and `# Parameters` descriptions
-- Error cases use `# Errors` descriptions
-- Always use English for all comments and documentation
-- 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
-- Group `use` statements with blank lines between groups
-
-## Asynchronous Programming Guidelines
-
-### 1. Trait Definition
-
-```rust
-#[async_trait::async_trait]
-pub trait StorageAPI: Send + Sync {
-    async fn get_object(&self, bucket: &str, object: &str) -> Result<ObjectInfo>;
-}
-```
-
-### 2. Error Handling
-
-```rust
-// Use ? operator to propagate errors
-async fn example_function() -> Result<()> {
-    let data = read_file("path").await?;
-    process_data(data).await?;
-    Ok(())
-}
-```
-
-### 3. Concurrency Control
-
-- Use `Arc` and `Mutex`/`RwLock` for shared state management
-- Prioritize async locks from `tokio::sync`
-- Avoid holding locks for long periods
-
-## Logging and Tracing Guidelines
-
-### 1. Tracing Usage
-
-```rust
-#[tracing::instrument(skip(self, data))]
-async fn process_data(&self, data: &[u8]) -> Result<()> {
-    info!("Processing {} bytes", data.len());
-    // Implementation logic
-}
-```
-
-### 2. Log Levels
-
-- `error!`: System errors requiring immediate attention
-- `warn!`: Warning information that may affect functionality
-- `info!`: Important business information
-- `debug!`: Debug information for development use
-- `trace!`: Detailed execution paths
-
-### 3. Structured Logging
-
-```rust
-info!(
-    counter.rustfs_api_requests_total = 1_u64,
-    key_request_method = %request.method(),
-    key_request_uri_path = %request.uri().path(),
-    "API request processed"
-);
-```
-
-## 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),
-}
-
-// Provide Result type alias for the module
-pub type Result<T> = core::result::Result<T, MyError>;
-```
-
-### 2. Error Helper Methods
-
-```rust
-impl MyError {
-    /// Create error from any compatible error type
-    pub fn other<E>(error: E) -> Self
-    where
-        E: Into<Box<dyn std::error::Error + Send + Sync>>,
-    {
-        MyError::Io(std::io::Error::other(error))
-    }
-}
-```
-
-### 3. Error Context and Propagation
-
-```rust
-// Use ? operator for clean error propagation
-async fn example_function() -> Result<()> {
-    let data = read_file("path").await?;
-    process_data(data).await?;
-    Ok(())
-}
-
-// 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)
-        })?;
-    Ok(())
-}
-```
-
-## 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());
-let results = join_all(futures).await;
-```
-
-### 3. Caching Strategy
-
-- Use `LazyLock` for global caching
-- Implement LRU cache to avoid memory leaks
-
-## Testing Guidelines
-
-### 1. Unit Tests
-
-```rust
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use test_case::test_case;
-
-    #[tokio::test]
-    async fn test_async_function() {
-        let result = async_function().await;
-        assert!(result.is_ok());
-    }
-
-    #[test_case("input1", "expected1")]
-    #[test_case("input2", "expected2")]
-    fn test_with_cases(input: &str, expected: &str) {
-        assert_eq!(function(input), expected);
-    }
-}
-```
-
-### 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
-- Each test should have a clear purpose and verify specific behavior
-- Test data should be realistic and representative of actual use cases
-
-## 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 */ }
-
-#[cfg(target_arch = "aarch64")]
-fn optimized_aarch64_function() { /* ARM64 specific implementation */ }
-
-#[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
-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
-
-## 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?;
-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 {
-    pub address: String,
-    pub volumes: String,
-    #[serde(default)]
-    pub console_enable: bool,
-}
-```
-
-## 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"]
-gpu = ["dep:nvml-wrapper"]
-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> {
-    // Check component status
-}
-```
-
-## 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)
-- [ ] **Pre-commit hooks are working** and all checks pass
-- [ ] **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
-- [ ] Is PR description provided in copyable markdown format for easy copying?
-
-## Common Patterns and Best Practices
-
-### 1. Resource Management
-
-```rust
-// Use RAII pattern for resource management
-pub struct ResourceGuard {
-    resource: Resource,
-}
-
-impl Drop for ResourceGuard {
-    fn drop(&mut self) {
-        // Clean up resources
-    }
-}
-```
-
-### 2. Dependency Injection
-
-```rust
-// Use dependency injection pattern
-pub struct Service {
-    config: Arc<Config>,
-    storage: Arc<dyn StorageAPI>,
-}
-```
-
-### 3. Graceful Shutdown
-
-```rust
-// Implement graceful shutdown
-async fn shutdown_gracefully(shutdown_rx: &mut Receiver<()>) {
-    tokio::select! {
-        _ = shutdown_rx.recv() => {
-            info!("Received shutdown signal");
-            // Perform cleanup operations
-        }
-        _ = tokio::time::sleep(SHUTDOWN_TIMEOUT) => {
-            warn!("Shutdown timeout reached");
-        }
-    }
-}
-```
-
-## 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
-
-## Branch Management and Development Workflow
-
-### 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 ⚠️**
-- **🔒 ALL CHANGES MUST GO THROUGH PULL REQUESTS - NO DIRECT COMMITS TO MAIN UNDER ANY CIRCUMSTANCES 🔒**
-- **Always work on feature branches - NO EXCEPTIONS**
-- Always check the .rules.md 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)
-   4. Make your changes ONLY on the feature branch
-   5. Test thoroughly before committing
-   6. Commit and push to the feature branch
-   7. **Create a pull request for code review - THIS IS THE ONLY WAY TO MERGE TO MAIN**
-   8. **Wait for PR approval before merging - NEVER merge your own PRs without 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**
-- **Pull Request Requirements:**
-  - All changes must be submitted via PR regardless of size or urgency
-  - PRs must include comprehensive description and testing information
-  - PRs must pass all CI/CD checks before merging
-  - PRs require at least one approval from code reviewers
-  - Even hotfixes and emergency changes must go through PR process
-- **Enforcement:**
-  - Main branch should be protected with branch protection rules
-  - Direct pushes to main should be blocked by repository settings
-  - Any accidental direct commits to main must be immediately reverted via PR
-
-### Development Workflow
-
-## 🎯 **Core Development Principles**
-
-- **🔴 Every change must be precise - don't modify unless you're confident**
-  - Carefully analyze code logic and ensure complete understanding before making changes
-  - When uncertain, prefer asking users or consulting documentation over blind modifications
-  - Use small iterative steps, modify only necessary parts at a time
-  - Evaluate impact scope before changes to ensure no new issues are introduced
-
-- **🚀 GitHub PR creation prioritizes gh command usage**
-  - Prefer using `gh pr create` command to create Pull Requests
-  - Avoid having users manually create PRs through web interface
-  - Provide clear and professional PR titles and descriptions
-  - Using `gh` commands ensures better integration and automation
-
-## 📝 **Code Quality Requirements**
-
-- 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 Documentation Generation Restrictions
-
-### Forbidden Summary Documents
-
-- **Strictly forbidden to create any form of AI-generated summary documents**
-- **Do not create documents containing large amounts of emoji, detailed formatting tables and typical AI style**
-- **Do not generate the following types of documents in the project:**
-  - Benchmark summary documents (BENCHMARK*.md)
-  - Implementation comparison analysis documents (IMPLEMENTATION_COMPARISON*.md)
-  - Performance analysis report documents
-  - Architecture summary documents
-  - Feature comparison documents
-  - Any documents with large amounts of emoji and formatted content
-- **If documentation is needed, only create when explicitly requested by the user, and maintain a concise and practical style**
-- **Documentation should focus on actually needed information, avoiding excessive formatting and decorative content**
-- **Any discovered AI-generated summary documents should be immediately deleted**
-
-### Allowed Documentation Types
-
-- README.md (project introduction, keep concise)
-- Technical documentation (only create when explicitly needed)
-- User manual (only create when explicitly needed)
-- API documentation (generated from code)
-- Changelog (CHANGELOG.md)
-
-These rules should serve as guiding principles when developing the RustFS project, ensuring code quality, performance, and maintainability.

.vscode/launch.json

@@ -1,103 +0,0 @@
-{
-    // 使用 IntelliSense 了解相关属性。 
-    // 悬停以查看现有属性的描述。
-    // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug executable 'rustfs'",
-            "cargo": {
-                "args": [
-                    "build",
-                    "--bin=rustfs",
-                    "--package=rustfs"
-                ],
-                "filter": {
-                    "name": "rustfs",
-                    "kind": "bin"
-                }
-            },
-            "env": {
-                "RUST_LOG": "rustfs=debug,ecstore=info,s3s=debug"
-            },
-            "args": [
-                "--access-key",
-                "AKEXAMPLERUSTFS",
-                "--secret-key",
-                "SKEXAMPLERUSTFS",
-                "--address",
-                "0.0.0.0:9010",
-                "--domain-name",
-                "127.0.0.1:9010",
-                "./target/volume/test{0...4}"
-            ],
-            "cwd": "${workspaceFolder}"
-        },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug unit tests in executable 'rustfs'",
-            "cargo": {
-                "args": [
-                    "test",
-                    "--no-run",
-                    "--bin=rustfs",
-                    "--package=rustfs"
-                ],
-                "filter": {
-                    "name": "rustfs",
-                    "kind": "bin"
-                }
-            },
-            "args": [],
-            "cwd": "${workspaceFolder}"
-        },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug unit tests in library 'ecstore'",
-            "cargo": {
-                "args": [
-                    "test",
-                    "--no-run",
-                    "--lib",
-                    "--package=ecstore"
-                ],
-                "filter": {
-                    "name": "ecstore",
-                    "kind": "lib"
-                }
-            },
-            "args": [],
-            "cwd": "${workspaceFolder}"
-        },
-        {
-            "name": "Debug executable target/debug/rustfs",
-            "type":  "lldb",
-            "request": "launch",
-            "program": "${workspaceFolder}/target/debug/rustfs",
-            "args": [],
-            "cwd": "${workspaceFolder}",
-            //"stopAtEntry": false,
-            //"preLaunchTask": "cargo build",
-            "sourceLanguages": [
-                "rust"
-            ],
-        },
-        {
-            "name": "Debug executable target/debug/test",
-            "type":  "lldb",
-            "request": "launch",
-            "program": "${workspaceFolder}/target/debug/deps/lifecycle_integration_test-5eb7590b8f3bea55",
-            "args": [],
-            "cwd": "${workspaceFolder}",
-            //"stopAtEntry": false,
-            //"preLaunchTask": "cargo build",
-            "sourceLanguages": [
-                "rust"
-            ],
-        }
-    ]
-}

CLA.md

@@ -1,39 +0,0 @@
-RustFS Individual Contributor License Agreement
-
-Thank you for your interest in contributing documentation and related software code to a project hosted or managed by RustFS. In order to clarify the intellectual property license granted with Contributions from any person or entity, RustFS must have a Contributor License Agreement (“CLA”) on file that has been signed by each Contributor, indicating agreement to the license terms below. This version of the Contributor License Agreement allows an individual to submit Contributions to the applicable project. If you are making a submission on behalf of a legal entity, then you should sign the separate Corporate Contributor License Agreement.
-
-You accept and agree to the following terms and conditions for Your present and future Contributions submitted to RustFS. You hereby irrevocably assign and transfer to RustFS all right, title, and interest in and to Your Contributions, including all copyrights and other intellectual property rights therein.
-
-Definitions
-
-“You” (or “Your”) shall mean the copyright owner or legal entity authorized by the copyright owner that is making this Agreement with RustFS. For legal entities, the entity making a Contribution and all other entities that control, are controlled by, or are under common control with that entity are considered to be a single Contributor. For the purposes of this definition, “control” means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
-
-“Contribution” shall mean any original work of authorship, including any modifications or additions to an existing work, that is intentionally submitted by You to RustFS for inclusion in, or documentation of, any of the products or projects owned or managed by RustFS (the “Work”), including without limitation any Work described in Schedule A. For the purposes of this definition, “submitted” means any form of electronic or written communication sent to RustFS or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, RustFS for the purpose of discussing and improving the Work.
-
-Assignment of Copyright
-
-Subject to the terms and conditions of this Agreement, You hereby irrevocably assign and transfer to RustFS all right, title, and interest in and to Your Contributions, including all copyrights and other intellectual property rights therein, for the entire term of such rights, including all renewals and extensions. You agree to execute all documents and take all actions as may be reasonably necessary to vest in RustFS the ownership of Your Contributions and to assist RustFS in perfecting, maintaining, and enforcing its rights in Your Contributions.
-
-Grant of Patent License
-
-Subject to the terms and conditions of this Agreement, You hereby grant to RustFS and to recipients of documentation and software distributed by RustFS a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by You that are necessarily infringed by Your Contribution(s) alone or by combination of Your Contribution(s) with the Work to which such Contribution(s) was submitted. If any entity institutes patent litigation against You or any other entity (including a cross-claim or counterclaim in a lawsuit) alleging that your Contribution, or the Work to which you have contributed, constitutes direct or contributory patent infringement, then any patent licenses granted to that entity under this Agreement for that Contribution or Work shall terminate as of the date such litigation is filed.
-
-You represent that you are legally entitled to grant the above assignment and license.
-
-You represent that each of Your Contributions is Your original creation (see section 7 for submissions on behalf of others). You represent that Your Contribution submissions include complete details of any third-party license or other restriction (including, but not limited to, related patents and trademarks) of which you are personally aware and which are associated with any part of Your Contributions.
-
-You are not expected to provide support for Your Contributions, except to the extent You desire to provide support. You may provide support for free, for a fee, or not at all. Unless required by applicable law or agreed to in writing, You provide Your Contributions on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON- INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE.
-
-Should You wish to submit work that is not Your original creation, You may submit it to RustFS separately from any Contribution, identifying the complete details of its source and of any license or other restriction (including, but not limited to, related patents, trademarks, and license agreements) of which you are personally aware, and conspicuously marking the work as “Submitted on behalf of a third-party: [named here]”.
-
-You agree to notify RustFS of any facts or circumstances of which you become aware that would make these representations inaccurate in any respect.
-
-Modification of CLA
-
-RustFS reserves the right to update or modify this CLA in the future. Any updates or modifications to this CLA shall apply only to Contributions made after the effective date of the revised CLA. Contributions made prior to the update shall remain governed by the version of the CLA that was in effect at the time of submission. It is not necessary for all Contributors to re-sign the CLA when the CLA is updated or modified.
-
-Governing Law and Dispute Resolution
-
-This Agreement will be governed by and construed in accordance with the laws of the People’s Republic of China excluding that body of laws known as conflict of laws. The parties expressly agree that the United Nations Convention on Contracts for the International Sale of Goods will not apply. Any legal action or proceeding arising under this Agreement will be brought exclusively in the courts located in Beijing, China, and the parties hereby irrevocably consent to the personal jurisdiction and venue therein.
-
-For your reading convenience, this Agreement is written in parallel English and Chinese sections. To the extent there is a conflict between the English and Chinese sections, the English sections shall govern.

CLAUDE.md

@@ -1,68 +0,0 @@
-# Claude AI Rules for RustFS Project
-
-## Core Rules Reference
-
-This project follows the comprehensive AI coding rules defined in `.rules.md`. Please refer to that file for the complete set of development guidelines, coding standards, and best practices.
-
-## Claude-Specific Configuration
-
-When using Claude for this project, ensure you:
-
-1. **Review the unified rules**: Always check `.rules.md` for the latest project guidelines
-2. **Follow branch protection**: Never attempt to commit directly to main/master branch
-3. **Use English**: All code comments, documentation, and variable names must be in English
-4. **Clean code practices**: Only make modifications you're confident about
-5. **Test thoroughly**: Ensure all changes pass formatting, linting, and testing requirements
-6. **Clean up after yourself**: Remove any temporary scripts or test files created during the session
-
-## Quick Reference
-
-### Critical Rules
-- 🚫 **NEVER commit directly to main/master branch**
-- ✅ **ALWAYS work on feature branches**
-- 📝 **ALWAYS use English for code and documentation**
-- 🧹 **ALWAYS clean up temporary files after use**
-- 🎯 **ONLY make confident, necessary modifications**
-
-### Pre-commit Checklist
-```bash
-# Before committing, always run:
-cargo fmt --all
-cargo clippy --all-targets --all-features -- -D warnings
-cargo check --all-targets
-cargo test
-```
-
-### Branch Workflow
-```bash
-git checkout main
-git pull origin main
-git checkout -b feat/your-feature-name
-# Make your changes
-git add .
-git commit -m "feat: your feature description"
-git push origin feat/your-feature-name
-gh pr create
-```
-
-## Claude-Specific Best Practices
-
-1. **Task Analysis**: Always thoroughly analyze the task before starting implementation
-2. **Minimal Changes**: Make only the necessary changes to accomplish the task
-3. **Clear Communication**: Provide clear explanations of changes and their rationale
-4. **Error Prevention**: Verify code correctness before suggesting changes
-5. **Documentation**: Ensure all code changes are properly documented in English
-
-## Important Notes
-
-- This file serves as an entry point for Claude AI
-- All detailed rules and guidelines are maintained in `.rules.md`
-- Updates to coding standards should be made in `.rules.md` to ensure consistency across all AI tools
-- When in doubt, always refer to `.rules.md` for authoritative guidance
-- Claude should prioritize code quality, safety, and maintainability over speed
-
-## See Also
-
-- [.rules.md](./.rules.md) - Complete AI coding rules and guidelines
-- [CONTRIBUTING.md](./CONTRIBUTING.md) - Contribution guidelines
-- [README.md](./README.md) - Project overview and setup instructions

CODE_OF_CONDUCT.md

@@ -1,128 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-We as members, contributors, and leaders pledge to make participation in our
-community a harassment-free experience for everyone, regardless of age, body
-size, visible or invisible disability, ethnicity, sex characteristics, gender
-identity and expression, level of experience, education, socio-economic status,
-nationality, personal appearance, race, religion, or sexual identity
-and orientation.
-
-We pledge to act and interact in ways that contribute to an open, welcoming,
-diverse, inclusive, and healthy community.
-
-## Our Standards
-
-Examples of behavior that contributes to a positive environment for our
-community include:
-
-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes,
-  and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the
-  overall community
-
-Examples of unacceptable behavior include:
-
-* The use of sexualized language or imagery, and sexual attention or
-  advances of any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email
-  address, without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Enforcement Responsibilities
-
-Community leaders are responsible for clarifying and enforcing our standards of
-acceptable behavior and will take appropriate and fair corrective action in
-response to any behavior that they deem inappropriate, threatening, offensive,
-or harmful.
-
-Community leaders have the right and responsibility to remove, edit, or reject
-comments, commits, code, wiki edits, issues, and other contributions that are
-not aligned to this Code of Conduct, and will communicate reasons for moderation
-decisions when appropriate.
-
-## Scope
-
-This Code of Conduct applies within all community spaces, and also applies when
-an individual is officially representing the community in public spaces.
-Examples of representing our community include using an official e-mail address,
-posting via an official social media account, or acting as an appointed
-representative at an online or offline event.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported to the community leaders responsible for enforcement at
-hello@rustfs.com.
-All complaints will be reviewed and investigated promptly and fairly.
-
-All community leaders are obligated to respect the privacy and security of the
-reporter of any incident.
-
-## Enforcement Guidelines
-
-Community leaders will follow these Community Impact Guidelines in determining
-the consequences for any action they deem in violation of this Code of Conduct:
-
-### 1. Correction
-
-**Community Impact**: Use of inappropriate language or other behavior deemed
-unprofessional or unwelcome in the community.
-
-**Consequence**: A private, written warning from community leaders, providing
-clarity around the nature of the violation and an explanation of why the
-behavior was inappropriate. A public apology may be requested.
-
-### 2. Warning
-
-**Community Impact**: A violation through a single incident or series
-of actions.
-
-**Consequence**: A warning with consequences for continued behavior. No
-interaction with the people involved, including unsolicited interaction with
-those enforcing the Code of Conduct, for a specified period of time. This
-includes avoiding interactions in community spaces as well as external channels
-like social media. Violating these terms may lead to a temporary or
-permanent ban.
-
-### 3. Temporary Ban
-
-**Community Impact**: A serious violation of community standards, including
-sustained inappropriate behavior.
-
-**Consequence**: A temporary ban from any sort of interaction or public
-communication with the community for a specified period of time. No public or
-private interaction with the people involved, including unsolicited interaction
-with those enforcing the Code of Conduct, is allowed during this period.
-Violating these terms may lead to a permanent ban.
-
-### 4. Permanent Ban
-
-**Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior,  harassment of an
-individual, or aggression toward or disparagement of classes of individuals.
-
-**Consequence**: A permanent ban from any sort of public interaction within
-the community.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 2.0, available at
-https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
-
-Community Impact Guidelines were inspired by [Mozilla's code of conduct
-enforcement ladder](https://github.com/mozilla/diversity).
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see the FAQ at
-https://www.contributor-covenant.org/faq. Translations are available at
-https://www.contributor-covenant.org/translations.

CONTRIBUTING.md

@@ -1,189 +0,0 @@
-# RustFS Development Guide
-
-## 📋 Code Quality Requirements
-
-### 🔧 Code Formatting Rules
-
-**MANDATORY**: All code must be properly formatted before committing. This project enforces strict formatting standards to maintain code consistency and readability.
-
-#### Pre-commit Requirements
-
-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
-   ```
-
-#### Quick Commands
-
-We provide convenient Makefile targets for common tasks:
-
-```bash
-# Format all code
-make fmt
-
-# Check if code is properly formatted
-make fmt-check
-
-# Run clippy checks
-make clippy
-
-# Run compilation check
-make check
-
-# Run tests
-make test
-
-# Run all pre-commit checks (format + clippy + check + test)
-make pre-commit
-
-# Setup git hooks (one-time setup)
-make setup-hooks
-```
-
-### 🔒 Automated Pre-commit Hooks
-
-This project includes a pre-commit hook that automatically runs before each commit to ensure:
-
-- ✅ Code is properly formatted (`cargo fmt --all --check`)
-- ✅ No clippy warnings (`cargo clippy --all-targets --all-features -- -D warnings`)
-- ✅ Code compiles successfully (`cargo check --all-targets`)
-
-#### Setting Up Pre-commit Hooks
-
-Run this command once after cloning the repository:
-
-```bash
-make setup-hooks
-```
-
-Or manually:
-
-```bash
-chmod +x .git/hooks/pre-commit
-```
-
-### 📝 Formatting Configuration
-
-The project uses the following rustfmt configuration (defined in `rustfmt.toml`):
-
-```toml
-max_width = 130
-fn_call_width = 90
-single_line_let_else_max_width = 100
-```
-
-### 🚫 Commit Prevention
-
-If your code doesn't meet the formatting requirements, the pre-commit hook will:
-
-1. **Block the commit** and show clear error messages
-2. **Provide exact commands** to fix the issues
-3. **Guide you through** the resolution process
-
-Example output when formatting fails:
-
-```
-❌ Code formatting check failed!
-💡 Please run 'cargo fmt --all' to format your code before committing.
-
-🔧 Quick fix:
-   cargo fmt --all
-   git add .
-   git commit
-```
-
-### 🔄 Development Workflow
-
-1. **Make your changes**
-2. **Format your code**: `make fmt` or `cargo fmt --all`
-3. **Run pre-commit checks**: `make pre-commit`
-4. **Commit your changes**: `git commit -m "your message"`
-5. **Push to your branch**: `git push`
-
-### 🛠️ IDE Integration
-
-#### VS Code
-
-Install the `rust-analyzer` extension and add to your `settings.json`:
-
-```json
-{
-    "rust-analyzer.rustfmt.extraArgs": ["--config-path", "./rustfmt.toml"],
-    "editor.formatOnSave": true,
-    "[rust]": {
-        "editor.defaultFormatter": "rust-lang.rust-analyzer"
-    }
-}
-```
-
-#### Other IDEs
-
-Configure your IDE to:
-
-- Use the project's `rustfmt.toml` configuration
-- Format on save
-- Run clippy checks
-
-### ❗ Important Notes
-
-- **Never bypass formatting checks** - they are there for a reason
-- **All CI/CD pipelines** will also enforce these same checks
-- **Pull requests** will be automatically rejected if formatting checks fail
-- **Consistent formatting** improves code readability and reduces merge conflicts
-
-### 🆘 Troubleshooting
-
-#### Pre-commit hook not running?
-
-```bash
-# Check if hook is executable
-ls -la .git/hooks/pre-commit
-
-# Make it executable if needed
-chmod +x .git/hooks/pre-commit
-```
-
-#### Formatting issues?
-
-```bash
-# Format all code
-cargo fmt --all
-
-# Check specific issues
-cargo fmt --all --check --verbose
-```
-
-#### Clippy issues?
-
-```bash
-# See detailed clippy output
-cargo clippy --all-targets --all-features -- -D warnings
-
-# Fix automatically fixable issues
-cargo clippy --fix --all-targets --all-features
-```
-
----
-
-Following these guidelines ensures high code quality and smooth collaboration across the RustFS project! 🚀

Cargo.toml

@@ -1,288 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-[workspace]
-members = [
-    "rustfs", # Core file system implementation
-    "crates/appauth", # Application authentication and authorization
-    "crates/audit-logger", # Audit logging system for file operations
-    "crates/common", # Shared utilities and data structures
-    "crates/config", # Configuration management
-    "crates/crypto", # Cryptography and security features
-    "crates/ecstore", # Erasure coding storage implementation
-    "crates/e2e_test", # End-to-end test suite
-    "crates/filemeta", # File metadata management
-    "crates/iam", # Identity and Access Management
-    "crates/lock", # Distributed locking implementation
-    "crates/madmin", # Management dashboard and admin API interface
-    "crates/notify", # Notification system for events
-    "crates/obs", # Observability utilities
-    "crates/protos", # Protocol buffer definitions
-    "crates/rio", # Rust I/O utilities and abstractions
-    "crates/targets", # Target-specific configurations and utilities
-    "crates/s3select-api", # S3 Select API interface
-    "crates/s3select-query", # S3 Select query engine
-    "crates/signer", # client signer
-    "crates/checksums", # client checksums
-    "crates/utils", # Utility functions and helpers
-    "crates/workers", # Worker thread pools and task scheduling
-    "crates/zip", # ZIP file handling and compression
-    "crates/ahm", # Asynchronous Hash Map for concurrent data structures
-    "crates/mcp", # MCP server for S3 operations
-]
-resolver = "2"
-
-[workspace.package]
-edition = "2024"
-license = "Apache-2.0"
-repository = "https://github.com/rustfs/rustfs"
-rust-version = "1.85"
-version = "0.0.5"
-homepage = "https://rustfs.com"
-description = "RustFS is a high-performance distributed object storage software built using Rust, one of the most popular languages worldwide. "
-keywords = ["RustFS", "Minio", "object-storage", "filesystem", "s3"]
-categories = ["web-programming", "development-tools", "filesystem", "network-programming"]
-
-[workspace.lints.rust]
-unsafe_code = "deny"
-
-[workspace.lints.clippy]
-all = "warn"
-
-[workspace.dependencies]
-rustfs-ahm = { path = "crates/ahm", version = "0.0.5" }
-rustfs-s3select-api = { path = "crates/s3select-api", version = "0.0.5" }
-rustfs-appauth = { path = "crates/appauth", version = "0.0.5" }
-rustfs-audit-logger = { path = "crates/audit-logger", version = "0.0.5" }
-rustfs-common = { path = "crates/common", version = "0.0.5" }
-rustfs-crypto = { path = "crates/crypto", version = "0.0.5" }
-rustfs-ecstore = { path = "crates/ecstore", version = "0.0.5" }
-rustfs-iam = { path = "crates/iam", version = "0.0.5" }
-rustfs-lock = { path = "crates/lock", version = "0.0.5" }
-rustfs-madmin = { path = "crates/madmin", version = "0.0.5" }
-rustfs-policy = { path = "crates/policy", version = "0.0.5" }
-rustfs-protos = { path = "crates/protos", version = "0.0.5" }
-rustfs-s3select-query = { path = "crates/s3select-query", version = "0.0.5" }
-rustfs = { path = "./rustfs", version = "0.0.5" }
-rustfs-zip = { path = "./crates/zip", version = "0.0.5" }
-rustfs-config = { path = "./crates/config", version = "0.0.5" }
-rustfs-obs = { path = "crates/obs", version = "0.0.5" }
-rustfs-notify = { path = "crates/notify", version = "0.0.5" }
-rustfs-utils = { path = "crates/utils", version = "0.0.5" }
-rustfs-rio = { path = "crates/rio", version = "0.0.5" }
-rustfs-filemeta = { path = "crates/filemeta", version = "0.0.5" }
-rustfs-signer = { path = "crates/signer", version = "0.0.5" }
-rustfs-checksums = { path = "crates/checksums", version = "0.0.5" }
-rustfs-workers = { path = "crates/workers", version = "0.0.5" }
-rustfs-mcp = { path = "crates/mcp", version = "0.0.5" }
-rustfs-targets = { path = "crates/targets", version = "0.0.5" }
-aes-gcm = { version = "0.10.3", features = ["std"] }
-anyhow = "1.0.99"
-arc-swap = "1.7.1"
-argon2 = { version = "0.5.3", features = ["std"] }
-atoi = "2.0.0"
-async-channel = "2.5.0"
-async-recursion = "1.1.1"
-async-trait = "0.1.89"
-async-compression = { version = "0.4.19" }
-atomic_enum = "0.3.0"
-aws-config = { version = "1.8.6" }
-aws-sdk-s3 = "1.101.0"
-axum = "0.8.4"
-base64-simd = "0.8.0"
-base64 = "0.22.1"
-brotli = "8.0.2"
-bytes = { version = "1.10.1", features = ["serde"] }
-bytesize = "2.0.1"
-byteorder = "1.5.0"
-cfg-if = "1.0.3"
-crc-fast = "1.5.0"
-chacha20poly1305 = { version = "0.10.1" }
-chrono = { version = "0.4.41", features = ["serde"] }
-clap = { version = "4.5.46", features = ["derive", "env"] }
-const-str = { version = "0.6.4", features = ["std", "proc"] }
-crc32fast = "1.5.0"
-criterion = { version = "0.7", features = ["html_reports"] }
-dashmap = "6.1.0"
-datafusion = "46.0.1"
-derive_builder = "0.20.2"
-enumset = "1.1.10"
-flatbuffers = "25.2.10"
-flate2 = "1.1.2"
-flexi_logger = { version = "0.31.2", features = ["trc", "dont_minimize_extra_stacks"] }
-form_urlencoded = "1.2.2"
-futures = "0.3.31"
-futures-core = "0.3.31"
-futures-util = "0.3.31"
-glob = "0.3.3"
-hex = "0.4.3"
-hex-simd = "0.8.0"
-highway = { version = "1.3.0" }
-hmac = "0.12.1"
-hyper = "1.7.0"
-hyper-util = { version = "0.1.16", features = [
-    "tokio",
-    "server-auto",
-    "server-graceful",
-] }
-hyper-rustls = "0.27.7"
-http = "1.3.1"
-http-body = "1.0.1"
-humantime = "2.2.0"
-ipnetwork = { version = "0.21.1", features = ["serde"] }
-jsonwebtoken = "9.3.1"
-lazy_static = "1.5.0"
-libsystemd = { version = "0.7.2" }
-local-ip-address = "0.6.5"
-lz4 = "1.28.1"
-matchit = "0.8.4"
-md-5 = "0.10.6"
-mime_guess = "2.0.5"
-netif = "0.1.6"
-nix = { version = "0.30.1", features = ["fs"] }
-nu-ansi-term = "0.50.1"
-num_cpus = { version = "1.17.0" }
-nvml-wrapper = "0.11.0"
-object_store = "0.11.2"
-once_cell = "1.21.3"
-opentelemetry = { version = "0.30.0" }
-opentelemetry-appender-tracing = { version = "0.30.1", features = [
-    "experimental_use_tracing_span_context",
-    "experimental_metadata_attributes",
-    "spec_unstable_logs_enabled"
-] }
-opentelemetry_sdk = { version = "0.30.0" }
-opentelemetry-stdout = { version = "0.30.0" }
-opentelemetry-otlp = { version = "0.30.0", default-features = false, features = [
-    "grpc-tonic", "gzip-tonic", "trace", "metrics", "logs", "internal-logs"
-] }
-opentelemetry-semantic-conventions = { version = "0.30.0", features = [
-    "semconv_experimental",
-] }
-parking_lot = "0.12.4"
-path-absolutize = "3.1.1"
-path-clean = "1.0.1"
-blake3 = { version = "1.8.2" }
-pbkdf2 = "0.12.2"
-percent-encoding = "2.3.2"
-pin-project-lite = "0.2.16"
-prost = "0.14.1"
-pretty_assertions = "1.4.1"
-quick-xml = "0.38.3"
-rand = "0.9.2"
-rdkafka = { version = "0.38.0", features = ["tokio"] }
-reed-solomon-simd = { version = "3.0.1" }
-regex = { version = "1.11.2" }
-reqwest = { version = "0.12.23", default-features = false, features = [
-    "rustls-tls",
-    "charset",
-    "http2",
-    "system-proxy",
-    "stream",
-    "json",
-    "blocking",
-] }
-rmcp = { version = "0.6.1" }
-rmp = "0.8.14"
-rmp-serde = "1.3.0"
-rsa = "0.9.8"
-rumqttc = { version = "0.24" }
-rust-embed = { version = "8.7.2" }
-rustfs-rsc = "2025.506.1"
-rustls = { version = "0.23.31" }
-rustls-pki-types = "1.12.0"
-rustls-pemfile = "2.2.0"
-s3s = { version = "0.12.0-minio-preview.3" }
-schemars = "1.0.4"
-serde = { version = "1.0.219", features = ["derive"] }
-serde_json = { version = "1.0.143", features = ["raw_value"] }
-serde_urlencoded = "0.7.1"
-serial_test = "3.2.0"
-sha1 = "0.10.6"
-sha2 = "0.10.9"
-shadow-rs = { version = "1.3.0", default-features = false }
-siphasher = "1.0.1"
-smallvec = { version = "1.15.1", features = ["serde"] }
-snafu = "0.8.8"
-snap = "1.1.1"
-socket2 = "0.6.0"
-strum = { version = "0.27.2", features = ["derive"] }
-sysinfo = "0.37.0"
-sysctl = "0.6.0"
-tempfile = "3.21.0"
-temp-env = "0.3.6"
-test-case = "3.3.1"
-thiserror = "2.0.16"
-time = { version = "0.3.42", features = [
-    "std",
-    "parsing",
-    "formatting",
-    "macros",
-    "serde",
-] }
-tokio = { version = "1.47.1", features = ["fs", "rt-multi-thread"] }
-tokio-rustls = { version = "0.26.2", default-features = false }
-tokio-stream = { version = "0.1.17" }
-tokio-tar = "0.3.1"
-tokio-test = "0.4.4"
-tokio-util = { version = "0.7.16", features = ["io", "compat"] }
-tonic = { version = "0.14.1", features = ["gzip"] }
-tonic-prost = { version = "0.14.1" }
-tonic-prost-build = { version = "0.14.1" }
-tower = { version = "0.5.2", features = ["timeout"] }
-tower-http = { version = "0.6.6", features = ["cors"] }
-tracing = "0.1.41"
-tracing-core = "0.1.34"
-tracing-error = "0.2.1"
-tracing-opentelemetry = "0.31.0"
-tracing-subscriber = { version = "0.3.20", features = ["env-filter", "time"] }
-transform-stream = "0.3.1"
-url = "2.5.7"
-urlencoding = "2.1.3"
-uuid = { version = "1.18.0", features = [
-    "v4",
-    "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"] }
-zip = "2.4.2"
-zstd = "0.13.3"
-
-
-[workspace.metadata.cargo-shear]
-ignored = ["rustfs", "rust-i18n", "rustfs-mcp", "rustfs-audit-logger", "tokio-test"]
-
-[profile.wasm-dev]
-inherits = "dev"
-opt-level = 1
-
-[profile.server-dev]
-inherits = "dev"
-
-[profile.android-dev]
-inherits = "dev"
-
-[profile.release]
-opt-level = 3
-
-[profile.production]
-inherits = "release"
-lto = "fat"
-codegen-units = 1
-
-[profile.profiling]
-inherits = "release"
-debug = true

Dockerfile

@@ -1,85 +0,0 @@
-FROM alpine:3.22 AS build
-
-ARG TARGETARCH
-ARG RELEASE=latest
-
-RUN apk add --no-cache ca-certificates curl unzip
-WORKDIR /build
-
-RUN set -eux; \
-    case "$TARGETARCH" in \
-      amd64)  ARCH_SUBSTR="x86_64-musl"  ;; \
-      arm64)  ARCH_SUBSTR="aarch64-musl" ;; \
-      *) echo "Unsupported TARGETARCH=$TARGETARCH" >&2; exit 1 ;; \
-    esac; \
-    if [ "$RELEASE" = "latest" ]; then \
-      TAG="$(curl -fsSL https://api.github.com/repos/rustfs/rustfs/releases \
-              | grep -o '"tag_name": "[^"]*"' | cut -d'"' -f4 | head -n 1)"; \
-    else \
-      TAG="$RELEASE"; \
-    fi; \
-    echo "Using tag: $TAG (arch pattern: $ARCH_SUBSTR)"; \
-    # Find download URL in assets list for this tag that contains arch substring and ends with .zip
-    URL="$(curl -fsSL "https://api.github.com/repos/rustfs/rustfs/releases/tags/$TAG" \
-           | grep -o "\"browser_download_url\": \"[^\"]*${ARCH_SUBSTR}[^\"]*\\.zip\"" \
-           | cut -d'"' -f4 | head -n 1)"; \
-    if [ -z "$URL" ]; then echo "Failed to locate release asset for $ARCH_SUBSTR at tag $TAG" >&2; exit 1; fi; \
-    echo "Downloading: $URL"; \
-    curl -fL "$URL" -o rustfs.zip; \
-    unzip -q rustfs.zip -d /build; \
-    # If binary is not in root directory, try to locate and move from zip to /build/rustfs
-    if [ ! -x /build/rustfs ]; then \
-      BIN_PATH="$(unzip -Z -1 rustfs.zip | grep -E '(^|/)rustfs$' | head -n 1 || true)"; \
-      if [ -n "$BIN_PATH" ]; then \
-        mkdir -p /build/.tmp && unzip -q rustfs.zip "$BIN_PATH" -d /build/.tmp && \
-        mv "/build/.tmp/$BIN_PATH" /build/rustfs; \
-      fi; \
-    fi; \
-    [ -x /build/rustfs ] || { echo "rustfs binary not found in asset" >&2; exit 1; }; \
-    chmod +x /build/rustfs; \
-    rm -rf rustfs.zip /build/.tmp || true
-
-
-FROM alpine:3.22
-
-ARG RELEASE=latest
-ARG BUILD_DATE
-ARG VCS_REF
-
-LABEL name="RustFS" \
-      vendor="RustFS Team" \
-      maintainer="RustFS Team <dev@rustfs.com>" \
-      version="v${RELEASE#v}" \
-      release="${RELEASE}" \
-      build-date="${BUILD_DATE}" \
-      vcs-ref="${VCS_REF}" \
-      summary="High-performance distributed object storage system compatible with S3 API" \
-      description="RustFS is a distributed object storage system written in Rust, supporting erasure coding, multi-tenant management, and observability." \
-      url="https://rustfs.com" \
-      license="Apache-2.0"
-
-RUN apk add --no-cache ca-certificates coreutils
-
-COPY --from=build /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
-COPY --from=build /build/rustfs /usr/bin/rustfs
-COPY entrypoint.sh /entrypoint.sh
-
-RUN chmod +x /usr/bin/rustfs /entrypoint.sh && \
-    mkdir -p /data /logs && \
-    chmod 0750 /data /logs
-
-ENV RUSTFS_ADDRESS=":9000" \
-    RUSTFS_ACCESS_KEY="rustfsadmin" \
-    RUSTFS_SECRET_KEY="rustfsadmin" \
-    RUSTFS_CONSOLE_ENABLE="true" \
-    RUSTFS_VOLUMES="/data" \
-    RUST_LOG="warn" \
-    RUSTFS_OBS_LOG_DIRECTORY="/logs" \
-    RUSTFS_SINKS_FILE_PATH="/logs"
-
-EXPOSE 9000
-VOLUME ["/data", "/logs"]
-
-ENTRYPOINT ["/entrypoint.sh"]
-
-CMD ["rustfs"]

Dockerfile.source

@@ -1,181 +0,0 @@
-# syntax=docker/dockerfile:1.6
-# Multi-stage Dockerfile for RustFS - LOCAL DEVELOPMENT ONLY
-#
-# IMPORTANT: This Dockerfile builds RustFS from source for local development and testing.
-# CI/CD uses the production Dockerfile with prebuilt binaries instead.
-#
-# Example:
-#   docker build -f Dockerfile.source -t rustfs:dev-local .
-#   docker run --rm -p 9000:9000 rustfs:dev-local
-#
-# Supports cross-compilation for amd64 and arm64 via TARGETPLATFORM.
-
-ARG TARGETPLATFORM
-ARG BUILDPLATFORM
-
-# -----------------------------
-# Build stage
-# -----------------------------
-FROM rust:1.88-bookworm AS builder
-
-# Re-declare args after FROM
-ARG TARGETPLATFORM
-ARG BUILDPLATFORM
-
-# Debug: print platforms
-RUN echo "Build info -> BUILDPLATFORM=${BUILDPLATFORM}, TARGETPLATFORM=${TARGETPLATFORM}"
-
-# Install build toolchain and headers
-# Use distro packages for protoc/flatc to avoid host-arch mismatch
-RUN set -eux; \
-    export DEBIAN_FRONTEND=noninteractive; \
-    apt-get update; \
-    apt-get install -y --no-install-recommends \
-    build-essential \
-    ca-certificates \
-    curl \
-    git \
-    pkg-config \
-    libssl-dev \
-    lld \
-    protobuf-compiler \
-    flatbuffers-compiler; \
-    rm -rf /var/lib/apt/lists/*
-
-# Optional: cross toolchain for aarch64 (only when targeting linux/arm64)
-RUN set -eux; \
-    if [ "${TARGETPLATFORM:-linux/amd64}" = "linux/arm64" ]; then \
-    export DEBIAN_FRONTEND=noninteractive; \
-    apt-get update; \
-    apt-get install -y --no-install-recommends gcc-aarch64-linux-gnu; \
-    rm -rf /var/lib/apt/lists/*; \
-    fi
-
-# Add Rust targets based on TARGETPLATFORM
-RUN set -eux; \
-    case "${TARGETPLATFORM:-linux/amd64}" in \
-    linux/amd64) rustup target add x86_64-unknown-linux-gnu ;; \
-    linux/arm64) rustup target add aarch64-unknown-linux-gnu ;; \
-    *) echo "Unsupported TARGETPLATFORM=${TARGETPLATFORM}" >&2; exit 1 ;; \
-    esac
-
-# Cross-compilation environment (used only when targeting aarch64)
-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
-
-# Layered copy to maximize caching:
-# 1) top-level manifests
-COPY Cargo.toml Cargo.lock ./
-# 2) workspace member manifests (adjust if workspace layout changes)
-COPY rustfs/Cargo.toml rustfs/Cargo.toml
-COPY crates/*/Cargo.toml crates/
-COPY cli/rustfs-gui/Cargo.toml cli/rustfs-gui/Cargo.toml
-
-# Pre-fetch dependencies for better caching
-RUN --mount=type=cache,target=/usr/local/cargo/registry \
-    --mount=type=cache,target=/usr/local/cargo/git \
-    cargo fetch --locked || true
-
-# 3) copy full sources (this is the main cache invalidation point)
-COPY . .
-
-# Cargo build configuration for lean release artifacts
-ENV CARGO_NET_GIT_FETCH_WITH_CLI=true \
-    CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse \
-    CARGO_INCREMENTAL=0 \
-    CARGO_PROFILE_RELEASE_DEBUG=false \
-    CARGO_PROFILE_RELEASE_SPLIT_DEBUGINFO=off \
-    CARGO_PROFILE_RELEASE_STRIP=symbols
-
-# Generate protobuf/flatbuffers code (uses protoc/flatc from distro)
-RUN --mount=type=cache,target=/usr/local/cargo/registry \
-    --mount=type=cache,target=/usr/local/cargo/git \
-    --mount=type=cache,target=/usr/src/rustfs/target \
-    cargo run --bin gproto
-
-# Build RustFS (target depends on TARGETPLATFORM)
-RUN --mount=type=cache,target=/usr/local/cargo/registry \
-    --mount=type=cache,target=/usr/local/cargo/git \
-    --mount=type=cache,target=/usr/src/rustfs/target \
-    set -eux; \
-    case "${TARGETPLATFORM:-linux/amd64}" in \
-    linux/amd64) \
-    echo "Building for x86_64-unknown-linux-gnu"; \
-    cargo build --release --locked --target x86_64-unknown-linux-gnu --bin rustfs -j "$(nproc)"; \
-    install -m 0755 target/x86_64-unknown-linux-gnu/release/rustfs /usr/local/bin/rustfs \
-    ;; \
-    linux/arm64) \
-    echo "Building for aarch64-unknown-linux-gnu"; \
-    cargo build --release --locked --target aarch64-unknown-linux-gnu --bin rustfs -j "$(nproc)"; \
-    install -m 0755 target/aarch64-unknown-linux-gnu/release/rustfs /usr/local/bin/rustfs \
-    ;; \
-    *) \
-    echo "Unsupported TARGETPLATFORM=${TARGETPLATFORM}" >&2; exit 1 \
-    ;; \
-    esac
-
-# -----------------------------
-# Runtime stage (Ubuntu minimal)
-# -----------------------------
-FROM ubuntu:22.04
-
-ARG BUILD_DATE
-ARG VCS_REF
-
-LABEL name="RustFS (dev-local)" \
-    maintainer="RustFS Team" \
-    build-date="${BUILD_DATE}" \
-    vcs-ref="${VCS_REF}" \
-    description="RustFS - local development image built from source (NOT for production)."
-
-# Minimal runtime deps: certificates + tzdata + coreutils (for chroot --userspec)
-RUN set -eux; \
-    export DEBIAN_FRONTEND=noninteractive; \
-    apt-get update; \
-    apt-get install -y --no-install-recommends \
-    ca-certificates \
-    tzdata \
-    coreutils; \
-    rm -rf /var/lib/apt/lists/*
-
-# Create a conventional runtime user/group (final switch happens in entrypoint via chroot --userspec)
-RUN set -eux; \
-    groupadd -g 1000 rustfs; \
-    useradd -u 1000 -g rustfs -M -s /usr/sbin/nologin rustfs
-
-WORKDIR /app
-
-# Prepare data/log directories with sane defaults
-RUN set -eux; \
-    mkdir -p /data /logs; \
-    chown -R rustfs:rustfs /data /logs /app; \
-    chmod 0750 /data /logs
-
-# Copy the freshly built binary and the entrypoint
-COPY --from=builder /usr/local/bin/rustfs /usr/bin/rustfs
-COPY entrypoint.sh /entrypoint.sh
-RUN chmod +x /usr/bin/rustfs /entrypoint.sh
-
-# Default environment (override in docker run/compose as needed)
-ENV RUSTFS_ADDRESS=":9000" \
-    RUSTFS_ACCESS_KEY="rustfsadmin" \
-    RUSTFS_SECRET_KEY="rustfsadmin" \
-    RUSTFS_CONSOLE_ENABLE="true" \
-    RUSTFS_VOLUMES="/data" \
-    RUST_LOG="warn" \
-    RUSTFS_OBS_LOG_DIRECTORY="/logs" \
-    RUSTFS_SINKS_FILE_PATH="/logs" \
-    RUSTFS_USERNAME="rustfs" \
-    RUSTFS_GROUPNAME="rustfs" \
-    RUSTFS_UID="1000" \
-    RUSTFS_GID="1000"
-
-EXPOSE 9000
-VOLUME ["/data", "/logs"]
-
-# Keep root here; entrypoint will drop privileges using chroot --userspec
-ENTRYPOINT ["/entrypoint.sh"]
-CMD ["/usr/bin/rustfs"]

Justfile

@@ -1,258 +0,0 @@
-DOCKER_CLI := env("DOCKER_CLI", "docker")
-IMAGE_NAME := env("IMAGE_NAME", "rustfs:v1.0.0")
-DOCKERFILE_SOURCE := env("DOCKERFILE_SOURCE", "Dockerfile.source")
-DOCKERFILE_PRODUCTION := env("DOCKERFILE_PRODUCTION", "Dockerfile")
-CONTAINER_NAME := env("CONTAINER_NAME", "rustfs-dev")
-
-[group("📒 Help")]
-[private]
-default:
-    @just --list --list-heading $'🦀 RustFS justfile manual page:\n'
-
-[doc("show help")]
-[group("📒 Help")]
-help: default
-
-[doc("run `cargo fmt` to format codes")]
-[group("👆 Code Quality")]
-fmt:
-    @echo "🔧 Formatting code..."
-    cargo fmt --all
-
-[doc("run `cargo fmt` in check mode")]
-[group("👆 Code Quality")]
-fmt-check:
-    @echo "📝 Checking code formatting..."
-    cargo fmt --all --check
-
-[doc("run `cargo clippy`")]
-[group("👆 Code Quality")]
-clippy:
-    @echo "🔍 Running clippy checks..."
-    cargo clippy --all-targets --all-features --fix --allow-dirty -- -D warnings
-
-[doc("run `cargo check`")]
-[group("👆 Code Quality")]
-check:
-    @echo "🔨 Running compilation check..."
-    cargo check --all-targets
-
-[doc("run `cargo test`")]
-[group("👆 Code Quality")]
-test:
-    @echo "🧪 Running tests..."
-    cargo nextest run --all --exclude e2e_test
-    cargo test --all --doc
-
-[doc("run `fmt` `clippy` `check` `test` at once")]
-[group("👆 Code Quality")]
-pre-commit: fmt clippy check test
-    @echo "✅ All pre-commit checks passed!"
-
-[group("🤔 Git")]
-setup-hooks:
-    @echo "🔧 Setting up git hooks..."
-    chmod +x .git/hooks/pre-commit
-    @echo "✅ Git hooks setup complete!"
-
-[doc("use `release` mode for building")]
-[group("🔨 Build")]
-build:
-    @echo "🔨 Building RustFS using build-rustfs.sh script..."
-    ./build-rustfs.sh
-
-[doc("use `debug` mode for building")]
-[group("🔨 Build")]
-build-dev:
-    @echo "🔨 Building RustFS in development mode..."
-    ./build-rustfs.sh --dev
-
-[group("🔨 Build")]
-[private]
-build-target target:
-    @echo "🔨 Building rustfs for {{ target }}..."
-    @echo "💡 On macOS/Windows, use 'make build-docker' or 'make docker-dev' instead"
-    ./build-rustfs.sh --platform {{ target }}
-
-[doc("use `x86_64-unknown-linux-musl` target for building")]
-[group("🔨 Build")]
-build-musl: (build-target "x86_64-unknown-linux-musl")
-
-[doc("use `x86_64-unknown-linux-gnu` target for building")]
-[group("🔨 Build")]
-build-gnu: (build-target "x86_64-unknown-linux-gnu")
-
-[doc("use `aarch64-unknown-linux-musl` target for building")]
-[group("🔨 Build")]
-build-musl-arm64: (build-target "aarch64-unknown-linux-musl")
-
-[doc("use `aarch64-unknown-linux-gnu` target for building")]
-[group("🔨 Build")]
-build-gnu-arm64: (build-target "aarch64-unknown-linux-gnu")
-
-[doc("build and deploy to server")]
-[group("🔨 Build")]
-deploy-dev ip: build-musl
-    @echo "🚀 Deploying to dev server: {{ ip }}"
-    ./scripts/dev_deploy.sh {{ ip }}
-
-[group("🔨 Build")]
-[private]
-build-cross-all-pre:
-    @echo "🔧 Building all target architectures..."
-    @echo "💡 On macOS/Windows, use 'make docker-dev' for reliable multi-arch builds"
-    @echo "🔨 Generating protobuf code..."
-    -cargo run --bin gproto
-
-[doc("build all targets at once")]
-[group("🔨 Build")]
-build-cross-all: build-cross-all-pre && build-gnu build-gnu-arm64 build-musl build-musl-arm64
-
-# ========================================================================================
-# Docker Multi-Architecture Builds (Primary Methods)
-# ========================================================================================
-
-[doc("build an image and run it")]
-[group("🐳 Build Image")]
-build-docker os="rockylinux9.3" cli=(DOCKER_CLI) dockerfile=(DOCKERFILE_SOURCE):
-    #!/usr/bin/env bash
-    SOURCE_BUILD_IMAGE_NAME="rustfs/rustfs-{{ os }}:v1"
-    SOURCE_BUILD_CONTAINER_NAME="rustfs-{{ os }}-build"
-    BUILD_CMD="/root/.cargo/bin/cargo build --release --bin rustfs --target-dir /root/s3-rustfs/target/{{ os }}"
-    echo "🐳 Building RustFS using Docker ({{ os }})..."
-    {{ cli }} buildx build -t $SOURCE_BUILD_IMAGE_NAME -f {{ dockerfile }} .
-    {{ cli }} run --rm --name $SOURCE_BUILD_CONTAINER_NAME -v $(pwd):/root/s3-rustfs -it $SOURCE_BUILD_IMAGE_NAME $BUILD_CMD
-
-[doc("build an image")]
-[group("🐳 Build Image")]
-docker-buildx:
-    @echo "🏗️ Building multi-architecture production Docker images with buildx..."
-    ./docker-buildx.sh
-
-[doc("build an image and push it")]
-[group("🐳 Build Image")]
-docker-buildx-push:
-    @echo "🚀 Building and pushing multi-architecture production Docker images with buildx..."
-    ./docker-buildx.sh --push
-
-[doc("build an image with a version")]
-[group("🐳 Build Image")]
-docker-buildx-version version:
-    @echo "🏗️ Building multi-architecture production Docker images (version: {{ version }}..."
-    ./docker-buildx.sh --release {{ version }}
-
-[doc("build an image with a version and push it")]
-[group("🐳 Build Image")]
-docker-buildx-push-version version:
-    @echo "🚀 Building and pushing multi-architecture production Docker images (version: {{ version }}..."
-    ./docker-buildx.sh --release {{ version }} --push
-
-[doc("build an image with a version and push it to registry")]
-[group("🐳 Build Image")]
-docker-dev-push registry cli=(DOCKER_CLI) source=(DOCKERFILE_SOURCE):
-    @echo "🚀 Building and pushing multi-architecture development Docker images..."
-    @echo "💡 push to registry: {{ registry }}"
-    {{ cli }} buildx build \
-    	--platform linux/amd64,linux/arm64 \
-    	--file {{ source }} \
-    	--tag {{ registry }}/rustfs:source-latest \
-    	--tag {{ registry }}/rustfs:dev-latest \
-    	--push \
-    	.
-
-# Local production builds using direct buildx (alternative to docker-buildx.sh)
-
-[group("🐳 Build Image")]
-docker-buildx-production-local cli=(DOCKER_CLI) source=(DOCKERFILE_PRODUCTION):
-    @echo "🏗️ Building single-architecture production Docker image locally..."
-    @echo "💡 Alternative to docker-buildx.sh for local testing"
-    {{ cli }} buildx build \
-    	--file {{ source }} \
-    	--tag rustfs:production-latest \
-    	--tag rustfs:latest \
-    	--load \
-    	--build-arg RELEASE=latest \
-    	.
-
-# Development/Source builds using direct buildx commands
-
-[group("🐳 Build Image")]
-docker-dev cli=(DOCKER_CLI) source=(DOCKERFILE_SOURCE):
-    @echo "🏗️ Building multi-architecture development Docker images with buildx..."
-    @echo "💡 This builds from source code and is intended for local development and testing"
-    @echo "⚠️  Multi-arch images cannot be loaded locally, use docker-dev-push to push to registry"
-    {{ cli }} buildx build \
-    	--platform linux/amd64,linux/arm64 \
-    	--file {{ source }} \
-    	--tag rustfs:source-latest \
-    	--tag rustfs:dev-latest \
-    	.
-
-[group("🐳 Build Image")]
-docker-dev-local cli=(DOCKER_CLI) source=(DOCKERFILE_SOURCE):
-    @echo "🏗️ Building single-architecture development Docker image for local use..."
-    @echo "💡 This builds from source code for the current platform and loads locally"
-    {{ cli }} buildx build \
-    	--file {{ source }} \
-    	--tag rustfs:source-latest \
-    	--tag rustfs:dev-latest \
-    	--load \
-    	.
-
-# ========================================================================================
-# Single Architecture Docker Builds (Traditional)
-# ========================================================================================
-
-[group("🐳 Build Image")]
-docker-build-production cli=(DOCKER_CLI) source=(DOCKERFILE_PRODUCTION):
-    @echo "🏗️ Building single-architecture production Docker image..."
-    @echo "💡 Consider using 'make docker-buildx-production-local' for multi-arch support"
-    {{ cli }} build -f {{ source }} -t rustfs:latest .
-
-[group("🐳 Build Image")]
-docker-build-source cli=(DOCKER_CLI) source=(DOCKERFILE_SOURCE):
-    @echo "🏗️ Building single-architecture source Docker image..."
-    @echo "💡 Consider using 'make docker-dev-local' for multi-arch support"
-    {{ cli }} build -f {{ source }} -t rustfs:source .
-
-# ========================================================================================
-# Development Environment
-# ========================================================================================
-
-[group("🏃 Running")]
-dev-env-start cli=(DOCKER_CLI) source=(DOCKERFILE_SOURCE) container=(CONTAINER_NAME):
-    @echo "🚀 Starting development environment..."
-    {{ cli }} buildx build \
-    	--file {{ source }} \
-    	--tag rustfs:dev \
-    	--load \
-    	.
-    -{{ cli }} stop {{ container }} 2>/dev/null
-    -{{ cli }} rm {{ container }} 2>/dev/null
-    {{ cli }} run -d --name {{ container }} \
-    	-p 9010:9010 -p 9000:9000 \
-    	-v {{ invocation_directory() }}:/workspace \
-    	-it rustfs:dev
-
-[group("🏃 Running")]
-dev-env-stop cli=(DOCKER_CLI) container=(CONTAINER_NAME):
-    @echo "🛑 Stopping development environment..."
-    -{{ cli }} stop {{ container }} 2>/dev/null
-    -{{ cli }}  rm {{ container }} 2>/dev/null
-
-[group("🏃 Running")]
-dev-env-restart: dev-env-stop dev-env-start
-
-[group("👍 E2E")]
-e2e-server:
-    sh scripts/run.sh
-
-[group("👍 E2E")]
-probe-e2e:
-    sh scripts/probe.sh
-
-[doc("inspect one image")]
-[group("🚚 Other")]
-docker-inspect-multiarch image cli=(DOCKER_CLI):
-    @echo "🔍 Inspecting multi-architecture image: {{ image }}"
-    {{ cli }} buildx imagetools inspect {{ image }}

LICENSE

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2024 Beijing Henghesha Technology Co., Ltd. 
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

Makefile

@@ -1,376 +0,0 @@
-###########
-# Remote development requires VSCode with Dev Containers, Remote SSH, Remote Explorer
-# https://code.visualstudio.com/docs/remote/containers
-###########
-DOCKER_CLI ?= docker
-IMAGE_NAME ?= rustfs:v1.0.0
-CONTAINER_NAME ?= rustfs-dev
-# Docker build configurations
-DOCKERFILE_PRODUCTION = Dockerfile
-DOCKERFILE_SOURCE = Dockerfile.source
-
-# Code quality and formatting targets
-.PHONY: fmt
-fmt:
-	@echo "🔧 Formatting code..."
-	cargo fmt --all
-
-.PHONY: fmt-check
-fmt-check:
-	@echo "📝 Checking code formatting..."
-	cargo fmt --all --check
-
-.PHONY: clippy
-clippy:
-	@echo "🔍 Running clippy checks..."
-	cargo clippy --fix --allow-dirty
-	cargo clippy --all-targets --all-features -- -D warnings
-
-.PHONY: check
-check:
-	@echo "🔨 Running compilation check..."
-	cargo check --all-targets
-
-.PHONY: test
-test:
-	@echo "🧪 Running tests..."
-	@if command -v cargo-nextest >/dev/null 2>&1; then \
-		cargo nextest run --all --exclude e2e_test; \
-	else \
-		echo "ℹ️ cargo-nextest not found; falling back to 'cargo test'"; \
-		cargo test --workspace --exclude e2e_test -- --nocapture; \
-	fi
-	cargo test --all --doc
-
-.PHONY: pre-commit
-pre-commit: fmt clippy check test
-	@echo "✅ All pre-commit checks passed!"
-
-.PHONY: setup-hooks
-setup-hooks:
-	@echo "🔧 Setting up git hooks..."
-	chmod +x .git/hooks/pre-commit
-	@echo "✅ Git hooks setup complete!"
-
-.PHONY: e2e-server
-e2e-server:
-	sh $(shell pwd)/scripts/run.sh
-
-.PHONY: probe-e2e
-probe-e2e:
-	sh $(shell pwd)/scripts/probe.sh
-
-# Native build using build-rustfs.sh script
-.PHONY: build
-build:
-	@echo "🔨 Building RustFS using build-rustfs.sh script..."
-	./build-rustfs.sh
-
-.PHONY: build-dev
-build-dev:
-	@echo "🔨 Building RustFS in development mode..."
-	./build-rustfs.sh --dev
-
-# Docker-based build (alternative approach)
-# Usage: make BUILD_OS=ubuntu22.04 build-docker
-# Output: target/ubuntu22.04/release/rustfs
-BUILD_OS ?= rockylinux9.3
-.PHONY: build-docker
-build-docker: SOURCE_BUILD_IMAGE_NAME = rustfs-$(BUILD_OS):v1
-build-docker: SOURCE_BUILD_CONTAINER_NAME = rustfs-$(BUILD_OS)-build
-build-docker: BUILD_CMD = /root/.cargo/bin/cargo build --release --bin rustfs --target-dir /root/s3-rustfs/target/$(BUILD_OS)
-build-docker:
-	@echo "🐳 Building RustFS using Docker ($(BUILD_OS))..."
-	$(DOCKER_CLI) buildx build -t $(SOURCE_BUILD_IMAGE_NAME) -f $(DOCKERFILE_SOURCE) .
-	$(DOCKER_CLI) run --rm --name $(SOURCE_BUILD_CONTAINER_NAME) -v $(shell pwd):/root/s3-rustfs -it $(SOURCE_BUILD_IMAGE_NAME) $(BUILD_CMD)
-
-.PHONY: build-musl
-build-musl:
-	@echo "🔨 Building rustfs for x86_64-unknown-linux-musl..."
-	@echo "💡 On macOS/Windows, use 'make build-docker' or 'make docker-dev' instead"
-	./build-rustfs.sh --platform x86_64-unknown-linux-musl
-
-.PHONY: build-gnu
-build-gnu:
-	@echo "🔨 Building rustfs for x86_64-unknown-linux-gnu..."
-	@echo "💡 On macOS/Windows, use 'make build-docker' or 'make docker-dev' instead"
-	./build-rustfs.sh --platform x86_64-unknown-linux-gnu
-
-.PHONY: build-musl-arm64
-build-musl-arm64:
-	@echo "🔨 Building rustfs for aarch64-unknown-linux-musl..."
-	@echo "💡 On macOS/Windows, use 'make build-docker' or 'make docker-dev' instead"
-	./build-rustfs.sh --platform aarch64-unknown-linux-musl
-
-.PHONY: build-gnu-arm64
-build-gnu-arm64:
-	@echo "🔨 Building rustfs for aarch64-unknown-linux-gnu..."
-	@echo "💡 On macOS/Windows, use 'make build-docker' or 'make docker-dev' instead"
-	./build-rustfs.sh --platform aarch64-unknown-linux-gnu
-
-.PHONY: deploy-dev
-deploy-dev: build-musl
-	@echo "🚀 Deploying to dev server: $${IP}"
-	./scripts/dev_deploy.sh $${IP}
-
-# ========================================================================================
-# Docker Multi-Architecture Builds (Primary Methods)
-# ========================================================================================
-
-# Production builds using docker-buildx.sh (for CI/CD and production)
-.PHONY: docker-buildx
-docker-buildx:
-	@echo "🏗️ Building multi-architecture production Docker images with buildx..."
-	./docker-buildx.sh
-
-.PHONY: docker-buildx-push
-docker-buildx-push:
-	@echo "🚀 Building and pushing multi-architecture production Docker images with buildx..."
-	./docker-buildx.sh --push
-
-.PHONY: docker-buildx-version
-docker-buildx-version:
-	@if [ -z "$(VERSION)" ]; then \
-		echo "❌ Error: Please specify version, example: make docker-buildx-version VERSION=v1.0.0"; \
-		exit 1; \
-	fi
-	@echo "🏗️ Building multi-architecture production Docker images (version: $(VERSION))..."
-	./docker-buildx.sh --release $(VERSION)
-
-.PHONY: docker-buildx-push-version
-docker-buildx-push-version:
-	@if [ -z "$(VERSION)" ]; then \
-		echo "❌ Error: Please specify version, example: make docker-buildx-push-version VERSION=v1.0.0"; \
-		exit 1; \
-	fi
-	@echo "🚀 Building and pushing multi-architecture production Docker images (version: $(VERSION))..."
-	./docker-buildx.sh --release $(VERSION) --push
-
-# Development/Source builds using direct buildx commands
-.PHONY: docker-dev
-docker-dev:
-	@echo "🏗️ Building multi-architecture development Docker images with buildx..."
-	@echo "💡 This builds from source code and is intended for local development and testing"
-	@echo "⚠️  Multi-arch images cannot be loaded locally, use docker-dev-push to push to registry"
-	$(DOCKER_CLI) buildx build \
-		--platform linux/amd64,linux/arm64 \
-		--file $(DOCKERFILE_SOURCE) \
-		--tag rustfs:source-latest \
-		--tag rustfs:dev-latest \
-		.
-
-.PHONY: docker-dev-local
-docker-dev-local:
-	@echo "🏗️ Building single-architecture development Docker image for local use..."
-	@echo "💡 This builds from source code for the current platform and loads locally"
-	$(DOCKER_CLI) buildx build \
-		--file $(DOCKERFILE_SOURCE) \
-		--tag rustfs:source-latest \
-		--tag rustfs:dev-latest \
-		--load \
-		.
-
-.PHONY: docker-dev-push
-docker-dev-push:
-	@if [ -z "$(REGISTRY)" ]; then \
-		echo "❌ Error: Please specify registry, example: make docker-dev-push REGISTRY=ghcr.io/username"; \
-		exit 1; \
-	fi
-	@echo "🚀 Building and pushing multi-architecture development Docker images..."
-	@echo "💡 Pushing to registry: $(REGISTRY)"
-	$(DOCKER_CLI) buildx build \
-		--platform linux/amd64,linux/arm64 \
-		--file $(DOCKERFILE_SOURCE) \
-		--tag $(REGISTRY)/rustfs:source-latest \
-		--tag $(REGISTRY)/rustfs:dev-latest \
-		--push \
-		.
-
-
-
-# Local production builds using direct buildx (alternative to docker-buildx.sh)
-.PHONY: docker-buildx-production-local
-docker-buildx-production-local:
-	@echo "🏗️ Building single-architecture production Docker image locally..."
-	@echo "💡 Alternative to docker-buildx.sh for local testing"
-	$(DOCKER_CLI) buildx build \
-		--file $(DOCKERFILE_PRODUCTION) \
-		--tag rustfs:production-latest \
-		--tag rustfs:latest \
-		--load \
-		--build-arg RELEASE=latest \
-		.
-
-# ========================================================================================
-# Single Architecture Docker Builds (Traditional)
-# ========================================================================================
-
-.PHONY: docker-build-production
-docker-build-production:
-	@echo "🏗️ Building single-architecture production Docker image..."
-	@echo "💡 Consider using 'make docker-buildx-production-local' for multi-arch support"
-	$(DOCKER_CLI) build -f $(DOCKERFILE_PRODUCTION) -t rustfs:latest .
-
-.PHONY: docker-build-source
-docker-build-source:
-	@echo "🏗️ Building single-architecture source Docker image..."
-	@echo "💡 Consider using 'make docker-dev-local' for multi-arch support"
-	DOCKER_BUILDKIT=1 $(DOCKER_CLI) build \
-		--build-arg BUILDKIT_INLINE_CACHE=1 \
-		-f $(DOCKERFILE_SOURCE) -t rustfs:source .
-
-# ========================================================================================
-# Development Environment
-# ========================================================================================
-
-.PHONY: dev-env-start
-dev-env-start:
-	@echo "🚀 Starting development environment..."
-	$(DOCKER_CLI) buildx build \
-		--file $(DOCKERFILE_SOURCE) \
-		--tag rustfs:dev \
-		--load \
-		.
-	$(DOCKER_CLI) stop $(CONTAINER_NAME) 2>/dev/null || true
-	$(DOCKER_CLI) rm $(CONTAINER_NAME) 2>/dev/null || true
-	$(DOCKER_CLI) run -d --name $(CONTAINER_NAME) \
-		-p 9010:9010 -p 9000:9000 \
-		-v $(shell pwd):/workspace \
-		-it rustfs:dev
-
-.PHONY: dev-env-stop
-dev-env-stop:
-	@echo "🛑 Stopping development environment..."
-	$(DOCKER_CLI) stop $(CONTAINER_NAME) 2>/dev/null || true
-	$(DOCKER_CLI) rm $(CONTAINER_NAME) 2>/dev/null || true
-
-.PHONY: dev-env-restart
-dev-env-restart: dev-env-stop dev-env-start
-
-
-
-# ========================================================================================
-# Build Utilities
-# ========================================================================================
-
-.PHONY: docker-inspect-multiarch
-docker-inspect-multiarch:
-	@if [ -z "$(IMAGE)" ]; then \
-		echo "❌ Error: Please specify image, example: 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..."
-	@echo "💡 On macOS/Windows, use 'make docker-dev' for reliable multi-arch builds"
-	@echo "🔨 Generating protobuf code..."
-	cargo run --bin gproto || true
-	@echo "🔨 Building x86_64-unknown-linux-gnu..."
-	./build-rustfs.sh --platform x86_64-unknown-linux-gnu
-	@echo "🔨 Building aarch64-unknown-linux-gnu..."
-	./build-rustfs.sh --platform aarch64-unknown-linux-gnu
-	@echo "🔨 Building x86_64-unknown-linux-musl..."
-	./build-rustfs.sh --platform x86_64-unknown-linux-musl
-	@echo "🔨 Building aarch64-unknown-linux-musl..."
-	./build-rustfs.sh --platform aarch64-unknown-linux-musl
-	@echo "✅ All architectures built successfully!"
-
-# ========================================================================================
-# Help and Documentation
-# ========================================================================================
-
-.PHONY: help-build
-help-build:
-	@echo "🔨 RustFS Build Help:"
-	@echo ""
-	@echo "🚀 Local Build (Recommended):"
-	@echo "  make build                               # Build RustFS binary (includes console by default)"
-	@echo "  make build-dev                           # Development mode build"
-	@echo "  make build-musl                          # Build x86_64 musl version"
-	@echo "  make build-gnu                           # Build x86_64 GNU version"
-	@echo "  make build-musl-arm64                    # Build aarch64 musl version"
-	@echo "  make build-gnu-arm64                     # Build aarch64 GNU version"
-	@echo ""
-	@echo "🐳 Docker Build:"
-	@echo "  make build-docker                        # Build using Docker container"
-	@echo "  make build-docker BUILD_OS=ubuntu22.04   # Specify build system"
-	@echo ""
-	@echo "🏗️ Cross-architecture Build:"
-	@echo "  make build-cross-all                     # Build binaries for all architectures"
-	@echo ""
-	@echo "🔧 Direct usage of build-rustfs.sh script:"
-	@echo "  ./build-rustfs.sh --help                 # View script help"
-	@echo "  ./build-rustfs.sh --no-console           # Build without console resources"
-	@echo "  ./build-rustfs.sh --force-console-update # Force update console resources"
-	@echo "  ./build-rustfs.sh --dev                  # Development mode build"
-	@echo "  ./build-rustfs.sh --sign                 # Sign binary files"
-	@echo "  ./build-rustfs.sh --platform x86_64-unknown-linux-gnu   # Specify target platform"
-	@echo "  ./build-rustfs.sh --skip-verification    # Skip binary verification"
-	@echo ""
-	@echo "💡 build-rustfs.sh script provides more options, smart detection and binary verification"
-
-.PHONY: help-docker
-help-docker:
-	@echo "🐳 Docker Multi-architecture Build Help:"
-	@echo ""
-	@echo "🚀 Production Image Build (Recommended to use docker-buildx.sh):"
-	@echo "  make docker-buildx                       # Build production multi-arch image (no push)"
-	@echo "  make docker-buildx-push                  # Build and push production multi-arch image"
-	@echo "  make docker-buildx-version VERSION=v1.0.0        # Build specific version"
-	@echo "  make docker-buildx-push-version VERSION=v1.0.0   # Build and push specific version"
-	@echo ""
-	@echo "🔧 Development/Source Image Build (Local development testing):"
-	@echo "  make docker-dev                          # Build dev multi-arch image (cannot load locally)"
-	@echo "  make docker-dev-local                    # Build dev single-arch image (local load)"
-	@echo "  make docker-dev-push REGISTRY=xxx       # Build and push dev image"
-	@echo ""
-	@echo "🏗️ Local Production Image Build (Alternative):"
-	@echo "  make docker-buildx-production-local      # Build production single-arch image locally"
-	@echo ""
-	@echo "📦 Single-architecture Build (Traditional way):"
-	@echo "  make docker-build-production             # Build single-arch production image"
-	@echo "  make docker-build-source                 # Build single-arch source image"
-	@echo ""
-	@echo "🚀 Development Environment Management:"
-	@echo "  make dev-env-start                       # Start development container environment"
-	@echo "  make dev-env-stop                        # Stop development container environment"
-	@echo "  make dev-env-restart                     # Restart development container environment"
-	@echo ""
-	@echo "🔧 Auxiliary Tools:"
-	@echo "  make build-cross-all                     # Build binaries for all architectures"
-	@echo "  make docker-inspect-multiarch IMAGE=xxx  # Check image architecture support"
-	@echo ""
-	@echo "📋 Environment Variables:"
-	@echo "  REGISTRY          Image registry address (required for push)"
-	@echo "  DOCKERHUB_USERNAME    Docker Hub username"
-	@echo "  DOCKERHUB_TOKEN       Docker Hub access token"
-	@echo "  GITHUB_TOKEN          GitHub access token"
-	@echo ""
-	@echo "💡 Suggestions:"
-	@echo "  - Production use: Use docker-buildx* commands (based on precompiled binaries)"
-	@echo "  - Local development: Use docker-dev* commands (build from source)"
-	@echo "  - Development environment: Use dev-env-* commands to manage dev containers"
-
-.PHONY: help
-help:
-	@echo "🦀 RustFS Makefile Help:"
-	@echo ""
-	@echo "📋 Main Command Categories:"
-	@echo "  make help-build                          # Show build-related help"
-	@echo "  make help-docker                         # Show Docker-related help"
-	@echo ""
-	@echo "🔧 Code Quality:"
-	@echo "  make fmt                                 # Format code"
-	@echo "  make clippy                              # Run clippy checks"
-	@echo "  make test                                # Run tests"
-	@echo "  make pre-commit                          # Run all pre-commit checks"
-	@echo ""
-	@echo "🚀 Quick Start:"
-	@echo "  make build                               # Build RustFS binary"
-	@echo "  make docker-dev-local                    # Build development Docker image (local)"
-	@echo "  make dev-env-start                       # Start development environment"
-	@echo ""
-	@echo "💡 For more help use 'make help-build' or 'make help-docker'"

README.md

@@ -1,169 +0,0 @@
-[![RustFS](https://rustfs.com/images/rustfs-github.png)](https://rustfs.com)
-
-<p align="center">RustFS is a high-performance distributed object storage software built using Rust</p>
-
-<p align="center">
-  <a href="https://github.com/rustfs/rustfs/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/rustfs/rustfs/actions/workflows/ci.yml/badge.svg" /></a>
-  <a href="https://github.com/rustfs/rustfs/actions/workflows/docker.yml"><img alt="Build and Push Docker Images" src="https://github.com/rustfs/rustfs/actions/workflows/docker.yml/badge.svg" /></a>
-  <img alt="GitHub commit activity" src="https://img.shields.io/github/commit-activity/m/rustfs/rustfs"/>
-  <img alt="Github Last Commit" src="https://img.shields.io/github/last-commit/rustfs/rustfs"/>
-  <a href="https://hellogithub.com/repository/rustfs/rustfs" target="_blank"><img src="https://abroad.hellogithub.com/v1/widgets/recommend.svg?rid=b95bcb72bdc340b68f16fdf6790b7d5b&claim_uid=MsbvjYeLDKAH457&theme=small" alt="Featured｜HelloGitHub" /></a>
-</p>
-
-<p align="center">
-  <a href="https://docs.rustfs.com/introduction.html">Getting Started</a>
-  · <a href="https://docs.rustfs.com/">Docs</a>
-  · <a href="https://github.com/rustfs/rustfs/issues">Bug reports</a>
-  · <a href="https://github.com/rustfs/rustfs/discussions">Discussions</a>
-</p>
-
-<p align="center">
-English | <a href="https://github.com/rustfs/rustfs/blob/main/README_ZH.md">简体中文</a> |
-  <!-- Keep these links. Translations will automatically update with the README. -->
-  <a href="https://readme-i18n.com/rustfs/rustfs?lang=de">Deutsch</a> |
-  <a href="https://readme-i18n.com/rustfs/rustfs?lang=es">Español</a> |
-  <a href="https://readme-i18n.com/rustfs/rustfs?lang=fr">français</a> |
-  <a href="https://readme-i18n.com/rustfs/rustfs?lang=ja">日本語</a> |
-  <a href="https://readme-i18n.com/rustfs/rustfs?lang=ko">한국어</a> |
-  <a href="https://readme-i18n.com/rustfs/rustfs?lang=pt">Português</a> |
-  <a href="https://readme-i18n.com/rustfs/rustfs?lang=ru">Русский</a>
-</p>
-
-RustFS is a high-performance distributed object storage software built using Rust, one of the most popular languages worldwide. Along with MinIO, it shares a range of advantages such as simplicity, S3 compatibility, open-source nature, support for data lakes, AI, and big data. Furthermore, it has a better and more user-friendly open-source license in comparison to other storage systems, being constructed under the Apache license. As Rust serves as its foundation, RustFS provides faster speed and safer distributed features for high-performance object storage.
-
-> ⚠️ **RustFS is under rapid development. Do NOT use in production environments!**
-
-## Features
-
-- **High Performance**: Built with Rust, ensuring speed and efficiency.
-- **Distributed Architecture**: Scalable and fault-tolerant design for large-scale deployments.
-- **S3 Compatibility**: Seamless integration with existing S3-compatible applications.
-- **Data Lake Support**: Optimized for big data and AI workloads.
-- **Open Source**: Licensed under Apache 2.0, encouraging community contributions and transparency.
-- **User-Friendly**: Designed with simplicity in mind, making it easy to deploy and manage.
-
-## RustFS vs MinIO
-
-Stress test server parameters
-
-|  Type  |  parameter   | Remark |
-| - | - | - |
-|CPU | 2 Core | Intel Xeon(Sapphire Rapids) Platinum 8475B , 2.7/3.2 GHz|   |
-|Memory| 4GB |     |
-|Network | 15Gbp |      |
-|Driver  | 40GB x 4 |   IOPS 3800 / Driver |
-
-<https://github.com/user-attachments/assets/2e4979b5-260c-4f2c-ac12-c87fd558072a>
-
-### RustFS vs Other object storage
-
-| RustFS | Other object storage|
-| - | - |
-| Powerful Console | Simple and useless Console |
-| Developed based on Rust language, memory is safer | Developed in Go or C, with potential issues like memory GC/leaks |
-| Does not report logs to third-party countries  | Reporting logs to other third countries may violate national security laws |
-| Licensed under Apache, more business-friendly  | AGPL V3 License and other License, polluted open source and License traps, infringement of intellectual property rights |
-| Comprehensive S3 support, works with domestic and international cloud providers  | Full support for S3, but no local cloud vendor support |
-| Rust-based development, strong support for secure and innovative devices  | Poor support for edge gateways and secure innovative devices|
-| Stable commercial prices, free community support | High pricing, with costs up to $250,000 for 1PiB |
-| No risk | Intellectual property risks and risks of prohibited uses |
-
-## Quickstart
-
-To get started with RustFS, follow these steps:
-
-1. **One-click installation script (Option 1)​​**
-
-   ```bash
-   curl -O  https://rustfs.com/install_rustfs.sh && bash install_rustfs.sh
-   ```
-
-2. **Docker Quick Start (Option 2)​​**
-
-  ```bash
-   # create data and logs directories
-   mkdir -p data logs
-
-   # using latest alpha version
-   docker run -d -p 9000:9000 -v $(pwd)/data:/data -v $(pwd)/logs:/logs rustfs/rustfs:alpha
-
-   # Specific version
-   docker run -d -p 9000:9000 -v $(pwd)/data:/data -v $(pwd)/logs:/logs rustfs/rustfs:1.0.0.alpha.45
-   ```
-
-3. **Build from Source (Option 3) - Advanced Users**
-
-   For developers who want to build RustFS Docker images from source with multi-architecture support:
-
-   ```bash
-   # Build multi-architecture images locally
-   ./docker-buildx.sh --build-arg RELEASE=latest
-
-   # Build and push to registry
-   ./docker-buildx.sh --push
-
-   # Build specific version
-   ./docker-buildx.sh --release v1.0.0 --push
-
-   # Build for custom registry
-   ./docker-buildx.sh --registry your-registry.com --namespace yourname --push
-   ```
-
-   The `docker-buildx.sh` script supports:
-   - **Multi-architecture builds**: `linux/amd64`, `linux/arm64`
-   - **Automatic version detection**: Uses git tags or commit hashes
-   - **Registry flexibility**: Supports Docker Hub, GitHub Container Registry, etc.
-   - **Build optimization**: Includes caching and parallel builds
-
-   You can also use Make targets for convenience:
-
-   ```bash
-   make docker-buildx                    # Build locally
-   make docker-buildx-push               # Build and push
-   make docker-buildx-version VERSION=v1.0.0  # Build specific version
-   make help-docker                      # Show all Docker-related commands
-   ```
-
-4. **Access the Console**: Open your web browser and navigate to `http://localhost:9000` to access the RustFS console, default username and password is `rustfsadmin` .
-5. **Create a Bucket**: Use the console to create a new bucket for your objects.
-6. **Upload Objects**: You can upload files directly through the console or use S3-compatible APIs to interact with your RustFS instance.
-
-## Documentation
-
-For detailed documentation, including configuration options, API references, and advanced usage, please visit our [Documentation](https://docs.rustfs.com).
-
-## Getting Help
-
-If you have any questions or need assistance, you can:
-
-- Check the [FAQ](https://github.com/rustfs/rustfs/discussions/categories/q-a) for common issues and solutions.
-- Join our [GitHub Discussions](https://github.com/rustfs/rustfs/discussions) to ask questions and share your experiences.
-- Open an issue on our [GitHub Issues](https://github.com/rustfs/rustfs/issues) page for bug reports or feature requests.
-
-## Links
-
-- [Documentation](https://docs.rustfs.com) - The manual you should read
-- [Changelog](https://github.com/rustfs/rustfs/releases) - What we broke and fixed
-- [GitHub Discussions](https://github.com/rustfs/rustfs/discussions) - Where the community lives
-
-## Contact
-
-- **Bugs**: [GitHub Issues](https://github.com/rustfs/rustfs/issues)
-- **Business**: <hello@rustfs.com>
-- **Jobs**: <jobs@rustfs.com>
-- **General Discussion**: [GitHub Discussions](https://github.com/rustfs/rustfs/discussions)
-- **Contributing**: [CONTRIBUTING.md](CONTRIBUTING.md)
-
-## Contributors
-
-RustFS is a community-driven project, and we appreciate all contributions. Check out the [Contributors](https://github.com/rustfs/rustfs/graphs/contributors) page to see the amazing people who have helped make RustFS better.
-
-<a href="https://github.com/rustfs/rustfs/graphs/contributors">
-  <img src="https://opencollective.com/rustfs/contributors.svg?width=890&limit=500&button=false" />
-</a>
-
-## License
-
-[Apache 2.0](https://opensource.org/licenses/Apache-2.0)
-
-**RustFS** is a trademark of RustFS, Inc. All other trademarks are the property of their respective owners.

README_ZH.md

@@ -1,119 +0,0 @@
-[![RustFS](https://rustfs.com/images/rustfs-github.png)](https://rustfs.com)
-
-<p align="center">RustFS 是一个使用 Rust 构建的高性能分布式对象存储软件</p >
-
-<p align="center">
-  <a href="https://github.com/rustfs/rustfs/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/rustfs/rustfs/actions/workflows/ci.yml/badge.svg" /></a>
-  <a href="https://github.com/rustfs/rustfs/actions/workflows/docker.yml"><img alt="Build and Push Docker Images" src="https://github.com/rustfs/rustfs/actions/workflows/docker.yml/badge.svg" /></a>
-  <img alt="GitHub commit activity" src="https://img.shields.io/github/commit-activity/m/rustfs/rustfs"/>
-  <img alt="Github Last Commit" src="https://img.shields.io/github/last-commit/rustfs/rustfs"/>
-  <a href="https://hellogithub.com/repository/rustfs/rustfs" target="_blank"><img src="https://abroad.hellogithub.com/v1/widgets/recommend.svg?rid=b95bcb72bdc340b68f16fdf6790b7d5b&claim_uid=MsbvjYeLDKAH457&theme=small" alt="Featured｜HelloGitHub" /></a>
-</p >
-
-<p align="center">
-  <a href="https://docs.rustfs.com/zh/introduction.html">快速开始</a >
-  · <a href="https://docs.rustfs.com/zh/">文档</a >
-  · <a href="https://github.com/rustfs/rustfs/issues">问题报告</a >
-  · <a href="https://github.com/rustfs/rustfs/discussions">讨论</a >
-</p >
-
-<p align="center">
-<a href="https://github.com/rustfs/rustfs/blob/main/README.md">English</a > | 简体中文
-</p >
-
-RustFS 是一个使用 Rust（全球最受欢迎的编程语言之一）构建的高性能分布式对象存储软件。与 MinIO 一样，它具有简单性、S3 兼容性、开源特性以及对数据湖、AI 和大数据的支持等一系列优势。此外，与其他存储系统相比，它采用 Apache 许可证构建，拥有更好、更用户友好的开源许可证。由于以 Rust 为基础，RustFS 为高性能对象存储提供了更快的速度和更安全的分布式功能。
-
-## 特性
-
-- **高性能**：使用 Rust 构建，确保速度和效率。
-- **分布式架构**：可扩展且容错的设计，适用于大规模部署。
-- **S3 兼容性**：与现有 S3 兼容应用程序无缝集成。
-- **数据湖支持**：针对大数据和 AI 工作负载进行了优化。
-- **开源**：采用 Apache 2.0 许可证，鼓励社区贡献和透明度。
-- **用户友好**：设计简单，易于部署和管理。
-
-## RustFS vs MinIO
-
-压力测试服务器参数
-
-|  类型  |  参数   | 备注 |
-| - | - | - |
-|CPU | 2 核心 | Intel Xeon(Sapphire Rapids) Platinum 8475B , 2.7/3.2 GHz|   |
-|内存| 4GB |     |
-|网络 | 15Gbp |      |
-|驱动器  | 40GB x 4 |   IOPS 3800 / 驱动器 |
-
-<https://github.com/user-attachments/assets/2e4979b5-260c-4f2c-ac12-c87fd558072a>
-
-### RustFS vs 其他对象存储
-
-| RustFS | 其他对象存储|
-| - | - |
-| 强大的控制台 | 简单且无用的控制台 |
-| 基于 Rust 语言开发，内存更安全 | 使用 Go 或 C 开发，存在内存 GC/泄漏等潜在问题 |
-| 不向第三方国家报告日志  | 向其他第三方国家报告日志可能违反国家安全法律 |
-| 采用 Apache 许可证，对商业更友好  | AGPL V3 许可证等其他许可证，污染开源和许可证陷阱，侵犯知识产权 |
-| 全面的 S3 支持，适用于国内外云提供商  | 完全支持 S3，但不支持本地云厂商 |
-| 基于 Rust 开发，对安全和创新设备有强大支持  | 对边缘网关和安全创新设备支持较差|
-| 稳定的商业价格，免费社区支持 | 高昂的定价，1PiB 成本高达 $250,000 |
-| 无风险 | 知识产权风险和禁止使用的风险 |
-
-## 快速开始
-
-要开始使用 RustFS，请按照以下步骤操作：
-
-1. **一键脚本快速启动 (方案一)**
-
-   ```bash
-   curl -O  https://rustfs.com/install_rustfs.sh && bash install_rustfs.sh
-   ```
-
-2. **Docker快速启动（方案二）**
-
-  ```bash
-   docker run -d -p 9000:9000  -v /data:/data rustfs/rustfs
-   ```
-
-3. **访问控制台**：打开 Web 浏览器并导航到 `http://localhost:9000` 以访问 RustFS 控制台，默认的用户名和密码是 `rustfsadmin` 。
-4. **创建存储桶**：使用控制台为您的对象创建新的存储桶。
-5. **上传对象**：您可以直接通过控制台上传文件，或使用 S3 兼容的 API 与您的 RustFS 实例交互。
-
-## 文档
-
-有关详细文档，包括配置选项、API 参考和高级用法，请访问我们的[文档](https://docs.rustfs.com)。
-
-## 获取帮助
-
-如果您有任何问题或需要帮助，您可以：
-
-- 查看[常见问题解答](https://github.com/rustfs/rustfs/discussions/categories/q-a)以获取常见问题和解决方案。
-- 加入我们的 [GitHub 讨论](https://github.com/rustfs/rustfs/discussions)来提问和分享您的经验。
-- 在我们的 [GitHub Issues](https://github.com/rustfs/rustfs/issues) 页面上开启问题，报告错误或功能请求。
-
-## 链接
-
-- [文档](https://docs.rustfs.com) - 您应该阅读的手册
-- [更新日志](https://docs.rustfs.com/changelog) - 我们破坏和修复的内容
-- [GitHub 讨论](https://github.com/rustfs/rustfs/discussions) - 社区所在地
-
-## 联系
-
-- **错误报告**：[GitHub Issues](https://github.com/rustfs/rustfs/issues)
-- **商务合作**：<hello@rustfs.com>
-- **招聘**：<jobs@rustfs.com>
-- **一般讨论**：[GitHub 讨论](https://github.com/rustfs/rustfs/discussions)
-- **贡献**：[CONTRIBUTING.md](CONTRIBUTING.md)
-
-## 贡献者
-
-RustFS 是一个社区驱动的项目，我们感谢所有的贡献。查看[贡献者](https://github.com/rustfs/rustfs/graphs/contributors)页面，了解帮助 RustFS 变得更好的杰出人员。
-
-<a href="https://github.com/rustfs/rustfs/graphs/contributors">
-  <img src="https://opencollective.com/rustfs/contributors.svg?width=890&limit=500&button=false" />
-</a >
-
-## 许可证
-
-[Apache 2.0](https://opensource.org/licenses/Apache-2.0)
-
-**RustFS** 是 RustFS, Inc. 的商标。所有其他商标均为其各自所有者的财产。

SECURITY.md

@@ -1,18 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-Use this section to tell people about which versions of your project are
-currently being supported with security updates.
-
-| Version | Supported          |
-| ------- | ------------------ |
-| 1.x.x   | :white_check_mark: |
-
-## Reporting a Vulnerability
-
-Use this section to tell people how to report a vulnerability.
-
-Tell them where to go, how often they can expect to get an update on a
-reported vulnerability, what to expect if the vulnerability is accepted or
-declined, etc.

_typos.toml

@@ -1,41 +0,0 @@
-[default]
-# # Ignore specific spell checking patterns
-# extend-ignore-identifiers-re = [
-#     # Ignore common patterns in base64 encoding and hash values
-#     "[A-Za-z0-9+/]{8,}={0,2}",  # base64 encoding
-#     "[A-Fa-f0-9]{8,}",          # hexadecimal hash
-#     "[A-Za-z0-9_-]{20,}",       # long random strings
-# ]
-
-# # Ignore specific regex patterns in content
-# extend-ignore-re = [
-#     # Ignore hash values and encoded strings (base64 patterns)
-#     "(?i)[A-Za-z0-9+/]{8,}={0,2}",
-#     # Ignore long strings in quotes (usually hash or base64)
-#     '"[A-Za-z0-9+/=_-]{8,}"',
-#     # Ignore IV values and similar cryptographic strings
-#     '"[A-Za-z0-9+/=]{12,}"',
-#     # Ignore cryptographic signatures and keys (including partial strings)
-#     "[A-Za-z0-9+/]{6,}[A-Za-z0-9+/=]*",
-#     # Ignore base64-like strings in comments (common in examples)
-#     "//.*[A-Za-z0-9+/]{8,}[A-Za-z0-9+/=]*",
-# ]
-extend-ignore-re = [
-    # Ignore long strings in quotes (usually hash or base64)
-    '"[A-Za-z0-9+/=_-]{32,}"',
-    # Ignore IV values and similar cryptographic strings
-    '"[A-Za-z0-9+/=]{12,}"',
-    # Ignore cryptographic signatures and keys (including partial strings)
-    "[A-Za-z0-9+/]{16,}[A-Za-z0-9+/=]*",
-]
-
-[default.extend-words]
-bui = "bui"
-typ = "typ"
-clen = "clen"
-datas = "datas"
-bre = "bre"
-abd = "abd"
-
-[files]
-extend-exclude = []

build-rustfs.sh

@@ -1,579 +0,0 @@
-#!/bin/bash
-
-# RustFS Binary Build Script
-# This script compiles RustFS binaries for different platforms and architectures
-
-set -e
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Auto-detect current platform
-detect_platform() {
-    local arch=$(uname -m)
-    local os=$(uname -s | tr '[:upper:]' '[:lower:]')
-
-    case "$os" in
-        "linux")
-            case "$arch" in
-                "x86_64")
-                    # Default to GNU for better compatibility
-                    echo "x86_64-unknown-linux-gnu"
-                    ;;
-                "aarch64"|"arm64")
-                    echo "aarch64-unknown-linux-gnu"
-                    ;;
-                "armv7l")
-                    echo "armv7-unknown-linux-gnueabihf"
-                    ;;
-                "loongarch64")
-                    echo "loongarch64-unknown-linux-musl"
-                    ;;
-                *)
-                    echo "unknown-platform"
-                    ;;
-            esac
-            ;;
-        "darwin")
-            case "$arch" in
-                "x86_64")
-                    echo "x86_64-apple-darwin"
-                    ;;
-                "arm64"|"aarch64")
-                    echo "aarch64-apple-darwin"
-                    ;;
-                *)
-                    echo "unknown-platform"
-                    ;;
-            esac
-            ;;
-        *)
-            echo "unknown-platform"
-            ;;
-    esac
-}
-
-# Cross-platform SHA256 checksum generation
-generate_sha256() {
-    local file="$1"
-    local output_file="$2"
-    local os=$(uname -s | tr '[:upper:]' '[:lower:]')
-
-    case "$os" in
-        "linux")
-            if command -v sha256sum &> /dev/null; then
-                sha256sum "$file" > "$output_file"
-            elif command -v shasum &> /dev/null; then
-                shasum -a 256 "$file" > "$output_file"
-            else
-                print_message $RED "❌ No SHA256 command found (sha256sum or shasum)"
-                return 1
-            fi
-            ;;
-        "darwin")
-            if command -v shasum &> /dev/null; then
-                shasum -a 256 "$file" > "$output_file"
-            elif command -v sha256sum &> /dev/null; then
-                sha256sum "$file" > "$output_file"
-            else
-                print_message $RED "❌ No SHA256 command found (shasum or sha256sum)"
-                return 1
-            fi
-            ;;
-        *)
-            # Try common commands in order
-            if command -v sha256sum &> /dev/null; then
-                sha256sum "$file" > "$output_file"
-            elif command -v shasum &> /dev/null; then
-                shasum -a 256 "$file" > "$output_file"
-            else
-                print_message $RED "❌ No SHA256 command found"
-                return 1
-            fi
-            ;;
-    esac
-}
-
-# Default values
-OUTPUT_DIR="target/release"
-PLATFORM=$(detect_platform)  # Auto-detect current platform
-BINARY_NAME="rustfs"
-BUILD_TYPE="release"
-SIGN=false
-WITH_CONSOLE=true
-FORCE_CONSOLE_UPDATE=false
-CONSOLE_VERSION="latest"
-SKIP_VERIFICATION=false
-CUSTOM_PLATFORM=""
-
-# Print usage
-usage() {
-    echo "Usage: $0 [OPTIONS]"
-    echo ""
-    echo "Description:"
-    echo "  Build RustFS binary for the current platform. Designed for CI/CD pipelines"
-    echo "  where different runners build platform-specific binaries natively."
-    echo "  Includes automatic verification to ensure the built binary is functional."
-    echo ""
-    echo "Options:"
-    echo "  -o, --output-dir DIR       Output directory (default: target/release)"
-    echo "  -b, --binary-name NAME     Binary name (default: rustfs)"
-    echo "  -p, --platform TARGET      Target platform (default: auto-detect)"
-    echo "                              Supported platforms:"
-    echo "                                x86_64-unknown-linux-gnu"
-    echo "                                aarch64-unknown-linux-gnu"
-    echo "                                armv7-unknown-linux-gnueabihf"
-    echo "                                x86_64-unknown-linux-musl"
-    echo "                                aarch64-unknown-linux-musl"
-    echo "                                armv7-unknown-linux-musleabihf"
-    echo "                                x86_64-apple-darwin"
-    echo "                                aarch64-apple-darwin"
-    echo "                                x86_64-pc-windows-msvc"
-    echo "                                aarch64-pc-windows-msvc"
-    echo "  --dev                      Build in dev mode"
-    echo "  --sign                     Sign binaries after build"
-    echo "  --with-console             Download console static assets (default)"
-    echo "  --no-console               Skip console static assets"
-    echo "  --force-console-update     Force update console assets even if they exist"
-    echo "  --console-version VERSION  Console version to download (default: latest)"
-    echo "  --skip-verification        Skip binary verification after build"
-    echo "  -h, --help                 Show this help message"
-    echo ""
-    echo "Examples:"
-    echo "  $0                         # Build for current platform (includes console assets)"
-    echo "  $0 --dev                   # Development build"
-    echo "  $0 --sign                  # Build and sign binary (release CI)"
-    echo "  $0 --no-console            # Build without console static assets"
-    echo "  $0 --force-console-update  # Force update console assets"
-    echo "  $0 --platform x86_64-unknown-linux-musl  # Build for specific platform"
-    echo "  $0 --skip-verification     # Skip binary verification (for cross-compilation)"
-    echo ""
-    echo "Detected platform: $(detect_platform)"
-    echo "CI Usage: Run this script on each platform's runner to build native binaries"
-}
-
-# Print colored message
-print_message() {
-    local color=$1
-    local message=$2
-    echo -e "${color}${message}${NC}"
-}
-
-# Get version from git
-get_version() {
-    if git describe --abbrev=0 --tags >/dev/null 2>&1; then
-        git describe --abbrev=0 --tags
-    else
-        git rev-parse --short HEAD
-    fi
-}
-
-# Setup rust environment
-setup_rust_environment() {
-    print_message $BLUE "🔧 Setting up Rust environment..."
-
-    # Install required target for current platform
-    print_message $YELLOW "Installing target: $PLATFORM"
-    rustup target add "$PLATFORM"
-
-    # Set up environment variables for musl targets
-    if [[ "$PLATFORM" == *"musl"* ]]; then
-        print_message $YELLOW "Setting up environment for musl target..."
-        export RUSTFLAGS="-C target-feature=-crt-static"
-
-        # For cargo-zigbuild, set up additional environment variables
-        if command -v cargo-zigbuild &> /dev/null; then
-            print_message $YELLOW "Configuring cargo-zigbuild for musl target..."
-
-            # Set environment variables for better musl support
-            export CC_x86_64_unknown_linux_musl="zig cc -target x86_64-linux-musl"
-            export CXX_x86_64_unknown_linux_musl="zig c++ -target x86_64-linux-musl"
-            export AR_x86_64_unknown_linux_musl="zig ar"
-            export CARGO_TARGET_X86_64_UNKNOWN_LINUX_MUSL_LINKER="zig cc -target x86_64-linux-musl"
-
-            export CC_aarch64_unknown_linux_musl="zig cc -target aarch64-linux-musl"
-            export CXX_aarch64_unknown_linux_musl="zig c++ -target aarch64-linux-musl"
-            export AR_aarch64_unknown_linux_musl="zig ar"
-            export CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_LINKER="zig cc -target aarch64-linux-musl"
-
-            # Set environment variables for zstd-sys to avoid target parsing issues
-            export ZSTD_SYS_USE_PKG_CONFIG=1
-            export PKG_CONFIG_ALLOW_CROSS=1
-        fi
-    fi
-
-    # Install required tools
-    if [ "$SIGN" = true ]; then
-        if ! command -v minisign &> /dev/null; then
-            print_message $YELLOW "Installing minisign for binary signing..."
-            cargo install minisign
-        fi
-    fi
-}
-
-# Download console static assets
-download_console_assets() {
-    local static_dir="rustfs/static"
-    local console_exists=false
-
-    # Check if console assets already exist
-    if [ -d "$static_dir" ] && [ -f "$static_dir/index.html" ]; then
-        console_exists=true
-        local static_size=$(du -sh "$static_dir" 2>/dev/null | cut -f1 || echo "unknown")
-        print_message $YELLOW "Console static assets already exist ($static_size)"
-    fi
-
-    # Determine if we need to download
-    local should_download=false
-    if [ "$WITH_CONSOLE" = true ]; then
-        if [ "$console_exists" = false ]; then
-            print_message $BLUE "🎨 Console assets not found, downloading..."
-            should_download=true
-        elif [ "$FORCE_CONSOLE_UPDATE" = true ]; then
-            print_message $BLUE "🎨 Force updating console assets..."
-            should_download=true
-        else
-            print_message $GREEN "✅ Console assets already available, skipping download"
-        fi
-    else
-        if [ "$console_exists" = true ]; then
-            print_message $GREEN "✅ Using existing console assets"
-        else
-            print_message $YELLOW "⚠️  Console assets not found. Use --download-console to download them."
-        fi
-    fi
-
-    if [ "$should_download" = true ]; then
-        print_message $BLUE "📥 Downloading console static assets..."
-
-        # Create static directory
-        mkdir -p "$static_dir"
-
-        # Download from GitHub Releases (consistent with Docker build)
-        local download_url
-        if [ "$CONSOLE_VERSION" = "latest" ]; then
-            print_message $YELLOW "Getting latest console release info..."
-            # For now, use dl.rustfs.com as fallback until GitHub Releases includes console assets
-            download_url="https://dl.rustfs.com/artifacts/console/rustfs-console-latest.zip"
-        else
-            download_url="https://dl.rustfs.com/artifacts/console/rustfs-console-${CONSOLE_VERSION}.zip"
-        fi
-
-        print_message $YELLOW "Downloading from: $download_url"
-
-        # Download with retries
-        local temp_file="console-assets-temp.zip"
-        local download_success=false
-
-        for i in {1..3}; do
-            if curl -L "$download_url" -o "$temp_file" --retry 3 --retry-delay 5 --max-time 300; then
-                download_success=true
-                break
-            else
-                print_message $YELLOW "Download attempt $i failed, retrying..."
-                sleep 2
-            fi
-        done
-
-        if [ "$download_success" = true ]; then
-            # Verify the downloaded file
-            if [ -f "$temp_file" ] && [ -s "$temp_file" ]; then
-                print_message $BLUE "📦 Extracting console assets..."
-
-                # Extract to static directory
-                if unzip -o "$temp_file" -d "$static_dir"; then
-                    rm "$temp_file"
-                    local final_size=$(du -sh "$static_dir" 2>/dev/null | cut -f1 || echo "unknown")
-                    print_message $GREEN "✅ Console assets downloaded successfully ($final_size)"
-                else
-                    print_message $RED "❌ Failed to extract console assets"
-                    rm -f "$temp_file"
-                    return 1
-                fi
-            else
-                print_message $RED "❌ Downloaded file is empty or invalid"
-                rm -f "$temp_file"
-                return 1
-            fi
-        else
-            print_message $RED "❌ Failed to download console assets after 3 attempts"
-            print_message $YELLOW "💡 Console assets are optional. Build will continue without them."
-            rm -f "$temp_file"
-        fi
-    fi
-}
-
-# Verify binary functionality
-verify_binary() {
-    local binary_path="$1"
-
-    # Check if binary exists
-    if [ ! -f "$binary_path" ]; then
-        print_message $RED "❌ Binary file not found: $binary_path"
-        return 1
-    fi
-
-    # Check if binary is executable
-    if [ ! -x "$binary_path" ]; then
-        print_message $RED "❌ Binary is not executable: $binary_path"
-        return 1
-    fi
-
-    # Check basic functionality - try to run help command
-    print_message $YELLOW "   Testing --help command..."
-    if ! "$binary_path" --help >/dev/null 2>&1; then
-        print_message $RED "❌ Binary failed to run --help command"
-        return 1
-    fi
-
-    # Check version command
-    print_message $YELLOW "   Testing --version command..."
-    if ! "$binary_path" --version >/dev/null 2>&1; then
-        print_message $YELLOW "⚠️  Binary does not support --version command (this is optional)"
-    fi
-
-    # Try to get some basic info about the binary
-    local file_info=$(file "$binary_path" 2>/dev/null || echo "unknown")
-    print_message $YELLOW "   Binary info: $file_info"
-
-    # Check if it's a valid ELF/Mach-O binary
-    if command -v readelf >/dev/null 2>&1; then
-        if readelf -h "$binary_path" >/dev/null 2>&1; then
-            print_message $YELLOW "   ELF binary structure: valid"
-        fi
-    elif command -v otool >/dev/null 2>&1; then
-        if otool -h "$binary_path" >/dev/null 2>&1; then
-            print_message $YELLOW "   Mach-O binary structure: valid"
-        fi
-    fi
-
-    return 0
-}
-
-# Build binary for current platform
-build_binary() {
-    local version=$(get_version)
-    local output_file="${OUTPUT_DIR}/${PLATFORM}/${BINARY_NAME}"
-
-    print_message $BLUE "🏗️  Building for platform: $PLATFORM"
-    print_message $YELLOW "   Version: $version"
-    print_message $YELLOW "   Output: $output_file"
-
-    # Create output directory
-    mkdir -p "${OUTPUT_DIR}/${PLATFORM}"
-
-    # Simple build logic matching the working version (4fb4b353)
-    # Force rebuild by touching build.rs
-    touch rustfs/build.rs
-
-    # Determine build command based on platform and cross-compilation needs
-    local build_cmd=""
-    local current_platform=$(detect_platform)
-
-    print_message $BLUE "📦 Using working version build logic..."
-
-    # Check if we need cross-compilation
-    if [ "$PLATFORM" != "$current_platform" ]; then
-        # Cross-compilation needed
-        if [[ "$PLATFORM" == *"apple-darwin"* ]]; then
-            print_message $RED "❌ macOS cross-compilation not supported"
-            print_message $YELLOW "💡 macOS targets must be built natively on macOS runners"
-            return 1
-        elif [[ "$PLATFORM" == *"windows"* ]]; then
-            # Use cross for Windows ARM64
-            if ! command -v cross &> /dev/null; then
-                print_message $YELLOW "📦 Installing cross tool..."
-                cargo install cross --git https://github.com/cross-rs/cross
-            fi
-            build_cmd="cross build"
-        else
-            # Use zigbuild for Linux ARM64 (matches working version)
-            if ! command -v cargo-zigbuild &> /dev/null; then
-                print_message $RED "❌ cargo-zigbuild not found. Please install it first."
-                return 1
-            fi
-            build_cmd="cargo zigbuild"
-        fi
-    else
-        # Native compilation
-        build_cmd="RUSTFLAGS=-Clink-arg=-lm cargo build"
-    fi
-
-    if [ "$BUILD_TYPE" = "release" ]; then
-        build_cmd+=" --release"
-    fi
-
-    build_cmd+=" --target $PLATFORM"
-    build_cmd+=" -p rustfs --bins"
-
-    print_message $BLUE "📦 Executing: $build_cmd"
-
-    # Execute build (this matches exactly what the working version does)
-    if eval $build_cmd; then
-        print_message $GREEN "✅ Successfully built for $PLATFORM"
-
-        # Copy binary to output directory
-        cp "target/${PLATFORM}/${BUILD_TYPE}/${BINARY_NAME}" "$output_file"
-
-        # Generate checksums
-        print_message $BLUE "🔐 Generating checksums..."
-        (cd "${OUTPUT_DIR}/${PLATFORM}" && generate_sha256 "${BINARY_NAME}" "${BINARY_NAME}.sha256sum")
-
-        # Verify binary functionality (if not skipped)
-        if [ "$SKIP_VERIFICATION" = false ]; then
-            print_message $BLUE "🔍 Verifying binary functionality..."
-            if verify_binary "$output_file"; then
-                print_message $GREEN "✅ Binary verification passed"
-            else
-                print_message $RED "❌ Binary verification failed"
-                return 1
-            fi
-        else
-            print_message $YELLOW "⚠️  Binary verification skipped by user request"
-        fi
-
-        # Sign binary if requested
-        if [ "$SIGN" = true ]; then
-            print_message $BLUE "✍️  Signing binary..."
-            (cd "${OUTPUT_DIR}/${PLATFORM}" && minisign -S -m "${BINARY_NAME}" -s ~/.minisign/minisign.key)
-        fi
-
-        print_message $GREEN "✅ Build completed successfully"
-    else
-        print_message $RED "❌ Failed to build for $PLATFORM"
-        return 1
-    fi
-}
-
-
-
-# Main build function
-build_rustfs() {
-    local version=$(get_version)
-
-    print_message $BLUE "🚀 Starting RustFS binary build process..."
-    print_message $YELLOW "   Version: $version"
-    print_message $YELLOW "   Platform: $PLATFORM"
-    print_message $YELLOW "   Output Directory: $OUTPUT_DIR"
-    print_message $YELLOW "   Build Type: $BUILD_TYPE"
-    print_message $YELLOW "   Sign: $SIGN"
-    print_message $YELLOW "   With Console: $WITH_CONSOLE"
-    if [ "$WITH_CONSOLE" = true ]; then
-        print_message $YELLOW "   Console Version: $CONSOLE_VERSION"
-        print_message $YELLOW "   Force Console Update: $FORCE_CONSOLE_UPDATE"
-    fi
-    print_message $YELLOW "   Skip Verification: $SKIP_VERIFICATION"
-    echo ""
-
-    # Setup environment
-    setup_rust_environment
-    echo ""
-
-    # Download console assets if requested
-    download_console_assets
-    echo ""
-
-    # Build binary
-    build_binary
-    echo ""
-
-    print_message $GREEN "🎉 Build process completed successfully!"
-
-    # Show built binary
-    local binary_file="${OUTPUT_DIR}/${PLATFORM}/${BINARY_NAME}"
-    if [ -f "$binary_file" ]; then
-        local size=$(ls -lh "$binary_file" | awk '{print $5}')
-        print_message $BLUE "📋 Built binary: $binary_file ($size)"
-    fi
-}
-
-# Parse command line arguments
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        -o|--output-dir)
-            OUTPUT_DIR="$2"
-            shift 2
-            ;;
-        -b|--binary-name)
-            BINARY_NAME="$2"
-            shift 2
-            ;;
-        -p|--platform)
-            CUSTOM_PLATFORM="$2"
-            shift 2
-            ;;
-        --dev)
-            BUILD_TYPE="debug"
-            shift
-            ;;
-        --sign)
-            SIGN=true
-            shift
-            ;;
-        --with-console)
-            WITH_CONSOLE=true
-            shift
-            ;;
-        --no-console)
-            WITH_CONSOLE=false
-            shift
-            ;;
-        --force-console-update)
-            FORCE_CONSOLE_UPDATE=true
-            WITH_CONSOLE=true  # Auto-enable download when forcing update
-            shift
-            ;;
-        --console-version)
-            CONSOLE_VERSION="$2"
-            shift 2
-            ;;
-        --skip-verification)
-            SKIP_VERIFICATION=true
-            shift
-            ;;
-        -h|--help)
-            usage
-            exit 0
-            ;;
-        *)
-            print_message $RED "❌ Unknown option: $1"
-            usage
-            exit 1
-            ;;
-    esac
-done
-
-# Main execution
-main() {
-    print_message $BLUE "🦀 RustFS Binary Build Script"
-    echo ""
-
-    # Check if we're in a Rust project
-    if [ ! -f "Cargo.toml" ]; then
-        print_message $RED "❌ No Cargo.toml found. Are you in a Rust project directory?"
-        exit 1
-    fi
-
-    # Override platform if specified
-    if [ -n "$CUSTOM_PLATFORM" ]; then
-        PLATFORM="$CUSTOM_PLATFORM"
-        print_message $YELLOW "🎯 Using specified platform: $PLATFORM"
-
-        # Auto-enable skip verification for cross-compilation
-        if [ "$PLATFORM" != "$(detect_platform)" ]; then
-            SKIP_VERIFICATION=true
-            print_message $YELLOW "⚠️  Cross-compilation detected, enabling --skip-verification"
-        fi
-    fi
-
-    # Start build process
-    build_rustfs
-}
-
-# Run main function
-main
-

crates/ahm/Cargo.toml

@@ -1,48 +0,0 @@
-[package]
-name = "rustfs-ahm"
-version.workspace = true
-edition.workspace = true
-authors = ["RustFS Team"]
-license.workspace = true
-description = "RustFS AHM (Automatic Health Management) Scanner"
-repository.workspace = true
-rust-version.workspace = true
-homepage.workspace = true
-documentation = "https://docs.rs/rustfs-ahm/latest/rustfs_ahm/"
-keywords = ["RustFS", "AHM", "health-management", "scanner", "Minio"]
-categories = ["web-programming", "development-tools", "filesystem"]
-
-[dependencies]
-rustfs-ecstore = { workspace = true }
-rustfs-common = { workspace = true }
-rustfs-filemeta = { workspace = true }
-rustfs-madmin = { workspace = true }
-rustfs-utils = { workspace = true }
-tokio = { workspace = true, features = ["full"] }
-tokio-util = { workspace = true }
-tracing = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
-time = { workspace = true }
-serde_json = { workspace = true }
-thiserror = { workspace = true }
-uuid = { workspace = true, features = ["v4", "serde"] }
-anyhow = { workspace = true }
-async-trait = { workspace = true }
-futures = { workspace = true }
-url = { workspace = true }
-rustfs-lock = { workspace = true }
-s3s = { workspace = true }
-lazy_static = { workspace = true }
-chrono = { workspace = true }
-rand = { workspace = true }
-reqwest = { workspace = true }
-tempfile = { workspace = true }
-
-[dev-dependencies]
-serde_json = { workspace = true }
-serial_test = "3.2.0"
-tracing-subscriber = { workspace = true }
-walkdir = "2.5.0"
-tempfile = { workspace = true }
-criterion = { workspace = true, features = ["html_reports"] }
-sysinfo = "0.30.8"

crates/ahm/src/error.rs

@@ -1,103 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum Error {
-    #[error("I/O error: {0}")]
-    Io(#[from] std::io::Error),
-
-    #[error("Storage error: {0}")]
-    Storage(#[from] rustfs_ecstore::error::Error),
-
-    #[error("Disk error: {0}")]
-    Disk(#[from] rustfs_ecstore::disk::error::DiskError),
-
-    #[error("Configuration error: {0}")]
-    Config(String),
-
-    #[error("Heal configuration error: {message}")]
-    ConfigurationError { message: String },
-
-    #[error("Other error: {0}")]
-    Other(String),
-
-    #[error(transparent)]
-    Anyhow(#[from] anyhow::Error),
-
-    // Scanner
-    #[error("Scanner error: {0}")]
-    Scanner(String),
-
-    #[error("Metrics error: {0}")]
-    Metrics(String),
-
-    #[error("Serialization error: {0}")]
-    Serialization(String),
-
-    #[error("IO error: {0}")]
-    IO(String),
-
-    #[error("Not found: {0}")]
-    NotFound(String),
-
-    #[error("Invalid checkpoint: {0}")]
-    InvalidCheckpoint(String),
-
-    // Heal
-    #[error("Heal task not found: {task_id}")]
-    TaskNotFound { task_id: String },
-
-    #[error("Heal task already exists: {task_id}")]
-    TaskAlreadyExists { task_id: String },
-
-    #[error("Heal manager is not running")]
-    ManagerNotRunning,
-
-    #[error("Heal task execution failed: {message}")]
-    TaskExecutionFailed { message: String },
-
-    #[error("Invalid heal type: {heal_type}")]
-    InvalidHealType { heal_type: String },
-
-    #[error("Heal task cancelled")]
-    TaskCancelled,
-
-    #[error("Heal task timeout")]
-    TaskTimeout,
-
-    #[error("Heal event processing failed: {message}")]
-    EventProcessingFailed { message: String },
-
-    #[error("Heal progress tracking failed: {message}")]
-    ProgressTrackingFailed { message: String },
-}
-
-pub type Result<T, E = Error> = std::result::Result<T, E>;
-
-impl Error {
-    pub fn other<E>(error: E) -> Self
-    where
-        E: Into<Box<dyn std::error::Error + Send + Sync>>,
-    {
-        Error::Other(error.into().to_string())
-    }
-}
-
-impl From<Error> for std::io::Error {
-    fn from(err: Error) -> Self {
-        std::io::Error::other(err)
-    }
-}

crates/ahm/src/heal/channel.rs

@@ -1,233 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use crate::error::Result;
-use crate::heal::{
-    manager::HealManager,
-    task::{HealOptions, HealPriority, HealRequest, HealType},
-};
-
-use rustfs_common::heal_channel::{
-    HealChannelCommand, HealChannelPriority, HealChannelReceiver, HealChannelRequest, HealChannelResponse, HealScanMode,
-};
-use std::sync::Arc;
-use tokio::sync::mpsc;
-use tracing::{error, info};
-
-/// Heal channel processor
-pub struct HealChannelProcessor {
-    /// Heal manager
-    heal_manager: Arc<HealManager>,
-    /// Response sender
-    response_sender: mpsc::UnboundedSender<HealChannelResponse>,
-    /// Response receiver
-    response_receiver: mpsc::UnboundedReceiver<HealChannelResponse>,
-}
-
-impl HealChannelProcessor {
-    /// Create new HealChannelProcessor
-    pub fn new(heal_manager: Arc<HealManager>) -> Self {
-        let (response_tx, response_rx) = mpsc::unbounded_channel();
-        Self {
-            heal_manager,
-            response_sender: response_tx,
-            response_receiver: response_rx,
-        }
-    }
-
-    /// Start processing heal channel requests
-    pub async fn start(&mut self, mut receiver: HealChannelReceiver) -> Result<()> {
-        info!("Starting heal channel processor");
-
-        loop {
-            tokio::select! {
-                command = receiver.recv() => {
-                    match command {
-                        Some(command) => {
-                            if let Err(e) = self.process_command(command).await {
-                                error!("Failed to process heal command: {}", e);
-                            }
-                        }
-                        None => {
-                            info!("Heal channel receiver closed, stopping processor");
-                            break;
-                        }
-                    }
-                }
-                response = self.response_receiver.recv() => {
-                    if let Some(response) = response {
-                        // Handle response if needed
-                        info!("Received heal response for request: {}", response.request_id);
-                    }
-                }
-            }
-        }
-
-        info!("Heal channel processor stopped");
-        Ok(())
-    }
-
-    /// Process heal command
-    async fn process_command(&self, command: HealChannelCommand) -> Result<()> {
-        match command {
-            HealChannelCommand::Start(request) => self.process_start_request(request).await,
-            HealChannelCommand::Query { heal_path, client_token } => self.process_query_request(heal_path, client_token).await,
-            HealChannelCommand::Cancel { heal_path } => self.process_cancel_request(heal_path).await,
-        }
-    }
-
-    /// Process start request
-    async fn process_start_request(&self, request: HealChannelRequest) -> Result<()> {
-        info!("Processing heal start request: {} for bucket: {}", request.id, request.bucket);
-
-        // Convert channel request to heal request
-        let heal_request = self.convert_to_heal_request(request.clone())?;
-
-        // Submit to heal manager
-        match self.heal_manager.submit_heal_request(heal_request).await {
-            Ok(task_id) => {
-                info!("Successfully submitted heal request: {} as task: {}", request.id, task_id);
-
-                // Send success response
-                let response = HealChannelResponse {
-                    request_id: request.id,
-                    success: true,
-                    data: Some(format!("Task ID: {task_id}").into_bytes()),
-                    error: None,
-                };
-
-                if let Err(e) = self.response_sender.send(response) {
-                    error!("Failed to send heal response: {}", e);
-                }
-            }
-            Err(e) => {
-                error!("Failed to submit heal request: {} - {}", request.id, e);
-
-                // Send error response
-                let response = HealChannelResponse {
-                    request_id: request.id,
-                    success: false,
-                    data: None,
-                    error: Some(e.to_string()),
-                };
-
-                if let Err(e) = self.response_sender.send(response) {
-                    error!("Failed to send heal error response: {}", e);
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Process query request
-    async fn process_query_request(&self, heal_path: String, client_token: String) -> Result<()> {
-        info!("Processing heal query request for path: {}", heal_path);
-
-        // TODO: Implement query logic based on heal_path and client_token
-        // For now, return a placeholder response
-        let response = HealChannelResponse {
-            request_id: client_token,
-            success: true,
-            data: Some(format!("Query result for path: {heal_path}").into_bytes()),
-            error: None,
-        };
-
-        if let Err(e) = self.response_sender.send(response) {
-            error!("Failed to send query response: {}", e);
-        }
-
-        Ok(())
-    }
-
-    /// Process cancel request
-    async fn process_cancel_request(&self, heal_path: String) -> Result<()> {
-        info!("Processing heal cancel request for path: {}", heal_path);
-
-        // TODO: Implement cancel logic based on heal_path
-        // For now, return a placeholder response
-        let response = HealChannelResponse {
-            request_id: heal_path.clone(),
-            success: true,
-            data: Some(format!("Cancel request for path: {heal_path}").into_bytes()),
-            error: None,
-        };
-
-        if let Err(e) = self.response_sender.send(response) {
-            error!("Failed to send cancel response: {}", e);
-        }
-
-        Ok(())
-    }
-
-    /// Convert channel request to heal request
-    fn convert_to_heal_request(&self, request: HealChannelRequest) -> Result<HealRequest> {
-        let heal_type = if let Some(disk_id) = &request.disk {
-            HealType::ErasureSet {
-                buckets: vec![],
-                set_disk_id: disk_id.clone(),
-            }
-        } else if let Some(prefix) = &request.object_prefix {
-            if !prefix.is_empty() {
-                HealType::Object {
-                    bucket: request.bucket.clone(),
-                    object: prefix.clone(),
-                    version_id: None,
-                }
-            } else {
-                HealType::Bucket {
-                    bucket: request.bucket.clone(),
-                }
-            }
-        } else {
-            HealType::Bucket {
-                bucket: request.bucket.clone(),
-            }
-        };
-
-        let priority = match request.priority {
-            HealChannelPriority::Low => HealPriority::Low,
-            HealChannelPriority::Normal => HealPriority::Normal,
-            HealChannelPriority::High => HealPriority::High,
-            HealChannelPriority::Critical => HealPriority::Urgent,
-        };
-
-        // Build HealOptions with all available fields
-        let mut options = HealOptions {
-            scan_mode: request.scan_mode.unwrap_or(HealScanMode::Normal),
-            remove_corrupted: request.remove_corrupted.unwrap_or(false),
-            recreate_missing: request.recreate_missing.unwrap_or(true),
-            update_parity: request.update_parity.unwrap_or(true),
-            recursive: request.recursive.unwrap_or(false),
-            dry_run: request.dry_run.unwrap_or(false),
-            timeout: request.timeout_seconds.map(std::time::Duration::from_secs),
-            pool_index: request.pool_index,
-            set_index: request.set_index,
-        };
-
-        // Apply force_start overrides
-        if request.force_start {
-            options.remove_corrupted = true;
-            options.recreate_missing = true;
-            options.update_parity = true;
-        }
-
-        Ok(HealRequest::new(heal_type, options, priority))
-    }
-
-    /// Get response sender for external use
-    pub fn get_response_sender(&self) -> mpsc::UnboundedSender<HealChannelResponse> {
-        self.response_sender.clone()
-    }
-}

crates/ahm/src/heal/erasure_healer.rs

@@ -1,456 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use crate::error::{Error, Result};
-use crate::heal::{
-    progress::HealProgress,
-    resume::{CheckpointManager, ResumeManager, ResumeUtils},
-    storage::HealStorageAPI,
-};
-use futures::future::join_all;
-use rustfs_common::heal_channel::{HealOpts, HealScanMode};
-use rustfs_ecstore::disk::DiskStore;
-use std::sync::Arc;
-use tokio::sync::RwLock;
-use tracing::{error, info, warn};
-
-/// Erasure Set Healer
-pub struct ErasureSetHealer {
-    storage: Arc<dyn HealStorageAPI>,
-    progress: Arc<RwLock<HealProgress>>,
-    cancel_token: tokio_util::sync::CancellationToken,
-    disk: DiskStore,
-}
-
-impl ErasureSetHealer {
-    pub fn new(
-        storage: Arc<dyn HealStorageAPI>,
-        progress: Arc<RwLock<HealProgress>>,
-        cancel_token: tokio_util::sync::CancellationToken,
-        disk: DiskStore,
-    ) -> Self {
-        Self {
-            storage,
-            progress,
-            cancel_token,
-            disk,
-        }
-    }
-
-    /// execute erasure set heal with resume
-    pub async fn heal_erasure_set(&self, buckets: &[String], set_disk_id: &str) -> Result<()> {
-        info!("Starting erasure set heal for {} buckets on set disk {}", buckets.len(), set_disk_id);
-
-        // 1. generate or get task id
-        let task_id = self.get_or_create_task_id(set_disk_id).await?;
-
-        // 2. initialize or resume resume state
-        let (resume_manager, checkpoint_manager) = self.initialize_resume_state(&task_id, buckets).await?;
-
-        // 3. execute heal with resume
-        let result = self
-            .execute_heal_with_resume(buckets, &resume_manager, &checkpoint_manager)
-            .await;
-
-        // 4. cleanup resume state
-        if result.is_ok() {
-            if let Err(e) = resume_manager.cleanup().await {
-                warn!("Failed to cleanup resume state: {}", e);
-            }
-            if let Err(e) = checkpoint_manager.cleanup().await {
-                warn!("Failed to cleanup checkpoint: {}", e);
-            }
-        }
-
-        result
-    }
-
-    /// get or create task id
-    async fn get_or_create_task_id(&self, _set_disk_id: &str) -> Result<String> {
-        // check if there are resumable tasks
-        let resumable_tasks = ResumeUtils::get_resumable_tasks(&self.disk).await?;
-
-        for task_id in resumable_tasks {
-            if ResumeUtils::can_resume_task(&self.disk, &task_id).await {
-                info!("Found resumable task: {}", task_id);
-                return Ok(task_id);
-            }
-        }
-
-        // create new task id
-        let task_id = ResumeUtils::generate_task_id();
-        info!("Created new heal task: {}", task_id);
-        Ok(task_id)
-    }
-
-    /// initialize or resume resume state
-    async fn initialize_resume_state(&self, task_id: &str, buckets: &[String]) -> Result<(ResumeManager, CheckpointManager)> {
-        // check if resume state exists
-        if ResumeManager::has_resume_state(&self.disk, task_id).await {
-            info!("Loading existing resume state for task: {}", task_id);
-
-            let resume_manager = ResumeManager::load_from_disk(self.disk.clone(), task_id).await?;
-            let checkpoint_manager = if CheckpointManager::has_checkpoint(&self.disk, task_id).await {
-                CheckpointManager::load_from_disk(self.disk.clone(), task_id).await?
-            } else {
-                CheckpointManager::new(self.disk.clone(), task_id.to_string()).await?
-            };
-
-            Ok((resume_manager, checkpoint_manager))
-        } else {
-            info!("Creating new resume state for task: {}", task_id);
-
-            let resume_manager =
-                ResumeManager::new(self.disk.clone(), task_id.to_string(), "erasure_set".to_string(), buckets.to_vec()).await?;
-
-            let checkpoint_manager = CheckpointManager::new(self.disk.clone(), task_id.to_string()).await?;
-
-            Ok((resume_manager, checkpoint_manager))
-        }
-    }
-
-    /// execute heal with resume
-    async fn execute_heal_with_resume(
-        &self,
-        buckets: &[String],
-        resume_manager: &ResumeManager,
-        checkpoint_manager: &CheckpointManager,
-    ) -> Result<()> {
-        // 1. get current state
-        let state = resume_manager.get_state().await;
-        let checkpoint = checkpoint_manager.get_checkpoint().await;
-
-        info!(
-            "Resuming from bucket {} object {}",
-            checkpoint.current_bucket_index, checkpoint.current_object_index
-        );
-
-        // 2. initialize progress
-        self.initialize_progress(buckets, &state).await;
-
-        // 3. continue from checkpoint
-        let current_bucket_index = checkpoint.current_bucket_index;
-        let mut current_object_index = checkpoint.current_object_index;
-
-        let mut processed_objects = state.processed_objects;
-        let mut successful_objects = state.successful_objects;
-        let mut failed_objects = state.failed_objects;
-        let mut skipped_objects = state.skipped_objects;
-
-        // 4. process remaining buckets
-        for (bucket_idx, bucket) in buckets.iter().enumerate().skip(current_bucket_index) {
-            // check if completed
-            if state.completed_buckets.contains(bucket) {
-                continue;
-            }
-
-            // update current bucket
-            resume_manager.set_current_item(Some(bucket.clone()), None).await?;
-
-            // process objects in bucket
-            let bucket_result = self
-                .heal_bucket_with_resume(
-                    bucket,
-                    &mut current_object_index,
-                    &mut processed_objects,
-                    &mut successful_objects,
-                    &mut failed_objects,
-                    &mut skipped_objects,
-                    resume_manager,
-                    checkpoint_manager,
-                )
-                .await;
-
-            // update checkpoint position
-            checkpoint_manager.update_position(bucket_idx, current_object_index).await?;
-
-            // update progress
-            resume_manager
-                .update_progress(processed_objects, successful_objects, failed_objects, skipped_objects)
-                .await?;
-
-            // check cancel status
-            if self.cancel_token.is_cancelled() {
-                info!("Heal task cancelled");
-                return Err(Error::TaskCancelled);
-            }
-
-            // process bucket result
-            match bucket_result {
-                Ok(_) => {
-                    resume_manager.complete_bucket(bucket).await?;
-                    info!("Completed heal for bucket: {}", bucket);
-                }
-                Err(e) => {
-                    error!("Failed to heal bucket {}: {}", bucket, e);
-                    // continue to next bucket, do not interrupt the whole process
-                }
-            }
-
-            // reset object index
-            current_object_index = 0;
-        }
-
-        // 5. mark task completed
-        resume_manager.mark_completed().await?;
-
-        info!("Erasure set heal completed successfully");
-        Ok(())
-    }
-
-    /// heal single bucket with resume
-    #[allow(clippy::too_many_arguments)]
-    async fn heal_bucket_with_resume(
-        &self,
-        bucket: &str,
-        current_object_index: &mut usize,
-        processed_objects: &mut u64,
-        successful_objects: &mut u64,
-        failed_objects: &mut u64,
-        _skipped_objects: &mut u64,
-        resume_manager: &ResumeManager,
-        checkpoint_manager: &CheckpointManager,
-    ) -> Result<()> {
-        info!("Starting heal for bucket: {} from object index {}", bucket, current_object_index);
-
-        // 1. get bucket info
-        let _bucket_info = match self.storage.get_bucket_info(bucket).await? {
-            Some(info) => info,
-            None => {
-                warn!("Bucket {} not found, skipping", bucket);
-                return Ok(());
-            }
-        };
-
-        // 2. get objects to heal
-        let objects = self.storage.list_objects_for_heal(bucket, "").await?;
-
-        // 3. continue from checkpoint
-        for (obj_idx, object) in objects.iter().enumerate().skip(*current_object_index) {
-            // check if already processed
-            if checkpoint_manager.get_checkpoint().await.processed_objects.contains(object) {
-                continue;
-            }
-
-            // update current object
-            resume_manager
-                .set_current_item(Some(bucket.to_string()), Some(object.clone()))
-                .await?;
-
-            // heal object
-            let heal_opts = HealOpts {
-                scan_mode: HealScanMode::Normal,
-                remove: true,
-                recreate: true,
-                ..Default::default()
-            };
-
-            match self.storage.heal_object(bucket, object, None, &heal_opts).await {
-                Ok((_result, None)) => {
-                    *successful_objects += 1;
-                    checkpoint_manager.add_processed_object(object.clone()).await?;
-                    info!("Successfully healed object {}/{}", bucket, object);
-                }
-                Ok((_, Some(err))) => {
-                    *failed_objects += 1;
-                    checkpoint_manager.add_failed_object(object.clone()).await?;
-                    warn!("Failed to heal object {}/{}: {}", bucket, object, err);
-                }
-                Err(err) => {
-                    *failed_objects += 1;
-                    checkpoint_manager.add_failed_object(object.clone()).await?;
-                    warn!("Error healing object {}/{}: {}", bucket, object, err);
-                }
-            }
-
-            *processed_objects += 1;
-            *current_object_index = obj_idx + 1;
-
-            // check cancel status
-            if self.cancel_token.is_cancelled() {
-                info!("Heal task cancelled during object processing");
-                return Err(Error::TaskCancelled);
-            }
-
-            // save checkpoint periodically
-            if obj_idx % 100 == 0 {
-                checkpoint_manager.update_position(0, *current_object_index).await?;
-            }
-        }
-
-        Ok(())
-    }
-
-    /// initialize progress tracking
-    async fn initialize_progress(&self, _buckets: &[String], state: &crate::heal::resume::ResumeState) {
-        let mut progress = self.progress.write().await;
-        progress.objects_scanned = state.total_objects;
-        progress.objects_healed = state.successful_objects;
-        progress.objects_failed = state.failed_objects;
-        progress.bytes_processed = 0; // set to 0 for now, can be extended later
-        progress.set_current_object(state.current_object.clone());
-    }
-
-    /// heal all buckets concurrently
-    #[allow(dead_code)]
-    async fn heal_buckets_concurrently(&self, buckets: &[String]) -> Vec<Result<()>> {
-        // use semaphore to control concurrency, avoid too many concurrent healings
-        let semaphore = Arc::new(tokio::sync::Semaphore::new(4)); // max 4 concurrent healings
-
-        let heal_futures = buckets.iter().map(|bucket| {
-            let bucket = bucket.clone();
-            let storage = self.storage.clone();
-            let progress = self.progress.clone();
-            let semaphore = semaphore.clone();
-            let cancel_token = self.cancel_token.clone();
-
-            async move {
-                let _permit = semaphore.acquire().await.unwrap();
-
-                if cancel_token.is_cancelled() {
-                    return Err(Error::TaskCancelled);
-                }
-
-                Self::heal_single_bucket(&storage, &bucket, &progress).await
-            }
-        });
-
-        // use join_all to process concurrently
-        join_all(heal_futures).await
-    }
-
-    /// heal single bucket
-    #[allow(dead_code)]
-    async fn heal_single_bucket(
-        storage: &Arc<dyn HealStorageAPI>,
-        bucket: &str,
-        progress: &Arc<RwLock<HealProgress>>,
-    ) -> Result<()> {
-        info!("Starting heal for bucket: {}", bucket);
-
-        // 1. get bucket info
-        let _bucket_info = match storage.get_bucket_info(bucket).await? {
-            Some(info) => info,
-            None => {
-                warn!("Bucket {} not found, skipping", bucket);
-                return Ok(());
-            }
-        };
-
-        // 2. get objects to heal
-        let objects = storage.list_objects_for_heal(bucket, "").await?;
-
-        // 3. update progress
-        {
-            let mut p = progress.write().await;
-            p.objects_scanned += objects.len() as u64;
-        }
-
-        // 4. heal objects concurrently
-        let heal_opts = HealOpts {
-            scan_mode: HealScanMode::Normal,
-            remove: true,   // remove corrupted data
-            recreate: true, // recreate missing data
-            ..Default::default()
-        };
-
-        let object_results = Self::heal_objects_concurrently(storage, bucket, &objects, &heal_opts, progress).await;
-
-        // 5. count results
-        let (success_count, failure_count) = object_results
-            .into_iter()
-            .fold((0, 0), |(success, failure), result| match result {
-                Ok(_) => (success + 1, failure),
-                Err(_) => (success, failure + 1),
-            });
-
-        // 6. update progress
-        {
-            let mut p = progress.write().await;
-            p.objects_healed += success_count;
-            p.objects_failed += failure_count;
-            p.set_current_object(Some(format!("completed bucket: {bucket}")));
-        }
-
-        info!(
-            "Completed heal for bucket {}: {} success, {} failures",
-            bucket, success_count, failure_count
-        );
-
-        Ok(())
-    }
-
-    /// heal objects concurrently
-    #[allow(dead_code)]
-    async fn heal_objects_concurrently(
-        storage: &Arc<dyn HealStorageAPI>,
-        bucket: &str,
-        objects: &[String],
-        heal_opts: &HealOpts,
-        _progress: &Arc<RwLock<HealProgress>>,
-    ) -> Vec<Result<()>> {
-        // use semaphore to control object healing concurrency
-        let semaphore = Arc::new(tokio::sync::Semaphore::new(8)); // max 8 concurrent object healings
-
-        let heal_futures = objects.iter().map(|object| {
-            let object = object.clone();
-            let bucket = bucket.to_string();
-            let storage = storage.clone();
-            let heal_opts = *heal_opts;
-            let semaphore = semaphore.clone();
-
-            async move {
-                let _permit = semaphore.acquire().await.unwrap();
-
-                match storage.heal_object(&bucket, &object, None, &heal_opts).await {
-                    Ok((_result, None)) => {
-                        info!("Successfully healed object {}/{}", bucket, object);
-                        Ok(())
-                    }
-                    Ok((_, Some(err))) => {
-                        warn!("Failed to heal object {}/{}: {}", bucket, object, err);
-                        Err(Error::other(err))
-                    }
-                    Err(err) => {
-                        warn!("Error healing object {}/{}: {}", bucket, object, err);
-                        Err(err)
-                    }
-                }
-            }
-        });
-
-        join_all(heal_futures).await
-    }
-
-    /// process results
-    #[allow(dead_code)]
-    async fn process_results(&self, results: Vec<Result<()>>) -> Result<()> {
-        let (success_count, failure_count): (usize, usize) =
-            results.into_iter().fold((0, 0), |(success, failure), result| match result {
-                Ok(_) => (success + 1, failure),
-                Err(_) => (success, failure + 1),
-            });
-
-        let total = success_count + failure_count;
-
-        info!("Erasure set heal completed: {}/{} buckets successful", success_count, total);
-
-        if failure_count > 0 {
-            warn!("{} buckets failed to heal", failure_count);
-            return Err(Error::other(format!("{failure_count} buckets failed to heal")));
-        }
-
-        Ok(())
-    }
-}

crates/ahm/src/heal/event.rs

@@ -1,359 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use crate::heal::task::{HealOptions, HealPriority, HealRequest, HealType};
-use rustfs_ecstore::disk::endpoint::Endpoint;
-use serde::{Deserialize, Serialize};
-use std::time::SystemTime;
-
-/// Corruption type
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum CorruptionType {
-    /// Data corruption
-    DataCorruption,
-    /// Metadata corruption
-    MetadataCorruption,
-    /// Partial corruption
-    PartialCorruption,
-    /// Complete corruption
-    CompleteCorruption,
-}
-
-/// Severity level
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
-pub enum Severity {
-    /// Low severity
-    Low = 0,
-    /// Medium severity
-    Medium = 1,
-    /// High severity
-    High = 2,
-    /// Critical severity
-    Critical = 3,
-}
-
-/// Heal event
-#[derive(Debug, Clone)]
-pub enum HealEvent {
-    /// Object corruption event
-    ObjectCorruption {
-        bucket: String,
-        object: String,
-        version_id: Option<String>,
-        corruption_type: CorruptionType,
-        severity: Severity,
-    },
-    /// Object missing event
-    ObjectMissing {
-        bucket: String,
-        object: String,
-        version_id: Option<String>,
-        expected_locations: Vec<usize>,
-        available_locations: Vec<usize>,
-    },
-    /// Metadata corruption event
-    MetadataCorruption {
-        bucket: String,
-        object: String,
-        corruption_type: CorruptionType,
-    },
-    /// Disk status change event
-    DiskStatusChange {
-        endpoint: Endpoint,
-        old_status: String,
-        new_status: String,
-    },
-    /// EC decode failure event
-    ECDecodeFailure {
-        bucket: String,
-        object: String,
-        version_id: Option<String>,
-        missing_shards: Vec<usize>,
-        available_shards: Vec<usize>,
-    },
-    /// Checksum mismatch event
-    ChecksumMismatch {
-        bucket: String,
-        object: String,
-        version_id: Option<String>,
-        expected_checksum: String,
-        actual_checksum: String,
-    },
-    /// Bucket metadata corruption event
-    BucketMetadataCorruption {
-        bucket: String,
-        corruption_type: CorruptionType,
-    },
-    /// MRF metadata corruption event
-    MRFMetadataCorruption {
-        meta_path: String,
-        corruption_type: CorruptionType,
-    },
-}
-
-impl HealEvent {
-    /// Convert HealEvent to HealRequest
-    pub fn to_heal_request(&self) -> HealRequest {
-        match self {
-            HealEvent::ObjectCorruption {
-                bucket,
-                object,
-                version_id,
-                severity,
-                ..
-            } => HealRequest::new(
-                HealType::Object {
-                    bucket: bucket.clone(),
-                    object: object.clone(),
-                    version_id: version_id.clone(),
-                },
-                HealOptions::default(),
-                Self::severity_to_priority(severity),
-            ),
-            HealEvent::ObjectMissing {
-                bucket,
-                object,
-                version_id,
-                ..
-            } => HealRequest::new(
-                HealType::Object {
-                    bucket: bucket.clone(),
-                    object: object.clone(),
-                    version_id: version_id.clone(),
-                },
-                HealOptions::default(),
-                HealPriority::High,
-            ),
-            HealEvent::MetadataCorruption { bucket, object, .. } => HealRequest::new(
-                HealType::Metadata {
-                    bucket: bucket.clone(),
-                    object: object.clone(),
-                },
-                HealOptions::default(),
-                HealPriority::High,
-            ),
-            HealEvent::DiskStatusChange { endpoint, .. } => {
-                // Convert disk status change to erasure set heal
-                // Note: This requires access to storage to get bucket list, which is not available here
-                // The actual bucket list will need to be provided by the caller or retrieved differently
-                HealRequest::new(
-                    HealType::ErasureSet {
-                        buckets: vec![], // Empty bucket list - caller should populate this
-                        set_disk_id: format!("{}_{}", endpoint.pool_idx, endpoint.set_idx),
-                    },
-                    HealOptions::default(),
-                    HealPriority::High,
-                )
-            }
-            HealEvent::ECDecodeFailure {
-                bucket,
-                object,
-                version_id,
-                ..
-            } => HealRequest::new(
-                HealType::ECDecode {
-                    bucket: bucket.clone(),
-                    object: object.clone(),
-                    version_id: version_id.clone(),
-                },
-                HealOptions::default(),
-                HealPriority::Urgent,
-            ),
-            HealEvent::ChecksumMismatch {
-                bucket,
-                object,
-                version_id,
-                ..
-            } => HealRequest::new(
-                HealType::Object {
-                    bucket: bucket.clone(),
-                    object: object.clone(),
-                    version_id: version_id.clone(),
-                },
-                HealOptions::default(),
-                HealPriority::High,
-            ),
-            HealEvent::BucketMetadataCorruption { bucket, .. } => {
-                HealRequest::new(HealType::Bucket { bucket: bucket.clone() }, HealOptions::default(), HealPriority::High)
-            }
-            HealEvent::MRFMetadataCorruption { meta_path, .. } => HealRequest::new(
-                HealType::MRF {
-                    meta_path: meta_path.clone(),
-                },
-                HealOptions::default(),
-                HealPriority::High,
-            ),
-        }
-    }
-
-    /// Convert severity to priority
-    fn severity_to_priority(severity: &Severity) -> HealPriority {
-        match severity {
-            Severity::Low => HealPriority::Low,
-            Severity::Medium => HealPriority::Normal,
-            Severity::High => HealPriority::High,
-            Severity::Critical => HealPriority::Urgent,
-        }
-    }
-
-    /// Get event description
-    pub fn description(&self) -> String {
-        match self {
-            HealEvent::ObjectCorruption {
-                bucket,
-                object,
-                corruption_type,
-                ..
-            } => {
-                format!("Object corruption detected: {bucket}/{object} - {corruption_type:?}")
-            }
-            HealEvent::ObjectMissing { bucket, object, .. } => {
-                format!("Object missing: {bucket}/{object}")
-            }
-            HealEvent::MetadataCorruption {
-                bucket,
-                object,
-                corruption_type,
-                ..
-            } => {
-                format!("Metadata corruption: {bucket}/{object} - {corruption_type:?}")
-            }
-            HealEvent::DiskStatusChange {
-                endpoint,
-                old_status,
-                new_status,
-                ..
-            } => {
-                format!("Disk status changed: {endpoint:?} {old_status} -> {new_status}")
-            }
-            HealEvent::ECDecodeFailure {
-                bucket,
-                object,
-                missing_shards,
-                ..
-            } => {
-                format!("EC decode failure: {bucket}/{object} - missing shards: {missing_shards:?}")
-            }
-            HealEvent::ChecksumMismatch {
-                bucket,
-                object,
-                expected_checksum,
-                actual_checksum,
-                ..
-            } => {
-                format!("Checksum mismatch: {bucket}/{object} - expected: {expected_checksum}, actual: {actual_checksum}")
-            }
-            HealEvent::BucketMetadataCorruption {
-                bucket, corruption_type, ..
-            } => {
-                format!("Bucket metadata corruption: {bucket} - {corruption_type:?}")
-            }
-            HealEvent::MRFMetadataCorruption {
-                meta_path,
-                corruption_type,
-                ..
-            } => {
-                format!("MRF metadata corruption: {meta_path} - {corruption_type:?}")
-            }
-        }
-    }
-
-    /// Get event severity
-    pub fn severity(&self) -> Severity {
-        match self {
-            HealEvent::ObjectCorruption { severity, .. } => severity.clone(),
-            HealEvent::ObjectMissing { .. } => Severity::High,
-            HealEvent::MetadataCorruption { .. } => Severity::High,
-            HealEvent::DiskStatusChange { .. } => Severity::High,
-            HealEvent::ECDecodeFailure { .. } => Severity::Critical,
-            HealEvent::ChecksumMismatch { .. } => Severity::High,
-            HealEvent::BucketMetadataCorruption { .. } => Severity::High,
-            HealEvent::MRFMetadataCorruption { .. } => Severity::High,
-        }
-    }
-
-    /// Get event timestamp
-    pub fn timestamp(&self) -> SystemTime {
-        SystemTime::now()
-    }
-}
-
-/// Heal event handler
-pub struct HealEventHandler {
-    /// Event queue
-    events: Vec<HealEvent>,
-    /// Maximum number of events
-    max_events: usize,
-}
-
-impl HealEventHandler {
-    pub fn new(max_events: usize) -> Self {
-        Self {
-            events: Vec::new(),
-            max_events,
-        }
-    }
-
-    /// Add event
-    pub fn add_event(&mut self, event: HealEvent) {
-        if self.events.len() >= self.max_events {
-            // Remove oldest event
-            self.events.remove(0);
-        }
-        self.events.push(event);
-    }
-
-    /// Get all events
-    pub fn get_events(&self) -> &[HealEvent] {
-        &self.events
-    }
-
-    /// Clear events
-    pub fn clear_events(&mut self) {
-        self.events.clear();
-    }
-
-    /// Get event count
-    pub fn event_count(&self) -> usize {
-        self.events.len()
-    }
-
-    /// Filter events by severity
-    pub fn filter_by_severity(&self, min_severity: Severity) -> Vec<&HealEvent> {
-        self.events.iter().filter(|event| event.severity() >= min_severity).collect()
-    }
-
-    /// Filter events by type
-    pub fn filter_by_type(&self, event_type: &str) -> Vec<&HealEvent> {
-        self.events
-            .iter()
-            .filter(|event| match event {
-                HealEvent::ObjectCorruption { .. } => event_type == "ObjectCorruption",
-                HealEvent::ObjectMissing { .. } => event_type == "ObjectMissing",
-                HealEvent::MetadataCorruption { .. } => event_type == "MetadataCorruption",
-                HealEvent::DiskStatusChange { .. } => event_type == "DiskStatusChange",
-                HealEvent::ECDecodeFailure { .. } => event_type == "ECDecodeFailure",
-                HealEvent::ChecksumMismatch { .. } => event_type == "ChecksumMismatch",
-                HealEvent::BucketMetadataCorruption { .. } => event_type == "BucketMetadataCorruption",
-                HealEvent::MRFMetadataCorruption { .. } => event_type == "MRFMetadataCorruption",
-            })
-            .collect()
-    }
-}
-
-impl Default for HealEventHandler {
-    fn default() -> Self {
-        Self::new(1000)
-    }
-}

crates/ahm/src/heal/manager.rs

@@ -1,422 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use crate::error::{Error, Result};
-use crate::heal::{
-    progress::{HealProgress, HealStatistics},
-    storage::HealStorageAPI,
-    task::{HealOptions, HealPriority, HealRequest, HealTask, HealTaskStatus, HealType},
-};
-use rustfs_ecstore::disk::DiskAPI;
-use rustfs_ecstore::disk::error::DiskError;
-use rustfs_ecstore::global::GLOBAL_LOCAL_DISK_MAP;
-use std::{
-    collections::{HashMap, VecDeque},
-    sync::Arc,
-    time::{Duration, SystemTime},
-};
-use tokio::{
-    sync::{Mutex, RwLock},
-    time::interval,
-};
-use tokio_util::sync::CancellationToken;
-use tracing::{error, info, warn};
-
-/// Heal config
-#[derive(Debug, Clone)]
-pub struct HealConfig {
-    /// Whether to enable auto heal
-    pub enable_auto_heal: bool,
-    /// Heal interval
-    pub heal_interval: Duration,
-    /// Maximum concurrent heal tasks
-    pub max_concurrent_heals: usize,
-    /// Task timeout
-    pub task_timeout: Duration,
-    /// Queue size
-    pub queue_size: usize,
-}
-
-impl Default for HealConfig {
-    fn default() -> Self {
-        Self {
-            enable_auto_heal: true,
-            heal_interval: Duration::from_secs(10), // 10 seconds
-            max_concurrent_heals: 4,
-            task_timeout: Duration::from_secs(300), // 5 minutes
-            queue_size: 1000,
-        }
-    }
-}
-
-/// Heal state
-#[derive(Debug, Default)]
-pub struct HealState {
-    /// Whether running
-    pub is_running: bool,
-    /// Current heal cycle
-    pub current_cycle: u64,
-    /// Last heal time
-    pub last_heal_time: Option<SystemTime>,
-    /// Total healed objects
-    pub total_healed_objects: u64,
-    /// Total heal failures
-    pub total_heal_failures: u64,
-    /// Current active heal tasks
-    pub active_heal_count: usize,
-}
-
-/// Heal manager
-pub struct HealManager {
-    /// Heal config
-    config: Arc<RwLock<HealConfig>>,
-    /// Heal state
-    state: Arc<RwLock<HealState>>,
-    /// Active heal tasks
-    active_heals: Arc<Mutex<HashMap<String, Arc<HealTask>>>>,
-    /// Heal queue
-    heal_queue: Arc<Mutex<VecDeque<HealRequest>>>,
-    /// Storage layer interface
-    storage: Arc<dyn HealStorageAPI>,
-    /// Cancel token
-    cancel_token: CancellationToken,
-    /// Statistics
-    statistics: Arc<RwLock<HealStatistics>>,
-}
-
-impl HealManager {
-    /// Create new HealManager
-    pub fn new(storage: Arc<dyn HealStorageAPI>, config: Option<HealConfig>) -> Self {
-        let config = config.unwrap_or_default();
-        Self {
-            config: Arc::new(RwLock::new(config)),
-            state: Arc::new(RwLock::new(HealState::default())),
-            active_heals: Arc::new(Mutex::new(HashMap::new())),
-            heal_queue: Arc::new(Mutex::new(VecDeque::new())),
-            storage,
-            cancel_token: CancellationToken::new(),
-            statistics: Arc::new(RwLock::new(HealStatistics::new())),
-        }
-    }
-
-    /// Start HealManager
-    pub async fn start(&self) -> Result<()> {
-        let mut state = self.state.write().await;
-        if state.is_running {
-            warn!("HealManager is already running");
-            return Ok(());
-        }
-        state.is_running = true;
-        drop(state);
-
-        info!("Starting HealManager");
-
-        // start scheduler
-        self.start_scheduler().await?;
-
-        // start auto disk scanner
-        self.start_auto_disk_scanner().await?;
-
-        info!("HealManager started successfully");
-        Ok(())
-    }
-
-    /// Stop HealManager
-    pub async fn stop(&self) -> Result<()> {
-        info!("Stopping HealManager");
-
-        // cancel all tasks
-        self.cancel_token.cancel();
-
-        // wait for all tasks to complete
-        let mut active_heals = self.active_heals.lock().await;
-        for task in active_heals.values() {
-            if let Err(e) = task.cancel().await {
-                warn!("Failed to cancel task {}: {}", task.id, e);
-            }
-        }
-        active_heals.clear();
-
-        // update state
-        let mut state = self.state.write().await;
-        state.is_running = false;
-
-        info!("HealManager stopped successfully");
-        Ok(())
-    }
-
-    /// Submit heal request
-    pub async fn submit_heal_request(&self, request: HealRequest) -> Result<String> {
-        let config = self.config.read().await;
-        let mut queue = self.heal_queue.lock().await;
-
-        if queue.len() >= config.queue_size {
-            return Err(Error::ConfigurationError {
-                message: "Heal queue is full".to_string(),
-            });
-        }
-
-        let request_id = request.id.clone();
-        queue.push_back(request);
-        drop(queue);
-
-        info!("Submitted heal request: {}", request_id);
-        Ok(request_id)
-    }
-
-    /// Get task status
-    pub async fn get_task_status(&self, task_id: &str) -> Result<HealTaskStatus> {
-        let active_heals = self.active_heals.lock().await;
-        if let Some(task) = active_heals.get(task_id) {
-            Ok(task.get_status().await)
-        } else {
-            Err(Error::TaskNotFound {
-                task_id: task_id.to_string(),
-            })
-        }
-    }
-
-    /// Get task progress
-    pub async fn get_active_tasks_count(&self) -> usize {
-        self.active_heals.lock().await.len()
-    }
-
-    pub async fn get_task_progress(&self, task_id: &str) -> Result<HealProgress> {
-        let active_heals = self.active_heals.lock().await;
-        if let Some(task) = active_heals.get(task_id) {
-            Ok(task.get_progress().await)
-        } else {
-            Err(Error::TaskNotFound {
-                task_id: task_id.to_string(),
-            })
-        }
-    }
-
-    /// Cancel task
-    pub async fn cancel_task(&self, task_id: &str) -> Result<()> {
-        let mut active_heals = self.active_heals.lock().await;
-        if let Some(task) = active_heals.get(task_id) {
-            task.cancel().await?;
-            active_heals.remove(task_id);
-            info!("Cancelled heal task: {}", task_id);
-            Ok(())
-        } else {
-            Err(Error::TaskNotFound {
-                task_id: task_id.to_string(),
-            })
-        }
-    }
-
-    /// Get statistics
-    pub async fn get_statistics(&self) -> HealStatistics {
-        self.statistics.read().await.clone()
-    }
-
-    /// Get active task count
-    pub async fn get_active_task_count(&self) -> usize {
-        let active_heals = self.active_heals.lock().await;
-        active_heals.len()
-    }
-
-    /// Get queue length
-    pub async fn get_queue_length(&self) -> usize {
-        let queue = self.heal_queue.lock().await;
-        queue.len()
-    }
-
-    /// Start scheduler
-    async fn start_scheduler(&self) -> Result<()> {
-        let config = self.config.clone();
-        let heal_queue = self.heal_queue.clone();
-        let active_heals = self.active_heals.clone();
-        let cancel_token = self.cancel_token.clone();
-        let statistics = self.statistics.clone();
-        let storage = self.storage.clone();
-
-        tokio::spawn(async move {
-            let mut interval = interval(config.read().await.heal_interval);
-
-            loop {
-                tokio::select! {
-                    _ = cancel_token.cancelled() => {
-                        info!("Heal scheduler received shutdown signal");
-                        break;
-                    }
-                    _ = interval.tick() => {
-                        Self::process_heal_queue(&heal_queue, &active_heals, &config, &statistics, &storage).await;
-                    }
-                }
-            }
-        });
-
-        Ok(())
-    }
-
-    /// Start background task to auto scan local disks and enqueue erasure set heal requests
-    async fn start_auto_disk_scanner(&self) -> Result<()> {
-        let config = self.config.clone();
-        let heal_queue = self.heal_queue.clone();
-        let active_heals = self.active_heals.clone();
-        let cancel_token = self.cancel_token.clone();
-        let storage = self.storage.clone();
-
-        tokio::spawn(async move {
-            let mut interval = interval(config.read().await.heal_interval);
-
-            loop {
-                tokio::select! {
-                    _ = cancel_token.cancelled() => {
-                        info!("Auto disk scanner received shutdown signal");
-                        break;
-                    }
-                    _ = interval.tick() => {
-                        // Build list of endpoints that need healing
-                        let mut endpoints = Vec::new();
-                        for (_, disk_opt) in GLOBAL_LOCAL_DISK_MAP.read().await.iter() {
-                            if let Some(disk) = disk_opt {
-                                // detect unformatted disk via get_disk_id()
-                                if let Err(err) = disk.get_disk_id().await {
-                                    if err == DiskError::UnformattedDisk {
-                                        endpoints.push(disk.endpoint());
-                                        continue;
-                                    }
-                                }
-                            }
-                        }
-
-                        if endpoints.is_empty() {
-                            continue;
-                        }
-
-                        // Get bucket list for erasure set healing
-                        let buckets = match storage.list_buckets().await {
-                            Ok(buckets) => buckets.iter().map(|b| b.name.clone()).collect::<Vec<String>>(),
-                            Err(e) => {
-                                error!("Failed to get bucket list for auto healing: {}", e);
-                                continue;
-                            }
-                        };
-
-                        // Create erasure set heal requests for each endpoint
-                        for ep in endpoints {
-                            // skip if already queued or healing
-                            let mut skip = false;
-                            {
-                                let queue = heal_queue.lock().await;
-                                if queue.iter().any(|req| matches!(&req.heal_type, crate::heal::task::HealType::ErasureSet { set_disk_id, .. } if set_disk_id == &format!("{}_{}", ep.pool_idx, ep.set_idx))) {
-                                    skip = true;
-                                }
-                            }
-                            if !skip {
-                                let active = active_heals.lock().await;
-                                if active.values().any(|task| matches!(&task.heal_type, crate::heal::task::HealType::ErasureSet { set_disk_id, .. } if set_disk_id == &format!("{}_{}", ep.pool_idx, ep.set_idx))) {
-                                    skip = true;
-                                }
-                            }
-
-                            if skip {
-                                continue;
-                            }
-
-                            // enqueue erasure set heal request for this disk
-                            let set_disk_id = format!("pool_{}_set_{}", ep.pool_idx, ep.set_idx);
-                            let req = HealRequest::new(
-                                HealType::ErasureSet {
-                                    buckets: buckets.clone(),
-                                    set_disk_id: set_disk_id.clone()
-                                },
-                                HealOptions::default(),
-                                HealPriority::Normal,
-                            );
-                            let mut queue = heal_queue.lock().await;
-                            queue.push_back(req);
-                            info!("Enqueued auto erasure set heal for endpoint: {} (set_disk_id: {})", ep, set_disk_id);
-                        }
-                    }
-                }
-            }
-        });
-        Ok(())
-    }
-
-    /// Process heal queue
-    async fn process_heal_queue(
-        heal_queue: &Arc<Mutex<VecDeque<HealRequest>>>,
-        active_heals: &Arc<Mutex<HashMap<String, Arc<HealTask>>>>,
-        config: &Arc<RwLock<HealConfig>>,
-        statistics: &Arc<RwLock<HealStatistics>>,
-        storage: &Arc<dyn HealStorageAPI>,
-    ) {
-        let config = config.read().await;
-        let mut active_heals_guard = active_heals.lock().await;
-
-        // check if new heal tasks can be started
-        if active_heals_guard.len() >= config.max_concurrent_heals {
-            return;
-        }
-
-        let mut queue = heal_queue.lock().await;
-        if let Some(request) = queue.pop_front() {
-            let task = Arc::new(HealTask::from_request(request, storage.clone()));
-            let task_id = task.id.clone();
-            active_heals_guard.insert(task_id.clone(), task.clone());
-            drop(active_heals_guard);
-            let active_heals_clone = active_heals.clone();
-            let statistics_clone = statistics.clone();
-
-            // start heal task
-            tokio::spawn(async move {
-                info!("Starting heal task: {}", task_id);
-                let result = task.execute().await;
-                match result {
-                    Ok(_) => {
-                        info!("Heal task completed successfully: {}", task_id);
-                    }
-                    Err(e) => {
-                        error!("Heal task failed: {} - {}", task_id, e);
-                    }
-                }
-                let mut active_heals_guard = active_heals_clone.lock().await;
-                if let Some(completed_task) = active_heals_guard.remove(&task_id) {
-                    // update statistics
-                    let mut stats = statistics_clone.write().await;
-                    match completed_task.get_status().await {
-                        HealTaskStatus::Completed => {
-                            stats.update_task_completion(true);
-                        }
-                        _ => {
-                            stats.update_task_completion(false);
-                        }
-                    }
-                    stats.update_running_tasks(active_heals_guard.len() as u64);
-                }
-            });
-
-            // update statistics
-            let mut stats = statistics.write().await;
-            stats.total_tasks += 1;
-        }
-    }
-}
-
-impl std::fmt::Debug for HealManager {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("HealManager")
-            .field("config", &"<config>")
-            .field("state", &"<state>")
-            .field("active_heals_count", &"<active_heals>")
-            .field("queue_length", &"<queue>")
-            .finish()
-    }
-}

crates/ahm/src/heal/mod.rs

@@ -1,27 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-pub mod channel;
-pub mod erasure_healer;
-pub mod event;
-pub mod manager;
-pub mod progress;
-pub mod resume;
-pub mod storage;
-pub mod task;
-
-pub use erasure_healer::ErasureSetHealer;
-pub use manager::HealManager;
-pub use resume::{CheckpointManager, ResumeCheckpoint, ResumeManager, ResumeState, ResumeUtils};
-pub use task::{HealOptions, HealPriority, HealRequest, HealTask, HealType};

crates/ahm/src/heal/progress.rs

@@ -1,148 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use serde::{Deserialize, Serialize};
-use std::time::SystemTime;
-
-#[derive(Debug, Default, Clone, Serialize, Deserialize)]
-pub struct HealProgress {
-    /// Objects scanned
-    pub objects_scanned: u64,
-    /// Objects healed
-    pub objects_healed: u64,
-    /// Objects failed
-    pub objects_failed: u64,
-    /// Bytes processed
-    pub bytes_processed: u64,
-    /// Current object
-    pub current_object: Option<String>,
-    /// Progress percentage
-    pub progress_percentage: f64,
-    /// Start time
-    pub start_time: Option<SystemTime>,
-    /// Last update time
-    pub last_update_time: Option<SystemTime>,
-    /// Estimated completion time
-    pub estimated_completion_time: Option<SystemTime>,
-}
-
-impl HealProgress {
-    pub fn new() -> Self {
-        Self {
-            start_time: Some(SystemTime::now()),
-            last_update_time: Some(SystemTime::now()),
-            ..Default::default()
-        }
-    }
-
-    pub fn update_progress(&mut self, scanned: u64, healed: u64, failed: u64, bytes: u64) {
-        self.objects_scanned = scanned;
-        self.objects_healed = healed;
-        self.objects_failed = failed;
-        self.bytes_processed = bytes;
-        self.last_update_time = Some(SystemTime::now());
-
-        // calculate progress percentage
-        let total = scanned + healed + failed;
-        if total > 0 {
-            self.progress_percentage = (healed as f64 / total as f64) * 100.0;
-        }
-    }
-
-    pub fn set_current_object(&mut self, object: Option<String>) {
-        self.current_object = object;
-        self.last_update_time = Some(SystemTime::now());
-    }
-
-    pub fn is_completed(&self) -> bool {
-        self.progress_percentage >= 100.0
-            || self.objects_scanned > 0 && self.objects_healed + self.objects_failed >= self.objects_scanned
-    }
-
-    pub fn get_success_rate(&self) -> f64 {
-        let total = self.objects_healed + self.objects_failed;
-        if total > 0 {
-            (self.objects_healed as f64 / total as f64) * 100.0
-        } else {
-            0.0
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct HealStatistics {
-    /// Total heal tasks
-    pub total_tasks: u64,
-    /// Successful tasks
-    pub successful_tasks: u64,
-    /// Failed tasks
-    pub failed_tasks: u64,
-    /// Running tasks
-    pub running_tasks: u64,
-    /// Total healed objects
-    pub total_objects_healed: u64,
-    /// Total healed bytes
-    pub total_bytes_healed: u64,
-    /// Last update time
-    pub last_update_time: SystemTime,
-}
-
-impl Default for HealStatistics {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl HealStatistics {
-    pub fn new() -> Self {
-        Self {
-            total_tasks: 0,
-            successful_tasks: 0,
-            failed_tasks: 0,
-            running_tasks: 0,
-            total_objects_healed: 0,
-            total_bytes_healed: 0,
-            last_update_time: SystemTime::now(),
-        }
-    }
-
-    pub fn update_task_completion(&mut self, success: bool) {
-        if success {
-            self.successful_tasks += 1;
-        } else {
-            self.failed_tasks += 1;
-        }
-        self.last_update_time = SystemTime::now();
-    }
-
-    pub fn update_running_tasks(&mut self, count: u64) {
-        self.running_tasks = count;
-        self.last_update_time = SystemTime::now();
-    }
-
-    pub fn add_healed_objects(&mut self, count: u64, bytes: u64) {
-        self.total_objects_healed += count;
-        self.total_bytes_healed += bytes;
-        self.last_update_time = SystemTime::now();
-    }
-
-    pub fn get_success_rate(&self) -> f64 {
-        let total = self.successful_tasks + self.failed_tasks;
-        if total > 0 {
-            (self.successful_tasks as f64 / total as f64) * 100.0
-        } else {
-            0.0
-        }
-    }
-}

crates/ahm/src/heal/resume.rs

@@ -1,696 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use crate::error::{Error, Result};
-use rustfs_ecstore::disk::{BUCKET_META_PREFIX, DiskAPI, DiskStore, RUSTFS_META_BUCKET};
-use serde::{Deserialize, Serialize};
-use std::path::Path;
-use std::sync::Arc;
-use std::time::{SystemTime, UNIX_EPOCH};
-use tokio::sync::RwLock;
-use tracing::{debug, info, warn};
-use uuid::Uuid;
-
-/// resume state file constants
-const RESUME_STATE_FILE: &str = "ahm_resume_state.json";
-const RESUME_PROGRESS_FILE: &str = "ahm_progress.json";
-const RESUME_CHECKPOINT_FILE: &str = "ahm_checkpoint.json";
-
-/// resume state
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ResumeState {
-    /// task id
-    pub task_id: String,
-    /// task type
-    pub task_type: String,
-    /// start time
-    pub start_time: u64,
-    /// last update time
-    pub last_update: u64,
-    /// completed
-    pub completed: bool,
-    /// total objects
-    pub total_objects: u64,
-    /// processed objects
-    pub processed_objects: u64,
-    /// successful objects
-    pub successful_objects: u64,
-    /// failed objects
-    pub failed_objects: u64,
-    /// skipped objects
-    pub skipped_objects: u64,
-    /// current bucket
-    pub current_bucket: Option<String>,
-    /// current object
-    pub current_object: Option<String>,
-    /// completed buckets
-    pub completed_buckets: Vec<String>,
-    /// pending buckets
-    pub pending_buckets: Vec<String>,
-    /// error message
-    pub error_message: Option<String>,
-    /// retry count
-    pub retry_count: u32,
-    /// max retries
-    pub max_retries: u32,
-}
-
-impl ResumeState {
-    pub fn new(task_id: String, task_type: String, buckets: Vec<String>) -> Self {
-        Self {
-            task_id,
-            task_type,
-            start_time: SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs(),
-            last_update: SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs(),
-            completed: false,
-            total_objects: 0,
-            processed_objects: 0,
-            successful_objects: 0,
-            failed_objects: 0,
-            skipped_objects: 0,
-            current_bucket: None,
-            current_object: None,
-            completed_buckets: Vec::new(),
-            pending_buckets: buckets,
-            error_message: None,
-            retry_count: 0,
-            max_retries: 3,
-        }
-    }
-
-    pub fn update_progress(&mut self, processed: u64, successful: u64, failed: u64, skipped: u64) {
-        self.processed_objects = processed;
-        self.successful_objects = successful;
-        self.failed_objects = failed;
-        self.skipped_objects = skipped;
-        self.last_update = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
-    }
-
-    pub fn set_current_item(&mut self, bucket: Option<String>, object: Option<String>) {
-        self.current_bucket = bucket;
-        self.current_object = object;
-        self.last_update = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
-    }
-
-    pub fn complete_bucket(&mut self, bucket: &str) {
-        if !self.completed_buckets.contains(&bucket.to_string()) {
-            self.completed_buckets.push(bucket.to_string());
-        }
-        if let Some(pos) = self.pending_buckets.iter().position(|b| b == bucket) {
-            self.pending_buckets.remove(pos);
-        }
-        self.last_update = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
-    }
-
-    pub fn mark_completed(&mut self) {
-        self.completed = true;
-        self.last_update = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
-    }
-
-    pub fn set_error(&mut self, error: String) {
-        self.error_message = Some(error);
-        self.last_update = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
-    }
-
-    pub fn increment_retry(&mut self) {
-        self.retry_count += 1;
-        self.last_update = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
-    }
-
-    pub fn can_retry(&self) -> bool {
-        self.retry_count < self.max_retries
-    }
-
-    pub fn get_progress_percentage(&self) -> f64 {
-        if self.total_objects == 0 {
-            return 0.0;
-        }
-        (self.processed_objects as f64 / self.total_objects as f64) * 100.0
-    }
-
-    pub fn get_success_rate(&self) -> f64 {
-        let total = self.successful_objects + self.failed_objects;
-        if total == 0 {
-            return 0.0;
-        }
-        (self.successful_objects as f64 / total as f64) * 100.0
-    }
-}
-
-/// resume manager
-pub struct ResumeManager {
-    disk: DiskStore,
-    state: Arc<RwLock<ResumeState>>,
-}
-
-impl ResumeManager {
-    /// create new resume manager
-    pub async fn new(disk: DiskStore, task_id: String, task_type: String, buckets: Vec<String>) -> Result<Self> {
-        let state = ResumeState::new(task_id, task_type, buckets);
-        let manager = Self {
-            disk,
-            state: Arc::new(RwLock::new(state)),
-        };
-
-        // save initial state
-        manager.save_state().await?;
-        Ok(manager)
-    }
-
-    /// load resume state from disk
-    pub async fn load_from_disk(disk: DiskStore, task_id: &str) -> Result<Self> {
-        let state_data = Self::read_state_file(&disk, task_id).await?;
-        let state: ResumeState = serde_json::from_slice(&state_data).map_err(|e| Error::TaskExecutionFailed {
-            message: format!("Failed to deserialize resume state: {e}"),
-        })?;
-
-        Ok(Self {
-            disk,
-            state: Arc::new(RwLock::new(state)),
-        })
-    }
-
-    /// check if resume state exists
-    pub async fn has_resume_state(disk: &DiskStore, task_id: &str) -> bool {
-        let file_path = Path::new(BUCKET_META_PREFIX).join(format!("{task_id}_{RESUME_STATE_FILE}"));
-        match disk.read_all(RUSTFS_META_BUCKET, file_path.to_str().unwrap()).await {
-            Ok(data) => !data.is_empty(),
-            Err(_) => false,
-        }
-    }
-
-    /// get current state
-    pub async fn get_state(&self) -> ResumeState {
-        self.state.read().await.clone()
-    }
-
-    /// update progress
-    pub async fn update_progress(&self, processed: u64, successful: u64, failed: u64, skipped: u64) -> Result<()> {
-        let mut state = self.state.write().await;
-        state.update_progress(processed, successful, failed, skipped);
-        drop(state);
-        self.save_state().await
-    }
-
-    /// set current item
-    pub async fn set_current_item(&self, bucket: Option<String>, object: Option<String>) -> Result<()> {
-        let mut state = self.state.write().await;
-        state.set_current_item(bucket, object);
-        drop(state);
-        self.save_state().await
-    }
-
-    /// complete bucket
-    pub async fn complete_bucket(&self, bucket: &str) -> Result<()> {
-        let mut state = self.state.write().await;
-        state.complete_bucket(bucket);
-        drop(state);
-        self.save_state().await
-    }
-
-    /// mark task completed
-    pub async fn mark_completed(&self) -> Result<()> {
-        let mut state = self.state.write().await;
-        state.mark_completed();
-        drop(state);
-        self.save_state().await
-    }
-
-    /// set error message
-    pub async fn set_error(&self, error: String) -> Result<()> {
-        let mut state = self.state.write().await;
-        state.set_error(error);
-        drop(state);
-        self.save_state().await
-    }
-
-    /// increment retry count
-    pub async fn increment_retry(&self) -> Result<()> {
-        let mut state = self.state.write().await;
-        state.increment_retry();
-        drop(state);
-        self.save_state().await
-    }
-
-    /// cleanup resume state
-    pub async fn cleanup(&self) -> Result<()> {
-        let state = self.state.read().await;
-        let task_id = &state.task_id;
-
-        // delete state files
-        let state_file = Path::new(BUCKET_META_PREFIX).join(format!("{task_id}_{RESUME_STATE_FILE}"));
-        let progress_file = Path::new(BUCKET_META_PREFIX).join(format!("{task_id}_{RESUME_PROGRESS_FILE}"));
-        let checkpoint_file = Path::new(BUCKET_META_PREFIX).join(format!("{task_id}_{RESUME_CHECKPOINT_FILE}"));
-
-        // ignore delete errors, files may not exist
-        let _ = self
-            .disk
-            .delete(RUSTFS_META_BUCKET, state_file.to_str().unwrap(), Default::default())
-            .await;
-        let _ = self
-            .disk
-            .delete(RUSTFS_META_BUCKET, progress_file.to_str().unwrap(), Default::default())
-            .await;
-        let _ = self
-            .disk
-            .delete(RUSTFS_META_BUCKET, checkpoint_file.to_str().unwrap(), Default::default())
-            .await;
-
-        info!("Cleaned up resume state for task: {}", task_id);
-        Ok(())
-    }
-
-    /// save state to disk
-    async fn save_state(&self) -> Result<()> {
-        let state = self.state.read().await;
-        let state_data = serde_json::to_vec(&*state).map_err(|e| Error::TaskExecutionFailed {
-            message: format!("Failed to serialize resume state: {e}"),
-        })?;
-
-        let file_path = Path::new(BUCKET_META_PREFIX).join(format!("{}_{}", state.task_id, RESUME_STATE_FILE));
-
-        self.disk
-            .write_all(RUSTFS_META_BUCKET, file_path.to_str().unwrap(), state_data.into())
-            .await
-            .map_err(|e| Error::TaskExecutionFailed {
-                message: format!("Failed to save resume state: {e}"),
-            })?;
-
-        debug!("Saved resume state for task: {}", state.task_id);
-        Ok(())
-    }
-
-    /// read state file from disk
-    async fn read_state_file(disk: &DiskStore, task_id: &str) -> Result<Vec<u8>> {
-        let file_path = Path::new(BUCKET_META_PREFIX).join(format!("{task_id}_{RESUME_STATE_FILE}"));
-
-        disk.read_all(RUSTFS_META_BUCKET, file_path.to_str().unwrap())
-            .await
-            .map(|bytes| bytes.to_vec())
-            .map_err(|e| Error::TaskExecutionFailed {
-                message: format!("Failed to read resume state file: {e}"),
-            })
-    }
-}
-
-/// resume checkpoint
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ResumeCheckpoint {
-    /// task id
-    pub task_id: String,
-    /// checkpoint time
-    pub checkpoint_time: u64,
-    /// current bucket index
-    pub current_bucket_index: usize,
-    /// current object index
-    pub current_object_index: usize,
-    /// processed objects
-    pub processed_objects: Vec<String>,
-    /// failed objects
-    pub failed_objects: Vec<String>,
-    /// skipped objects
-    pub skipped_objects: Vec<String>,
-}
-
-impl ResumeCheckpoint {
-    pub fn new(task_id: String) -> Self {
-        Self {
-            task_id,
-            checkpoint_time: SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs(),
-            current_bucket_index: 0,
-            current_object_index: 0,
-            processed_objects: Vec::new(),
-            failed_objects: Vec::new(),
-            skipped_objects: Vec::new(),
-        }
-    }
-
-    pub fn update_position(&mut self, bucket_index: usize, object_index: usize) {
-        self.current_bucket_index = bucket_index;
-        self.current_object_index = object_index;
-        self.checkpoint_time = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
-    }
-
-    pub fn add_processed_object(&mut self, object: String) {
-        if !self.processed_objects.contains(&object) {
-            self.processed_objects.push(object);
-        }
-    }
-
-    pub fn add_failed_object(&mut self, object: String) {
-        if !self.failed_objects.contains(&object) {
-            self.failed_objects.push(object);
-        }
-    }
-
-    pub fn add_skipped_object(&mut self, object: String) {
-        if !self.skipped_objects.contains(&object) {
-            self.skipped_objects.push(object);
-        }
-    }
-}
-
-/// resume checkpoint manager
-pub struct CheckpointManager {
-    disk: DiskStore,
-    checkpoint: Arc<RwLock<ResumeCheckpoint>>,
-}
-
-impl CheckpointManager {
-    /// create new checkpoint manager
-    pub async fn new(disk: DiskStore, task_id: String) -> Result<Self> {
-        let checkpoint = ResumeCheckpoint::new(task_id);
-        let manager = Self {
-            disk,
-            checkpoint: Arc::new(RwLock::new(checkpoint)),
-        };
-
-        // save initial checkpoint
-        manager.save_checkpoint().await?;
-        Ok(manager)
-    }
-
-    /// load checkpoint from disk
-    pub async fn load_from_disk(disk: DiskStore, task_id: &str) -> Result<Self> {
-        let checkpoint_data = Self::read_checkpoint_file(&disk, task_id).await?;
-        let checkpoint: ResumeCheckpoint = serde_json::from_slice(&checkpoint_data).map_err(|e| Error::TaskExecutionFailed {
-            message: format!("Failed to deserialize checkpoint: {e}"),
-        })?;
-
-        Ok(Self {
-            disk,
-            checkpoint: Arc::new(RwLock::new(checkpoint)),
-        })
-    }
-
-    /// check if checkpoint exists
-    pub async fn has_checkpoint(disk: &DiskStore, task_id: &str) -> bool {
-        let file_path = Path::new(BUCKET_META_PREFIX).join(format!("{task_id}_{RESUME_CHECKPOINT_FILE}"));
-        match disk.read_all(RUSTFS_META_BUCKET, file_path.to_str().unwrap()).await {
-            Ok(data) => !data.is_empty(),
-            Err(_) => false,
-        }
-    }
-
-    /// get current checkpoint
-    pub async fn get_checkpoint(&self) -> ResumeCheckpoint {
-        self.checkpoint.read().await.clone()
-    }
-
-    /// update position
-    pub async fn update_position(&self, bucket_index: usize, object_index: usize) -> Result<()> {
-        let mut checkpoint = self.checkpoint.write().await;
-        checkpoint.update_position(bucket_index, object_index);
-        drop(checkpoint);
-        self.save_checkpoint().await
-    }
-
-    /// add processed object
-    pub async fn add_processed_object(&self, object: String) -> Result<()> {
-        let mut checkpoint = self.checkpoint.write().await;
-        checkpoint.add_processed_object(object);
-        drop(checkpoint);
-        self.save_checkpoint().await
-    }
-
-    /// add failed object
-    pub async fn add_failed_object(&self, object: String) -> Result<()> {
-        let mut checkpoint = self.checkpoint.write().await;
-        checkpoint.add_failed_object(object);
-        drop(checkpoint);
-        self.save_checkpoint().await
-    }
-
-    /// add skipped object
-    pub async fn add_skipped_object(&self, object: String) -> Result<()> {
-        let mut checkpoint = self.checkpoint.write().await;
-        checkpoint.add_skipped_object(object);
-        drop(checkpoint);
-        self.save_checkpoint().await
-    }
-
-    /// cleanup checkpoint
-    pub async fn cleanup(&self) -> Result<()> {
-        let checkpoint = self.checkpoint.read().await;
-        let task_id = &checkpoint.task_id;
-
-        let checkpoint_file = Path::new(BUCKET_META_PREFIX).join(format!("{task_id}_{RESUME_CHECKPOINT_FILE}"));
-        let _ = self
-            .disk
-            .delete(RUSTFS_META_BUCKET, checkpoint_file.to_str().unwrap(), Default::default())
-            .await;
-
-        info!("Cleaned up checkpoint for task: {}", task_id);
-        Ok(())
-    }
-
-    /// save checkpoint to disk
-    async fn save_checkpoint(&self) -> Result<()> {
-        let checkpoint = self.checkpoint.read().await;
-        let checkpoint_data = serde_json::to_vec(&*checkpoint).map_err(|e| Error::TaskExecutionFailed {
-            message: format!("Failed to serialize checkpoint: {e}"),
-        })?;
-
-        let file_path = Path::new(BUCKET_META_PREFIX).join(format!("{}_{}", checkpoint.task_id, RESUME_CHECKPOINT_FILE));
-
-        self.disk
-            .write_all(RUSTFS_META_BUCKET, file_path.to_str().unwrap(), checkpoint_data.into())
-            .await
-            .map_err(|e| Error::TaskExecutionFailed {
-                message: format!("Failed to save checkpoint: {e}"),
-            })?;
-
-        debug!("Saved checkpoint for task: {}", checkpoint.task_id);
-        Ok(())
-    }
-
-    /// read checkpoint file from disk
-    async fn read_checkpoint_file(disk: &DiskStore, task_id: &str) -> Result<Vec<u8>> {
-        let file_path = Path::new(BUCKET_META_PREFIX).join(format!("{task_id}_{RESUME_CHECKPOINT_FILE}"));
-
-        disk.read_all(RUSTFS_META_BUCKET, file_path.to_str().unwrap())
-            .await
-            .map(|bytes| bytes.to_vec())
-            .map_err(|e| Error::TaskExecutionFailed {
-                message: format!("Failed to read checkpoint file: {e}"),
-            })
-    }
-}
-
-/// resume utils
-pub struct ResumeUtils;
-
-impl ResumeUtils {
-    /// generate unique task id
-    pub fn generate_task_id() -> String {
-        Uuid::new_v4().to_string()
-    }
-
-    /// check if task can be resumed
-    pub async fn can_resume_task(disk: &DiskStore, task_id: &str) -> bool {
-        ResumeManager::has_resume_state(disk, task_id).await
-    }
-
-    /// get all resumable task ids
-    pub async fn get_resumable_tasks(disk: &DiskStore) -> Result<Vec<String>> {
-        // List all files in the buckets metadata directory
-        let entries = match disk.list_dir("", RUSTFS_META_BUCKET, BUCKET_META_PREFIX, -1).await {
-            Ok(entries) => entries,
-            Err(e) => {
-                debug!("Failed to list resume state files: {}", e);
-                return Ok(Vec::new());
-            }
-        };
-
-        let mut task_ids = Vec::new();
-
-        // Filter files that end with ahm_resume_state.json and extract task IDs
-        for entry in entries {
-            if entry.ends_with(&format!("_{RESUME_STATE_FILE}")) {
-                // Extract task ID from filename: {task_id}_ahm_resume_state.json
-                if let Some(task_id) = entry.strip_suffix(&format!("_{RESUME_STATE_FILE}")) {
-                    if !task_id.is_empty() {
-                        task_ids.push(task_id.to_string());
-                    }
-                }
-            }
-        }
-
-        debug!("Found {} resumable tasks: {:?}", task_ids.len(), task_ids);
-        Ok(task_ids)
-    }
-
-    /// cleanup expired resume states
-    pub async fn cleanup_expired_states(disk: &DiskStore, max_age_hours: u64) -> Result<()> {
-        let task_ids = Self::get_resumable_tasks(disk).await?;
-        let current_time = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
-
-        for task_id in task_ids {
-            if let Ok(resume_manager) = ResumeManager::load_from_disk(disk.clone(), &task_id).await {
-                let state = resume_manager.get_state().await;
-                let age_hours = (current_time - state.last_update) / 3600;
-
-                if age_hours > max_age_hours {
-                    info!("Cleaning up expired resume state for task: {} (age: {} hours)", task_id, age_hours);
-                    if let Err(e) = resume_manager.cleanup().await {
-                        warn!("Failed to cleanup expired resume state for task {}: {}", task_id, e);
-                    }
-                }
-            }
-        }
-
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[tokio::test]
-    async fn test_resume_state_creation() {
-        let task_id = ResumeUtils::generate_task_id();
-        let buckets = vec!["bucket1".to_string(), "bucket2".to_string()];
-        let state = ResumeState::new(task_id.clone(), "erasure_set".to_string(), buckets);
-
-        assert_eq!(state.task_id, task_id);
-        assert_eq!(state.task_type, "erasure_set");
-        assert!(!state.completed);
-        assert_eq!(state.processed_objects, 0);
-        assert_eq!(state.pending_buckets.len(), 2);
-    }
-
-    #[tokio::test]
-    async fn test_resume_state_progress() {
-        let task_id = ResumeUtils::generate_task_id();
-        let buckets = vec!["bucket1".to_string()];
-        let mut state = ResumeState::new(task_id, "erasure_set".to_string(), buckets);
-
-        state.update_progress(10, 8, 1, 1);
-        assert_eq!(state.processed_objects, 10);
-        assert_eq!(state.successful_objects, 8);
-        assert_eq!(state.failed_objects, 1);
-        assert_eq!(state.skipped_objects, 1);
-
-        let progress = state.get_progress_percentage();
-        assert_eq!(progress, 0.0); // total_objects is 0
-
-        state.total_objects = 100;
-        let progress = state.get_progress_percentage();
-        assert_eq!(progress, 10.0);
-    }
-
-    #[tokio::test]
-    async fn test_resume_state_bucket_completion() {
-        let task_id = ResumeUtils::generate_task_id();
-        let buckets = vec!["bucket1".to_string(), "bucket2".to_string()];
-        let mut state = ResumeState::new(task_id, "erasure_set".to_string(), buckets);
-
-        assert_eq!(state.pending_buckets.len(), 2);
-        assert_eq!(state.completed_buckets.len(), 0);
-
-        state.complete_bucket("bucket1");
-        assert_eq!(state.pending_buckets.len(), 1);
-        assert_eq!(state.completed_buckets.len(), 1);
-        assert!(state.completed_buckets.contains(&"bucket1".to_string()));
-    }
-
-    #[tokio::test]
-    async fn test_resume_utils() {
-        let task_id1 = ResumeUtils::generate_task_id();
-        let task_id2 = ResumeUtils::generate_task_id();
-
-        assert_ne!(task_id1, task_id2);
-        assert_eq!(task_id1.len(), 36); // UUID length
-        assert_eq!(task_id2.len(), 36);
-    }
-
-    #[tokio::test]
-    async fn test_get_resumable_tasks_integration() {
-        use rustfs_ecstore::disk::{DiskOption, endpoint::Endpoint, new_disk};
-        use tempfile::TempDir;
-
-        // Create a temporary directory for testing
-        let temp_dir = TempDir::new().unwrap();
-        let disk_path = temp_dir.path().join("test_disk");
-        std::fs::create_dir_all(&disk_path).unwrap();
-
-        // Create a local disk for testing
-        let endpoint = Endpoint::try_from(disk_path.to_string_lossy().as_ref()).unwrap();
-        let disk_option = DiskOption {
-            cleanup: false,
-            health_check: false,
-        };
-        let disk = new_disk(&endpoint, &disk_option).await.unwrap();
-
-        // Create necessary directories first (ignore if already exist)
-        let _ = disk.make_volume(RUSTFS_META_BUCKET).await;
-        let _ = disk.make_volume(&format!("{RUSTFS_META_BUCKET}/{BUCKET_META_PREFIX}")).await;
-
-        // Create some test resume state files
-        let task_ids = vec![
-            "test-task-1".to_string(),
-            "test-task-2".to_string(),
-            "test-task-3".to_string(),
-        ];
-
-        // Save resume state files for each task
-        for task_id in &task_ids {
-            let state = ResumeState::new(
-                task_id.clone(),
-                "erasure_set".to_string(),
-                vec!["bucket1".to_string(), "bucket2".to_string()],
-            );
-
-            let state_data = serde_json::to_vec(&state).unwrap();
-            let file_path = format!("{BUCKET_META_PREFIX}/{task_id}_{RESUME_STATE_FILE}");
-
-            disk.write_all(RUSTFS_META_BUCKET, &file_path, state_data.into())
-                .await
-                .unwrap();
-        }
-
-        // Also create some non-resume state files to test filtering
-        let non_resume_files = vec![
-            "other_file.txt",
-            "task4_ahm_checkpoint.json",
-            "task5_ahm_progress.json",
-            "_ahm_resume_state.json", // Invalid: empty task ID
-        ];
-
-        for file_name in non_resume_files {
-            let file_path = format!("{BUCKET_META_PREFIX}/{file_name}");
-            disk.write_all(RUSTFS_META_BUCKET, &file_path, b"test data".to_vec().into())
-                .await
-                .unwrap();
-        }
-
-        // Now call get_resumable_tasks to see if it finds the correct files
-        let found_task_ids = ResumeUtils::get_resumable_tasks(&disk).await.unwrap();
-
-        // Verify that only the valid resume state files are found
-        assert_eq!(found_task_ids.len(), 3);
-        for task_id in &task_ids {
-            assert!(found_task_ids.contains(task_id), "Task ID {task_id} not found");
-        }
-
-        // Verify that invalid files are not included
-        assert!(!found_task_ids.contains(&"".to_string()));
-        assert!(!found_task_ids.contains(&"task4".to_string()));
-        assert!(!found_task_ids.contains(&"task5".to_string()));
-
-        // Clean up
-        temp_dir.close().unwrap();
-    }
-}

crates/ahm/src/heal/storage.rs

@@ -1,544 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use crate::error::{Error, Result};
-use async_trait::async_trait;
-use rustfs_common::heal_channel::{HealOpts, HealScanMode};
-use rustfs_ecstore::{
-    disk::{DiskStore, endpoint::Endpoint},
-    store::ECStore,
-    store_api::{BucketInfo, ObjectIO, StorageAPI},
-};
-use rustfs_madmin::heal_commands::HealResultItem;
-use std::sync::Arc;
-use tracing::{debug, error, info, warn};
-
-/// Disk status for heal operations
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum DiskStatus {
-    /// Ok
-    Ok,
-    /// Offline
-    Offline,
-    /// Corrupt
-    Corrupt,
-    /// Missing
-    Missing,
-    /// Permission denied
-    PermissionDenied,
-    /// Faulty
-    Faulty,
-    /// Root mount
-    RootMount,
-    /// Unknown
-    Unknown,
-    /// Unformatted
-    Unformatted,
-}
-
-/// Heal storage layer interface
-#[async_trait]
-pub trait HealStorageAPI: Send + Sync {
-    /// Get object meta
-    async fn get_object_meta(&self, bucket: &str, object: &str) -> Result<Option<rustfs_ecstore::store_api::ObjectInfo>>;
-
-    /// Get object data
-    async fn get_object_data(&self, bucket: &str, object: &str) -> Result<Option<Vec<u8>>>;
-
-    /// Put object data
-    async fn put_object_data(&self, bucket: &str, object: &str, data: &[u8]) -> Result<()>;
-
-    /// Delete object
-    async fn delete_object(&self, bucket: &str, object: &str) -> Result<()>;
-
-    /// Check object integrity
-    async fn verify_object_integrity(&self, bucket: &str, object: &str) -> Result<bool>;
-
-    /// EC decode rebuild
-    async fn ec_decode_rebuild(&self, bucket: &str, object: &str) -> Result<Vec<u8>>;
-
-    /// Get disk status
-    async fn get_disk_status(&self, endpoint: &Endpoint) -> Result<DiskStatus>;
-
-    /// Format disk
-    async fn format_disk(&self, endpoint: &Endpoint) -> Result<()>;
-
-    /// Get bucket info
-    async fn get_bucket_info(&self, bucket: &str) -> Result<Option<BucketInfo>>;
-
-    /// Fix bucket metadata
-    async fn heal_bucket_metadata(&self, bucket: &str) -> Result<()>;
-
-    /// Get all buckets
-    async fn list_buckets(&self) -> Result<Vec<BucketInfo>>;
-
-    /// Check object exists
-    async fn object_exists(&self, bucket: &str, object: &str) -> Result<bool>;
-
-    /// Get object size
-    async fn get_object_size(&self, bucket: &str, object: &str) -> Result<Option<u64>>;
-
-    /// Get object checksum
-    async fn get_object_checksum(&self, bucket: &str, object: &str) -> Result<Option<String>>;
-
-    /// Heal object using ecstore
-    async fn heal_object(
-        &self,
-        bucket: &str,
-        object: &str,
-        version_id: Option<&str>,
-        opts: &HealOpts,
-    ) -> Result<(HealResultItem, Option<Error>)>;
-
-    /// Heal bucket using ecstore
-    async fn heal_bucket(&self, bucket: &str, opts: &HealOpts) -> Result<HealResultItem>;
-
-    /// Heal format using ecstore
-    async fn heal_format(&self, dry_run: bool) -> Result<(HealResultItem, Option<Error>)>;
-
-    /// List objects for healing
-    async fn list_objects_for_heal(&self, bucket: &str, prefix: &str) -> Result<Vec<String>>;
-
-    /// Get disk for resume functionality
-    async fn get_disk_for_resume(&self, set_disk_id: &str) -> Result<DiskStore>;
-}
-
-/// ECStore Heal storage layer implementation
-pub struct ECStoreHealStorage {
-    ecstore: Arc<ECStore>,
-}
-
-impl ECStoreHealStorage {
-    pub fn new(ecstore: Arc<ECStore>) -> Self {
-        Self { ecstore }
-    }
-}
-
-#[async_trait]
-impl HealStorageAPI for ECStoreHealStorage {
-    async fn get_object_meta(&self, bucket: &str, object: &str) -> Result<Option<rustfs_ecstore::store_api::ObjectInfo>> {
-        debug!("Getting object meta: {}/{}", bucket, object);
-
-        match self.ecstore.get_object_info(bucket, object, &Default::default()).await {
-            Ok(info) => Ok(Some(info)),
-            Err(e) => {
-                // Map ObjectNotFound to None to align with Option return type
-                if matches!(e, rustfs_ecstore::error::StorageError::ObjectNotFound(_, _)) {
-                    debug!("Object meta not found: {}/{}", bucket, object);
-                    Ok(None)
-                } else {
-                    error!("Failed to get object meta: {}/{} - {}", bucket, object, e);
-                    Err(Error::other(e))
-                }
-            }
-        }
-    }
-
-    async fn get_object_data(&self, bucket: &str, object: &str) -> Result<Option<Vec<u8>>> {
-        debug!("Getting object data: {}/{}", bucket, object);
-
-        let reader = match (*self.ecstore)
-            .get_object_reader(bucket, object, None, Default::default(), &Default::default())
-            .await
-        {
-            Ok(reader) => reader,
-            Err(e) => {
-                error!("Failed to get object: {}/{} - {}", bucket, object, e);
-                return Err(Error::other(e));
-            }
-        };
-
-        // WARNING: Returning Vec<u8> for large objects is dangerous. To avoid OOM, cap the read size.
-        // If needed, refactor callers to stream instead of buffering entire object.
-        const MAX_READ_BYTES: usize = 16 * 1024 * 1024; // 16 MiB cap
-        let mut buf = Vec::with_capacity(1024 * 1024);
-        use tokio::io::AsyncReadExt as _;
-        let mut n_read: usize = 0;
-        let mut stream = reader.stream;
-        loop {
-            // Read in chunks
-            let mut chunk = vec![0u8; 1024 * 1024];
-            match stream.read(&mut chunk).await {
-                Ok(0) => break,
-                Ok(n) => {
-                    buf.extend_from_slice(&chunk[..n]);
-                    n_read += n;
-                    if n_read > MAX_READ_BYTES {
-                        warn!(
-                            "Object data exceeds cap ({} bytes), aborting full read to prevent OOM: {}/{}",
-                            MAX_READ_BYTES, bucket, object
-                        );
-                        return Ok(None);
-                    }
-                }
-                Err(e) => {
-                    error!("Failed to read object data: {}/{} - {}", bucket, object, e);
-                    return Err(Error::other(e));
-                }
-            }
-        }
-        Ok(Some(buf))
-    }
-
-    async fn put_object_data(&self, bucket: &str, object: &str, data: &[u8]) -> Result<()> {
-        debug!("Putting object data: {}/{} ({} bytes)", bucket, object, data.len());
-
-        let mut reader = rustfs_ecstore::store_api::PutObjReader::from_vec(data.to_vec());
-        match (*self.ecstore)
-            .put_object(bucket, object, &mut reader, &Default::default())
-            .await
-        {
-            Ok(_) => {
-                info!("Successfully put object: {}/{}", bucket, object);
-                Ok(())
-            }
-            Err(e) => {
-                error!("Failed to put object: {}/{} - {}", bucket, object, e);
-                Err(Error::other(e))
-            }
-        }
-    }
-
-    async fn delete_object(&self, bucket: &str, object: &str) -> Result<()> {
-        debug!("Deleting object: {}/{}", bucket, object);
-
-        match self.ecstore.delete_object(bucket, object, Default::default()).await {
-            Ok(_) => {
-                info!("Successfully deleted object: {}/{}", bucket, object);
-                Ok(())
-            }
-            Err(e) => {
-                error!("Failed to delete object: {}/{} - {}", bucket, object, e);
-                Err(Error::other(e))
-            }
-        }
-    }
-
-    async fn verify_object_integrity(&self, bucket: &str, object: &str) -> Result<bool> {
-        debug!("Verifying object integrity: {}/{}", bucket, object);
-
-        // Check object metadata first
-        match self.get_object_meta(bucket, object).await? {
-            Some(obj_info) => {
-                if obj_info.size < 0 {
-                    warn!("Object has invalid size: {}/{}", bucket, object);
-                    return Ok(false);
-                }
-
-                // Stream-read the object to a sink to avoid loading into memory
-                match (*self.ecstore)
-                    .get_object_reader(bucket, object, None, Default::default(), &Default::default())
-                    .await
-                {
-                    Ok(reader) => {
-                        let mut stream = reader.stream;
-                        match tokio::io::copy(&mut stream, &mut tokio::io::sink()).await {
-                            Ok(_) => {
-                                info!("Object integrity check passed: {}/{}", bucket, object);
-                                Ok(true)
-                            }
-                            Err(e) => {
-                                warn!("Object stream read failed: {}/{} - {}", bucket, object, e);
-                                Ok(false)
-                            }
-                        }
-                    }
-                    Err(e) => {
-                        warn!("Failed to get object reader: {}/{} - {}", bucket, object, e);
-                        Ok(false)
-                    }
-                }
-            }
-            None => {
-                warn!("Object metadata not found: {}/{}", bucket, object);
-                Ok(false)
-            }
-        }
-    }
-
-    async fn ec_decode_rebuild(&self, bucket: &str, object: &str) -> Result<Vec<u8>> {
-        debug!("EC decode rebuild: {}/{}", bucket, object);
-
-        // Use ecstore's heal_object to rebuild the object
-        let heal_opts = HealOpts {
-            recursive: false,
-            dry_run: false,
-            remove: false,
-            recreate: true,
-            scan_mode: HealScanMode::Deep,
-            update_parity: true,
-            no_lock: false,
-            pool: None,
-            set: None,
-        };
-
-        match self.heal_object(bucket, object, None, &heal_opts).await {
-            Ok((_result, error)) => {
-                if error.is_some() {
-                    return Err(Error::TaskExecutionFailed {
-                        message: format!("Heal failed: {error:?}"),
-                    });
-                }
-
-                // After healing, try to read the object data
-                match self.get_object_data(bucket, object).await? {
-                    Some(data) => {
-                        info!("EC decode rebuild successful: {}/{} ({} bytes)", bucket, object, data.len());
-                        Ok(data)
-                    }
-                    None => {
-                        error!("Object not found after heal: {}/{}", bucket, object);
-                        Err(Error::TaskExecutionFailed {
-                            message: format!("Object not found after heal: {bucket}/{object}"),
-                        })
-                    }
-                }
-            }
-            Err(e) => {
-                error!("Heal operation failed: {}/{} - {}", bucket, object, e);
-                Err(e)
-            }
-        }
-    }
-
-    async fn get_disk_status(&self, endpoint: &Endpoint) -> Result<DiskStatus> {
-        debug!("Getting disk status: {:?}", endpoint);
-
-        // TODO: implement disk status check using ecstore
-        // For now, return Ok status
-        info!("Disk status check: {:?} - OK", endpoint);
-        Ok(DiskStatus::Ok)
-    }
-
-    async fn format_disk(&self, endpoint: &Endpoint) -> Result<()> {
-        debug!("Formatting disk: {:?}", endpoint);
-
-        // Use ecstore's heal_format
-        match self.heal_format(false).await {
-            Ok((_, error)) => {
-                if error.is_some() {
-                    return Err(Error::other(format!("Format failed: {error:?}")));
-                }
-                info!("Successfully formatted disk: {:?}", endpoint);
-                Ok(())
-            }
-            Err(e) => {
-                error!("Failed to format disk: {:?} - {}", endpoint, e);
-                Err(e)
-            }
-        }
-    }
-
-    async fn get_bucket_info(&self, bucket: &str) -> Result<Option<BucketInfo>> {
-        debug!("Getting bucket info: {}", bucket);
-
-        match self.ecstore.get_bucket_info(bucket, &Default::default()).await {
-            Ok(info) => Ok(Some(info)),
-            Err(e) => {
-                error!("Failed to get bucket info: {} - {}", bucket, e);
-                Err(Error::other(e))
-            }
-        }
-    }
-
-    async fn heal_bucket_metadata(&self, bucket: &str) -> Result<()> {
-        debug!("Healing bucket metadata: {}", bucket);
-
-        let heal_opts = HealOpts {
-            recursive: true,
-            dry_run: false,
-            remove: false,
-            recreate: false,
-            scan_mode: HealScanMode::Normal,
-            update_parity: false,
-            no_lock: false,
-            pool: None,
-            set: None,
-        };
-
-        match self.heal_bucket(bucket, &heal_opts).await {
-            Ok(_) => {
-                info!("Successfully healed bucket metadata: {}", bucket);
-                Ok(())
-            }
-            Err(e) => {
-                error!("Failed to heal bucket metadata: {} - {}", bucket, e);
-                Err(e)
-            }
-        }
-    }
-
-    async fn list_buckets(&self) -> Result<Vec<BucketInfo>> {
-        debug!("Listing buckets");
-
-        match self.ecstore.list_bucket(&Default::default()).await {
-            Ok(buckets) => Ok(buckets),
-            Err(e) => {
-                error!("Failed to list buckets: {}", e);
-                Err(Error::other(e))
-            }
-        }
-    }
-
-    async fn object_exists(&self, bucket: &str, object: &str) -> Result<bool> {
-        debug!("Checking object exists: {}/{}", bucket, object);
-
-        match self.get_object_meta(bucket, object).await {
-            Ok(Some(_)) => Ok(true),
-            Ok(None) => Ok(false),
-            Err(_) => Ok(false),
-        }
-    }
-
-    async fn get_object_size(&self, bucket: &str, object: &str) -> Result<Option<u64>> {
-        debug!("Getting object size: {}/{}", bucket, object);
-
-        match self.get_object_meta(bucket, object).await {
-            Ok(Some(obj_info)) => Ok(Some(obj_info.size as u64)),
-            Ok(None) => Ok(None),
-            Err(e) => Err(e),
-        }
-    }
-
-    async fn get_object_checksum(&self, bucket: &str, object: &str) -> Result<Option<String>> {
-        debug!("Getting object checksum: {}/{}", bucket, object);
-
-        match self.get_object_meta(bucket, object).await {
-            Ok(Some(obj_info)) => {
-                // Convert checksum bytes to hex string
-                let checksum = obj_info.checksum.iter().map(|b| format!("{b:02x}")).collect::<String>();
-                Ok(Some(checksum))
-            }
-            Ok(None) => Ok(None),
-            Err(e) => Err(e),
-        }
-    }
-
-    async fn heal_object(
-        &self,
-        bucket: &str,
-        object: &str,
-        version_id: Option<&str>,
-        opts: &HealOpts,
-    ) -> Result<(HealResultItem, Option<Error>)> {
-        debug!("Healing object: {}/{}", bucket, object);
-
-        let version_id_str = version_id.unwrap_or("");
-
-        match self.ecstore.heal_object(bucket, object, version_id_str, opts).await {
-            Ok((result, ecstore_error)) => {
-                let error = ecstore_error.map(Error::other);
-                info!("Heal object completed: {}/{} - result: {:?}, error: {:?}", bucket, object, result, error);
-                Ok((result, error))
-            }
-            Err(e) => {
-                error!("Heal object failed: {}/{} - {}", bucket, object, e);
-                Err(Error::other(e))
-            }
-        }
-    }
-
-    async fn heal_bucket(&self, bucket: &str, opts: &HealOpts) -> Result<HealResultItem> {
-        debug!("Healing bucket: {}", bucket);
-
-        match self.ecstore.heal_bucket(bucket, opts).await {
-            Ok(result) => {
-                info!("Heal bucket completed: {} - result: {:?}", bucket, result);
-                Ok(result)
-            }
-            Err(e) => {
-                error!("Heal bucket failed: {} - {}", bucket, e);
-                Err(Error::other(e))
-            }
-        }
-    }
-
-    async fn heal_format(&self, dry_run: bool) -> Result<(HealResultItem, Option<Error>)> {
-        debug!("Healing format (dry_run: {})", dry_run);
-
-        match self.ecstore.heal_format(dry_run).await {
-            Ok((result, ecstore_error)) => {
-                let error = ecstore_error.map(Error::other);
-                info!("Heal format completed - result: {:?}, error: {:?}", result, error);
-                Ok((result, error))
-            }
-            Err(e) => {
-                error!("Heal format failed: {}", e);
-                Err(Error::other(e))
-            }
-        }
-    }
-
-    async fn list_objects_for_heal(&self, bucket: &str, prefix: &str) -> Result<Vec<String>> {
-        debug!("Listing objects for heal: {}/{}", bucket, prefix);
-
-        // Use list_objects_v2 to get objects
-        match self
-            .ecstore
-            .clone()
-            .list_objects_v2(bucket, prefix, None, None, 1000, false, None)
-            .await
-        {
-            Ok(list_info) => {
-                let objects: Vec<String> = list_info.objects.into_iter().map(|obj| obj.name).collect();
-                info!("Found {} objects for heal in {}/{}", objects.len(), bucket, prefix);
-                Ok(objects)
-            }
-            Err(e) => {
-                error!("Failed to list objects for heal: {}/{} - {}", bucket, prefix, e);
-                Err(Error::other(e))
-            }
-        }
-    }
-
-    async fn get_disk_for_resume(&self, set_disk_id: &str) -> Result<DiskStore> {
-        debug!("Getting disk for resume: {}", set_disk_id);
-
-        // Parse set_disk_id to extract pool and set indices
-        // Format: "pool_{pool_idx}_set_{set_idx}"
-        let parts: Vec<&str> = set_disk_id.split('_').collect();
-        if parts.len() != 4 || parts[0] != "pool" || parts[2] != "set" {
-            return Err(Error::TaskExecutionFailed {
-                message: format!("Invalid set_disk_id format: {set_disk_id}"),
-            });
-        }
-
-        let pool_idx: usize = parts[1].parse().map_err(|_| Error::TaskExecutionFailed {
-            message: format!("Invalid pool index in set_disk_id: {set_disk_id}"),
-        })?;
-
-        let set_idx: usize = parts[3].parse().map_err(|_| Error::TaskExecutionFailed {
-            message: format!("Invalid set index in set_disk_id: {set_disk_id}"),
-        })?;
-
-        // Get the first available disk from the set
-        let disks = self
-            .ecstore
-            .get_disks(pool_idx, set_idx)
-            .await
-            .map_err(|e| Error::TaskExecutionFailed {
-                message: format!("Failed to get disks for pool {pool_idx} set {set_idx}: {e}"),
-            })?;
-
-        // Find the first available disk
-        if let Some(disk_store) = disks.into_iter().flatten().next() {
-            info!("Found disk for resume: {:?}", disk_store);
-            return Ok(disk_store);
-        }
-
-        Err(Error::TaskExecutionFailed {
-            message: format!("No available disk found for set_disk_id: {set_disk_id}"),
-        })
-    }
-}

crates/ahm/src/heal/task.rs

@@ -1,855 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use crate::error::{Error, Result};
-use crate::heal::ErasureSetHealer;
-use crate::heal::{progress::HealProgress, storage::HealStorageAPI};
-use rustfs_common::heal_channel::{HealOpts, HealScanMode};
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-use std::time::{Duration, SystemTime};
-use tokio::sync::RwLock;
-use tracing::{error, info, warn};
-use uuid::Uuid;
-
-/// Heal type
-#[derive(Debug, Clone)]
-pub enum HealType {
-    /// Object heal
-    Object {
-        bucket: String,
-        object: String,
-        version_id: Option<String>,
-    },
-    /// Bucket heal
-    Bucket { bucket: String },
-    /// Erasure Set heal (includes disk format repair)
-    ErasureSet { buckets: Vec<String>, set_disk_id: String },
-    /// Metadata heal
-    Metadata { bucket: String, object: String },
-    /// MRF heal
-    MRF { meta_path: String },
-    /// EC decode heal
-    ECDecode {
-        bucket: String,
-        object: String,
-        version_id: Option<String>,
-    },
-}
-
-/// Heal priority
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
-pub enum HealPriority {
-    /// Low priority
-    Low = 0,
-    /// Normal priority
-    Normal = 1,
-    /// High priority
-    High = 2,
-    /// Urgent priority
-    Urgent = 3,
-}
-
-impl Default for HealPriority {
-    fn default() -> Self {
-        Self::Normal
-    }
-}
-
-/// Heal options
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct HealOptions {
-    /// Scan mode
-    pub scan_mode: HealScanMode,
-    /// Whether to remove corrupted data
-    pub remove_corrupted: bool,
-    /// Whether to recreate
-    pub recreate_missing: bool,
-    /// Whether to update parity
-    pub update_parity: bool,
-    /// Whether to recursively process
-    pub recursive: bool,
-    /// Whether to dry run
-    pub dry_run: bool,
-    /// Timeout
-    pub timeout: Option<Duration>,
-    /// pool index
-    pub pool_index: Option<usize>,
-    /// set index
-    pub set_index: Option<usize>,
-}
-
-impl Default for HealOptions {
-    fn default() -> Self {
-        Self {
-            scan_mode: HealScanMode::Normal,
-            remove_corrupted: false,
-            recreate_missing: true,
-            update_parity: true,
-            recursive: false,
-            dry_run: false,
-            timeout: Some(Duration::from_secs(300)), // 5 minutes default timeout
-            pool_index: None,
-            set_index: None,
-        }
-    }
-}
-
-/// Heal task status
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub enum HealTaskStatus {
-    /// Pending
-    Pending,
-    /// Running
-    Running,
-    /// Completed
-    Completed,
-    /// Failed
-    Failed { error: String },
-    /// Cancelled
-    Cancelled,
-    /// Timeout
-    Timeout,
-}
-
-/// Heal request
-#[derive(Debug, Clone)]
-pub struct HealRequest {
-    /// Request ID
-    pub id: String,
-    /// Heal type
-    pub heal_type: HealType,
-    /// Heal options
-    pub options: HealOptions,
-    /// Priority
-    pub priority: HealPriority,
-    /// Created time
-    pub created_at: SystemTime,
-}
-
-impl HealRequest {
-    pub fn new(heal_type: HealType, options: HealOptions, priority: HealPriority) -> Self {
-        Self {
-            id: Uuid::new_v4().to_string(),
-            heal_type,
-            options,
-            priority,
-            created_at: SystemTime::now(),
-        }
-    }
-
-    pub fn object(bucket: String, object: String, version_id: Option<String>) -> Self {
-        Self::new(
-            HealType::Object {
-                bucket,
-                object,
-                version_id,
-            },
-            HealOptions::default(),
-            HealPriority::Normal,
-        )
-    }
-
-    pub fn bucket(bucket: String) -> Self {
-        Self::new(HealType::Bucket { bucket }, HealOptions::default(), HealPriority::Normal)
-    }
-
-    pub fn metadata(bucket: String, object: String) -> Self {
-        Self::new(HealType::Metadata { bucket, object }, HealOptions::default(), HealPriority::High)
-    }
-
-    pub fn ec_decode(bucket: String, object: String, version_id: Option<String>) -> Self {
-        Self::new(
-            HealType::ECDecode {
-                bucket,
-                object,
-                version_id,
-            },
-            HealOptions::default(),
-            HealPriority::Urgent,
-        )
-    }
-}
-
-/// Heal task
-pub struct HealTask {
-    /// Task ID
-    pub id: String,
-    /// Heal type
-    pub heal_type: HealType,
-    /// Heal options
-    pub options: HealOptions,
-    /// Task status
-    pub status: Arc<RwLock<HealTaskStatus>>,
-    /// Progress tracking
-    pub progress: Arc<RwLock<HealProgress>>,
-    /// Created time
-    pub created_at: SystemTime,
-    /// Started time
-    pub started_at: Arc<RwLock<Option<SystemTime>>>,
-    /// Completed time
-    pub completed_at: Arc<RwLock<Option<SystemTime>>>,
-    /// Cancel token
-    pub cancel_token: tokio_util::sync::CancellationToken,
-    /// Storage layer interface
-    pub storage: Arc<dyn HealStorageAPI>,
-}
-
-impl HealTask {
-    pub fn from_request(request: HealRequest, storage: Arc<dyn HealStorageAPI>) -> Self {
-        Self {
-            id: request.id,
-            heal_type: request.heal_type,
-            options: request.options,
-            status: Arc::new(RwLock::new(HealTaskStatus::Pending)),
-            progress: Arc::new(RwLock::new(HealProgress::new())),
-            created_at: request.created_at,
-            started_at: Arc::new(RwLock::new(None)),
-            completed_at: Arc::new(RwLock::new(None)),
-            cancel_token: tokio_util::sync::CancellationToken::new(),
-            storage,
-        }
-    }
-
-    pub async fn execute(&self) -> Result<()> {
-        // update status to running
-        {
-            let mut status = self.status.write().await;
-            *status = HealTaskStatus::Running;
-        }
-        {
-            let mut started_at = self.started_at.write().await;
-            *started_at = Some(SystemTime::now());
-        }
-
-        info!("Starting heal task: {} with type: {:?}", self.id, self.heal_type);
-
-        let result = match &self.heal_type {
-            HealType::Object {
-                bucket,
-                object,
-                version_id,
-            } => self.heal_object(bucket, object, version_id.as_deref()).await,
-            HealType::Bucket { bucket } => self.heal_bucket(bucket).await,
-
-            HealType::Metadata { bucket, object } => self.heal_metadata(bucket, object).await,
-            HealType::MRF { meta_path } => self.heal_mrf(meta_path).await,
-            HealType::ECDecode {
-                bucket,
-                object,
-                version_id,
-            } => self.heal_ec_decode(bucket, object, version_id.as_deref()).await,
-            HealType::ErasureSet { buckets, set_disk_id } => self.heal_erasure_set(buckets.clone(), set_disk_id.clone()).await,
-        };
-
-        // update completed time and status
-        {
-            let mut completed_at = self.completed_at.write().await;
-            *completed_at = Some(SystemTime::now());
-        }
-
-        match &result {
-            Ok(_) => {
-                let mut status = self.status.write().await;
-                *status = HealTaskStatus::Completed;
-                info!("Heal task completed successfully: {}", self.id);
-            }
-            Err(e) => {
-                let mut status = self.status.write().await;
-                *status = HealTaskStatus::Failed { error: e.to_string() };
-                error!("Heal task failed: {} with error: {}", self.id, e);
-            }
-        }
-
-        result
-    }
-
-    pub async fn cancel(&self) -> Result<()> {
-        self.cancel_token.cancel();
-        let mut status = self.status.write().await;
-        *status = HealTaskStatus::Cancelled;
-        info!("Heal task cancelled: {}", self.id);
-        Ok(())
-    }
-
-    pub async fn get_status(&self) -> HealTaskStatus {
-        self.status.read().await.clone()
-    }
-
-    pub async fn get_progress(&self) -> HealProgress {
-        self.progress.read().await.clone()
-    }
-
-    // specific heal implementation method
-    async fn heal_object(&self, bucket: &str, object: &str, version_id: Option<&str>) -> Result<()> {
-        info!("Healing object: {}/{}", bucket, object);
-
-        // update progress
-        {
-            let mut progress = self.progress.write().await;
-            progress.set_current_object(Some(format!("{bucket}/{object}")));
-            progress.update_progress(0, 4, 0, 0);
-        }
-
-        // Step 1: Check if object exists and get metadata
-        info!("Step 1: Checking object existence and metadata");
-        let object_exists = self.storage.object_exists(bucket, object).await?;
-        if !object_exists {
-            warn!("Object does not exist: {}/{}", bucket, object);
-            if self.options.recreate_missing {
-                info!("Attempting to recreate missing object: {}/{}", bucket, object);
-                return self.recreate_missing_object(bucket, object, version_id).await;
-            } else {
-                return Err(Error::TaskExecutionFailed {
-                    message: format!("Object not found: {bucket}/{object}"),
-                });
-            }
-        }
-
-        {
-            let mut progress = self.progress.write().await;
-            progress.update_progress(1, 3, 0, 0);
-        }
-
-        // Step 2: directly call ecstore to perform heal
-        info!("Step 2: Performing heal using ecstore");
-        let heal_opts = HealOpts {
-            recursive: self.options.recursive,
-            dry_run: self.options.dry_run,
-            remove: self.options.remove_corrupted,
-            recreate: self.options.recreate_missing,
-            scan_mode: self.options.scan_mode,
-            update_parity: self.options.update_parity,
-            no_lock: false,
-            pool: self.options.pool_index,
-            set: self.options.set_index,
-        };
-
-        match self.storage.heal_object(bucket, object, version_id, &heal_opts).await {
-            Ok((result, error)) => {
-                if let Some(e) = error {
-                    error!("Heal operation failed: {}/{} - {}", bucket, object, e);
-
-                    // If heal failed and remove_corrupted is enabled, delete the corrupted object
-                    if self.options.remove_corrupted {
-                        warn!("Removing corrupted object: {}/{}", bucket, object);
-                        if !self.options.dry_run {
-                            self.storage.delete_object(bucket, object).await?;
-                            info!("Successfully deleted corrupted object: {}/{}", bucket, object);
-                        } else {
-                            info!("Dry run mode - would delete corrupted object: {}/{}", bucket, object);
-                        }
-                    }
-
-                    {
-                        let mut progress = self.progress.write().await;
-                        progress.update_progress(3, 3, 0, 0);
-                    }
-
-                    return Err(Error::TaskExecutionFailed {
-                        message: format!("Failed to heal object {bucket}/{object}: {e}"),
-                    });
-                }
-
-                // Step 3: Verify heal result
-                info!("Step 3: Verifying heal result");
-                let object_size = result.object_size as u64;
-                info!(
-                    "Heal completed successfully: {}/{} ({} bytes, {} drives healed)",
-                    bucket,
-                    object,
-                    object_size,
-                    result.after.drives.len()
-                );
-
-                {
-                    let mut progress = self.progress.write().await;
-                    progress.update_progress(3, 3, object_size, object_size);
-                }
-                Ok(())
-            }
-            Err(e) => {
-                error!("Heal operation failed: {}/{} - {}", bucket, object, e);
-
-                // If heal failed and remove_corrupted is enabled, delete the corrupted object
-                if self.options.remove_corrupted {
-                    warn!("Removing corrupted object: {}/{}", bucket, object);
-                    if !self.options.dry_run {
-                        self.storage.delete_object(bucket, object).await?;
-                        info!("Successfully deleted corrupted object: {}/{}", bucket, object);
-                    } else {
-                        info!("Dry run mode - would delete corrupted object: {}/{}", bucket, object);
-                    }
-                }
-
-                {
-                    let mut progress = self.progress.write().await;
-                    progress.update_progress(3, 3, 0, 0);
-                }
-
-                Err(Error::TaskExecutionFailed {
-                    message: format!("Failed to heal object {bucket}/{object}: {e}"),
-                })
-            }
-        }
-    }
-
-    /// Recreate missing object (for EC decode scenarios)
-    async fn recreate_missing_object(&self, bucket: &str, object: &str, version_id: Option<&str>) -> Result<()> {
-        info!("Attempting to recreate missing object: {}/{}", bucket, object);
-
-        // Use ecstore's heal_object with recreate option
-        let heal_opts = HealOpts {
-            recursive: false,
-            dry_run: self.options.dry_run,
-            remove: false,
-            recreate: true,
-            scan_mode: HealScanMode::Deep,
-            update_parity: true,
-            no_lock: false,
-            pool: None,
-            set: None,
-        };
-
-        match self.storage.heal_object(bucket, object, version_id, &heal_opts).await {
-            Ok((result, error)) => {
-                if let Some(e) = error {
-                    error!("Failed to recreate missing object: {}/{} - {}", bucket, object, e);
-                    return Err(Error::TaskExecutionFailed {
-                        message: format!("Failed to recreate missing object {bucket}/{object}: {e}"),
-                    });
-                }
-
-                let object_size = result.object_size as u64;
-                info!("Successfully recreated missing object: {}/{} ({} bytes)", bucket, object, object_size);
-
-                {
-                    let mut progress = self.progress.write().await;
-                    progress.update_progress(4, 4, object_size, object_size);
-                }
-                Ok(())
-            }
-            Err(e) => {
-                error!("Failed to recreate missing object: {}/{} - {}", bucket, object, e);
-                Err(Error::TaskExecutionFailed {
-                    message: format!("Failed to recreate missing object {bucket}/{object}: {e}"),
-                })
-            }
-        }
-    }
-
-    async fn heal_bucket(&self, bucket: &str) -> Result<()> {
-        info!("Healing bucket: {}", bucket);
-
-        // update progress
-        {
-            let mut progress = self.progress.write().await;
-            progress.set_current_object(Some(format!("bucket: {bucket}")));
-            progress.update_progress(0, 3, 0, 0);
-        }
-
-        // Step 1: Check if bucket exists
-        info!("Step 1: Checking bucket existence");
-        let bucket_exists = self.storage.get_bucket_info(bucket).await?.is_some();
-        if !bucket_exists {
-            warn!("Bucket does not exist: {}", bucket);
-            return Err(Error::TaskExecutionFailed {
-                message: format!("Bucket not found: {bucket}"),
-            });
-        }
-
-        {
-            let mut progress = self.progress.write().await;
-            progress.update_progress(1, 3, 0, 0);
-        }
-
-        // Step 2: Perform bucket heal using ecstore
-        info!("Step 2: Performing bucket heal using ecstore");
-        let heal_opts = HealOpts {
-            recursive: self.options.recursive,
-            dry_run: self.options.dry_run,
-            remove: self.options.remove_corrupted,
-            recreate: self.options.recreate_missing,
-            scan_mode: self.options.scan_mode,
-            update_parity: self.options.update_parity,
-            no_lock: false,
-            pool: self.options.pool_index,
-            set: self.options.set_index,
-        };
-
-        match self.storage.heal_bucket(bucket, &heal_opts).await {
-            Ok(result) => {
-                info!("Bucket heal completed successfully: {} ({} drives)", bucket, result.after.drives.len());
-
-                {
-                    let mut progress = self.progress.write().await;
-                    progress.update_progress(3, 3, 0, 0);
-                }
-                Ok(())
-            }
-            Err(e) => {
-                error!("Bucket heal failed: {} - {}", bucket, e);
-                {
-                    let mut progress = self.progress.write().await;
-                    progress.update_progress(3, 3, 0, 0);
-                }
-                Err(Error::TaskExecutionFailed {
-                    message: format!("Failed to heal bucket {bucket}: {e}"),
-                })
-            }
-        }
-    }
-
-    async fn heal_metadata(&self, bucket: &str, object: &str) -> Result<()> {
-        info!("Healing metadata: {}/{}", bucket, object);
-
-        // update progress
-        {
-            let mut progress = self.progress.write().await;
-            progress.set_current_object(Some(format!("metadata: {bucket}/{object}")));
-            progress.update_progress(0, 3, 0, 0);
-        }
-
-        // Step 1: Check if object exists
-        info!("Step 1: Checking object existence");
-        let object_exists = self.storage.object_exists(bucket, object).await?;
-        if !object_exists {
-            warn!("Object does not exist: {}/{}", bucket, object);
-            return Err(Error::TaskExecutionFailed {
-                message: format!("Object not found: {bucket}/{object}"),
-            });
-        }
-
-        {
-            let mut progress = self.progress.write().await;
-            progress.update_progress(1, 3, 0, 0);
-        }
-
-        // Step 2: Perform metadata heal using ecstore
-        info!("Step 2: Performing metadata heal using ecstore");
-        let heal_opts = HealOpts {
-            recursive: false,
-            dry_run: self.options.dry_run,
-            remove: false,
-            recreate: false,
-            scan_mode: HealScanMode::Deep,
-            update_parity: false,
-            no_lock: false,
-            pool: self.options.pool_index,
-            set: self.options.set_index,
-        };
-
-        match self.storage.heal_object(bucket, object, None, &heal_opts).await {
-            Ok((result, error)) => {
-                if let Some(e) = error {
-                    error!("Metadata heal failed: {}/{} - {}", bucket, object, e);
-                    {
-                        let mut progress = self.progress.write().await;
-                        progress.update_progress(3, 3, 0, 0);
-                    }
-                    return Err(Error::TaskExecutionFailed {
-                        message: format!("Failed to heal metadata {bucket}/{object}: {e}"),
-                    });
-                }
-
-                info!(
-                    "Metadata heal completed successfully: {}/{} ({} drives)",
-                    bucket,
-                    object,
-                    result.after.drives.len()
-                );
-
-                {
-                    let mut progress = self.progress.write().await;
-                    progress.update_progress(3, 3, 0, 0);
-                }
-                Ok(())
-            }
-            Err(e) => {
-                error!("Metadata heal failed: {}/{} - {}", bucket, object, e);
-                {
-                    let mut progress = self.progress.write().await;
-                    progress.update_progress(3, 3, 0, 0);
-                }
-                Err(Error::TaskExecutionFailed {
-                    message: format!("Failed to heal metadata {bucket}/{object}: {e}"),
-                })
-            }
-        }
-    }
-
-    async fn heal_mrf(&self, meta_path: &str) -> Result<()> {
-        info!("Healing MRF: {}", meta_path);
-
-        // update progress
-        {
-            let mut progress = self.progress.write().await;
-            progress.set_current_object(Some(format!("mrf: {meta_path}")));
-            progress.update_progress(0, 2, 0, 0);
-        }
-
-        // Parse meta_path to extract bucket and object
-        let parts: Vec<&str> = meta_path.split('/').collect();
-        if parts.len() < 2 {
-            return Err(Error::TaskExecutionFailed {
-                message: format!("Invalid meta path format: {meta_path}"),
-            });
-        }
-
-        let bucket = parts[0];
-        let object = parts[1..].join("/");
-
-        // Step 1: Perform MRF heal using ecstore
-        info!("Step 1: Performing MRF heal using ecstore");
-        let heal_opts = HealOpts {
-            recursive: true,
-            dry_run: self.options.dry_run,
-            remove: self.options.remove_corrupted,
-            recreate: self.options.recreate_missing,
-            scan_mode: HealScanMode::Deep,
-            update_parity: true,
-            no_lock: false,
-            pool: None,
-            set: None,
-        };
-
-        match self.storage.heal_object(bucket, &object, None, &heal_opts).await {
-            Ok((result, error)) => {
-                if let Some(e) = error {
-                    error!("MRF heal failed: {} - {}", meta_path, e);
-                    {
-                        let mut progress = self.progress.write().await;
-                        progress.update_progress(2, 2, 0, 0);
-                    }
-                    return Err(Error::TaskExecutionFailed {
-                        message: format!("Failed to heal MRF {meta_path}: {e}"),
-                    });
-                }
-
-                info!("MRF heal completed successfully: {} ({} drives)", meta_path, result.after.drives.len());
-
-                {
-                    let mut progress = self.progress.write().await;
-                    progress.update_progress(2, 2, 0, 0);
-                }
-                Ok(())
-            }
-            Err(e) => {
-                error!("MRF heal failed: {} - {}", meta_path, e);
-                {
-                    let mut progress = self.progress.write().await;
-                    progress.update_progress(2, 2, 0, 0);
-                }
-                Err(Error::TaskExecutionFailed {
-                    message: format!("Failed to heal MRF {meta_path}: {e}"),
-                })
-            }
-        }
-    }
-
-    async fn heal_ec_decode(&self, bucket: &str, object: &str, version_id: Option<&str>) -> Result<()> {
-        info!("Healing EC decode: {}/{}", bucket, object);
-
-        // update progress
-        {
-            let mut progress = self.progress.write().await;
-            progress.set_current_object(Some(format!("ec_decode: {bucket}/{object}")));
-            progress.update_progress(0, 3, 0, 0);
-        }
-
-        // Step 1: Check if object exists
-        info!("Step 1: Checking object existence");
-        let object_exists = self.storage.object_exists(bucket, object).await?;
-        if !object_exists {
-            warn!("Object does not exist: {}/{}", bucket, object);
-            return Err(Error::TaskExecutionFailed {
-                message: format!("Object not found: {bucket}/{object}"),
-            });
-        }
-
-        {
-            let mut progress = self.progress.write().await;
-            progress.update_progress(1, 3, 0, 0);
-        }
-
-        // Step 2: Perform EC decode heal using ecstore
-        info!("Step 2: Performing EC decode heal using ecstore");
-        let heal_opts = HealOpts {
-            recursive: false,
-            dry_run: self.options.dry_run,
-            remove: false,
-            recreate: true,
-            scan_mode: HealScanMode::Deep,
-            update_parity: true,
-            no_lock: false,
-            pool: None,
-            set: None,
-        };
-
-        match self.storage.heal_object(bucket, object, version_id, &heal_opts).await {
-            Ok((result, error)) => {
-                if let Some(e) = error {
-                    error!("EC decode heal failed: {}/{} - {}", bucket, object, e);
-                    {
-                        let mut progress = self.progress.write().await;
-                        progress.update_progress(3, 3, 0, 0);
-                    }
-                    return Err(Error::TaskExecutionFailed {
-                        message: format!("Failed to heal EC decode {bucket}/{object}: {e}"),
-                    });
-                }
-
-                let object_size = result.object_size as u64;
-                info!(
-                    "EC decode heal completed successfully: {}/{} ({} bytes, {} drives)",
-                    bucket,
-                    object,
-                    object_size,
-                    result.after.drives.len()
-                );
-
-                {
-                    let mut progress = self.progress.write().await;
-                    progress.update_progress(3, 3, object_size, object_size);
-                }
-                Ok(())
-            }
-            Err(e) => {
-                error!("EC decode heal failed: {}/{} - {}", bucket, object, e);
-                {
-                    let mut progress = self.progress.write().await;
-                    progress.update_progress(3, 3, 0, 0);
-                }
-                Err(Error::TaskExecutionFailed {
-                    message: format!("Failed to heal EC decode {bucket}/{object}: {e}"),
-                })
-            }
-        }
-    }
-
-    async fn heal_erasure_set(&self, buckets: Vec<String>, set_disk_id: String) -> Result<()> {
-        info!("Healing Erasure Set: {} ({} buckets)", set_disk_id, buckets.len());
-
-        // update progress
-        {
-            let mut progress = self.progress.write().await;
-            progress.set_current_object(Some(format!("erasure_set: {} ({} buckets)", set_disk_id, buckets.len())));
-            progress.update_progress(0, 4, 0, 0);
-        }
-
-        let buckets = if buckets.is_empty() {
-            info!("No buckets specified, listing all buckets");
-            let bucket_infos = self.storage.list_buckets().await?;
-            bucket_infos.into_iter().map(|info| info.name).collect()
-        } else {
-            buckets
-        };
-
-        // Step 1: Perform disk format heal using ecstore
-        info!("Step 1: Performing disk format heal using ecstore");
-        match self.storage.heal_format(self.options.dry_run).await {
-            Ok((result, error)) => {
-                if let Some(e) = error {
-                    error!("Disk format heal failed: {} - {}", set_disk_id, e);
-                    {
-                        let mut progress = self.progress.write().await;
-                        progress.update_progress(4, 4, 0, 0);
-                    }
-                    return Err(Error::TaskExecutionFailed {
-                        message: format!("Failed to heal disk format for {set_disk_id}: {e}"),
-                    });
-                }
-
-                info!(
-                    "Disk format heal completed successfully: {} ({} drives)",
-                    set_disk_id,
-                    result.after.drives.len()
-                );
-            }
-            Err(e) => {
-                error!("Disk format heal failed: {} - {}", set_disk_id, e);
-                {
-                    let mut progress = self.progress.write().await;
-                    progress.update_progress(4, 4, 0, 0);
-                }
-                return Err(Error::TaskExecutionFailed {
-                    message: format!("Failed to heal disk format for {set_disk_id}: {e}"),
-                });
-            }
-        }
-
-        {
-            let mut progress = self.progress.write().await;
-            progress.update_progress(1, 4, 0, 0);
-        }
-
-        // Step 2: Get disk for resume functionality
-        info!("Step 2: Getting disk for resume functionality");
-        let disk = self.storage.get_disk_for_resume(&set_disk_id).await?;
-
-        {
-            let mut progress = self.progress.write().await;
-            progress.update_progress(2, 4, 0, 0);
-        }
-
-        // Step 3: Heal bucket structure
-        for bucket in buckets.iter() {
-            if let Err(err) = self.heal_bucket(bucket).await {
-                info!("{}", err.to_string());
-            }
-        }
-
-        // Step 3: Create erasure set healer with resume support
-        info!("Step 3: Creating erasure set healer with resume support");
-        let erasure_healer = ErasureSetHealer::new(self.storage.clone(), self.progress.clone(), self.cancel_token.clone(), disk);
-
-        {
-            let mut progress = self.progress.write().await;
-            progress.update_progress(3, 4, 0, 0);
-        }
-
-        // Step 4: Execute erasure set heal with resume
-        info!("Step 4: Executing erasure set heal with resume");
-        let result = erasure_healer.heal_erasure_set(&buckets, &set_disk_id).await;
-
-        {
-            let mut progress = self.progress.write().await;
-            progress.update_progress(4, 4, 0, 0);
-        }
-
-        match result {
-            Ok(_) => {
-                info!("Erasure set heal completed successfully: {} ({} buckets)", set_disk_id, buckets.len());
-                Ok(())
-            }
-            Err(e) => {
-                error!("Erasure set heal failed: {} - {}", set_disk_id, e);
-                Err(Error::TaskExecutionFailed {
-                    message: format!("Failed to heal erasure set {set_disk_id}: {e}"),
-                })
-            }
-        }
-    }
-}
-
-impl std::fmt::Debug for HealTask {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("HealTask")
-            .field("id", &self.id)
-            .field("heal_type", &self.heal_type)
-            .field("options", &self.options)
-            .field("created_at", &self.created_at)
-            .finish()
-    }
-}

crates/ahm/src/lib.rs

@@ -1,112 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::sync::{Arc, OnceLock};
-use tokio_util::sync::CancellationToken;
-use tracing::{error, info};
-
-pub mod error;
-pub mod heal;
-pub mod scanner;
-
-pub use error::{Error, Result};
-pub use heal::{HealManager, HealOptions, HealPriority, HealRequest, HealType, channel::HealChannelProcessor};
-pub use scanner::Scanner;
-
-// Global cancellation token for AHM services (scanner and other background tasks)
-static GLOBAL_AHM_SERVICES_CANCEL_TOKEN: OnceLock<CancellationToken> = OnceLock::new();
-
-/// Initialize the global AHM services cancellation token
-pub fn init_ahm_services_cancel_token(cancel_token: CancellationToken) -> Result<()> {
-    GLOBAL_AHM_SERVICES_CANCEL_TOKEN
-        .set(cancel_token)
-        .map_err(|_| Error::Config("AHM services cancel token already initialized".to_string()))
-}
-
-/// Get the global AHM services cancellation token
-pub fn get_ahm_services_cancel_token() -> Option<&'static CancellationToken> {
-    GLOBAL_AHM_SERVICES_CANCEL_TOKEN.get()
-}
-
-/// Create and initialize the global AHM services cancellation token
-pub fn create_ahm_services_cancel_token() -> CancellationToken {
-    let cancel_token = CancellationToken::new();
-    init_ahm_services_cancel_token(cancel_token.clone()).expect("AHM services cancel token already initialized");
-    cancel_token
-}
-
-/// Shutdown all AHM services gracefully
-pub fn shutdown_ahm_services() {
-    if let Some(cancel_token) = GLOBAL_AHM_SERVICES_CANCEL_TOKEN.get() {
-        cancel_token.cancel();
-    }
-}
-
-/// Global heal manager instance
-static GLOBAL_HEAL_MANAGER: OnceLock<Arc<HealManager>> = OnceLock::new();
-
-/// Global heal channel processor instance
-static GLOBAL_HEAL_CHANNEL_PROCESSOR: OnceLock<Arc<tokio::sync::Mutex<HealChannelProcessor>>> = OnceLock::new();
-
-/// Initialize and start heal manager with channel processor
-pub async fn init_heal_manager(
-    storage: Arc<dyn heal::storage::HealStorageAPI>,
-    config: Option<heal::manager::HealConfig>,
-) -> Result<Arc<HealManager>> {
-    // Create heal manager
-    let heal_manager = Arc::new(HealManager::new(storage, config));
-
-    // Start heal manager
-    heal_manager.start().await?;
-
-    // Store global instance
-    GLOBAL_HEAL_MANAGER
-        .set(heal_manager.clone())
-        .map_err(|_| Error::Config("Heal manager already initialized".to_string()))?;
-
-    // Initialize heal channel
-    let channel_receiver = rustfs_common::heal_channel::init_heal_channel();
-
-    // Create channel processor
-    let channel_processor = HealChannelProcessor::new(heal_manager.clone());
-
-    // Store channel processor instance first
-    GLOBAL_HEAL_CHANNEL_PROCESSOR
-        .set(Arc::new(tokio::sync::Mutex::new(channel_processor)))
-        .map_err(|_| Error::Config("Heal channel processor already initialized".to_string()))?;
-
-    // Start channel processor in background
-    let receiver = channel_receiver;
-    tokio::spawn(async move {
-        if let Some(processor_guard) = GLOBAL_HEAL_CHANNEL_PROCESSOR.get() {
-            let mut processor = processor_guard.lock().await;
-            if let Err(e) = processor.start(receiver).await {
-                error!("Heal channel processor failed: {}", e);
-            }
-        }
-    });
-
-    info!("Heal manager with channel processor initialized successfully");
-    Ok(heal_manager)
-}
-
-/// Get global heal manager instance
-pub fn get_heal_manager() -> Option<&'static Arc<HealManager>> {
-    GLOBAL_HEAL_MANAGER.get()
-}
-
-/// Get global heal channel processor instance
-pub fn get_heal_channel_processor() -> Option<&'static Arc<tokio::sync::Mutex<HealChannelProcessor>>> {
-    GLOBAL_HEAL_CHANNEL_PROCESSOR.get()
-}

crates/ahm/src/scanner/checkpoint.rs

@@ -1,328 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::{
-    path::{Path, PathBuf},
-    time::{Duration, SystemTime},
-};
-
-use serde::{Deserialize, Serialize};
-use tokio::sync::RwLock;
-use tracing::{debug, error, info, warn};
-
-use super::node_scanner::ScanProgress;
-use crate::{Error, error::Result};
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct CheckpointData {
-    pub version: u32,
-    pub timestamp: SystemTime,
-    pub progress: ScanProgress,
-    pub node_id: String,
-    pub checksum: u64,
-}
-
-impl CheckpointData {
-    pub fn new(progress: ScanProgress, node_id: String) -> Self {
-        let mut checkpoint = Self {
-            version: 1,
-            timestamp: SystemTime::now(),
-            progress,
-            node_id,
-            checksum: 0,
-        };
-
-        checkpoint.checksum = checkpoint.calculate_checksum();
-        checkpoint
-    }
-
-    fn calculate_checksum(&self) -> u64 {
-        use std::collections::hash_map::DefaultHasher;
-        use std::hash::{Hash, Hasher};
-
-        let mut hasher = DefaultHasher::new();
-        self.version.hash(&mut hasher);
-        self.node_id.hash(&mut hasher);
-        self.progress.current_cycle.hash(&mut hasher);
-        self.progress.current_disk_index.hash(&mut hasher);
-
-        if let Some(ref bucket) = self.progress.current_bucket {
-            bucket.hash(&mut hasher);
-        }
-
-        if let Some(ref key) = self.progress.last_scan_key {
-            key.hash(&mut hasher);
-        }
-
-        hasher.finish()
-    }
-
-    pub fn verify_integrity(&self) -> bool {
-        let calculated_checksum = self.calculate_checksum();
-        self.checksum == calculated_checksum
-    }
-}
-
-pub struct CheckpointManager {
-    checkpoint_file: PathBuf,
-    backup_file: PathBuf,
-    temp_file: PathBuf,
-    save_interval: Duration,
-    last_save: RwLock<SystemTime>,
-    node_id: String,
-}
-
-impl CheckpointManager {
-    pub fn new(node_id: &str, data_dir: &Path) -> Self {
-        if !data_dir.exists() {
-            if let Err(e) = std::fs::create_dir_all(data_dir) {
-                error!("create data dir failed {:?}: {}", data_dir, e);
-            }
-        }
-
-        let checkpoint_file = data_dir.join(format!("scanner_checkpoint_{}.json", node_id));
-        let backup_file = data_dir.join(format!("scanner_checkpoint_{}.backup", node_id));
-        let temp_file = data_dir.join(format!("scanner_checkpoint_{}.tmp", node_id));
-
-        Self {
-            checkpoint_file,
-            backup_file,
-            temp_file,
-            save_interval: Duration::from_secs(30), // 30s
-            last_save: RwLock::new(SystemTime::UNIX_EPOCH),
-            node_id: node_id.to_string(),
-        }
-    }
-
-    pub async fn save_checkpoint(&self, progress: &ScanProgress) -> Result<()> {
-        let now = SystemTime::now();
-        let last_save = *self.last_save.read().await;
-
-        if now.duration_since(last_save).unwrap_or(Duration::ZERO) < self.save_interval {
-            return Ok(());
-        }
-
-        let checkpoint_data = CheckpointData::new(progress.clone(), self.node_id.clone());
-
-        let json_data = serde_json::to_string_pretty(&checkpoint_data)
-            .map_err(|e| Error::Serialization(format!("serialize checkpoint failed: {}", e)))?;
-
-        tokio::fs::write(&self.temp_file, json_data)
-            .await
-            .map_err(|e| Error::IO(format!("write temp checkpoint file failed: {}", e)))?;
-
-        if self.checkpoint_file.exists() {
-            tokio::fs::copy(&self.checkpoint_file, &self.backup_file)
-                .await
-                .map_err(|e| Error::IO(format!("backup checkpoint file failed: {}", e)))?;
-        }
-
-        tokio::fs::rename(&self.temp_file, &self.checkpoint_file)
-            .await
-            .map_err(|e| Error::IO(format!("replace checkpoint file failed: {}", e)))?;
-
-        *self.last_save.write().await = now;
-
-        debug!(
-            "save checkpoint to {:?}, cycle: {}, disk index: {}",
-            self.checkpoint_file, checkpoint_data.progress.current_cycle, checkpoint_data.progress.current_disk_index
-        );
-
-        Ok(())
-    }
-
-    pub async fn load_checkpoint(&self) -> Result<Option<ScanProgress>> {
-        // first try main checkpoint file
-        match self.load_checkpoint_from_file(&self.checkpoint_file).await {
-            Ok(checkpoint) => {
-                info!(
-                    "restore scan progress from main checkpoint file: cycle={}, disk index={}, last scan key={:?}",
-                    checkpoint.current_cycle, checkpoint.current_disk_index, checkpoint.last_scan_key
-                );
-                Ok(Some(checkpoint))
-            }
-            Err(e) => {
-                warn!("main checkpoint file is corrupted or not exists: {}", e);
-
-                // try backup file
-                match self.load_checkpoint_from_file(&self.backup_file).await {
-                    Ok(checkpoint) => {
-                        warn!(
-                            "restore scan progress from backup file: cycle={}, disk index={}",
-                            checkpoint.current_cycle, checkpoint.current_disk_index
-                        );
-
-                        // copy backup file to main checkpoint file
-                        if let Err(copy_err) = tokio::fs::copy(&self.backup_file, &self.checkpoint_file).await {
-                            warn!("restore main checkpoint file failed: {}", copy_err);
-                        }
-
-                        Ok(Some(checkpoint))
-                    }
-                    Err(backup_e) => {
-                        warn!("backup file is corrupted or not exists: {}", backup_e);
-                        info!("cannot restore scan progress, will start fresh scan");
-                        Ok(None)
-                    }
-                }
-            }
-        }
-    }
-
-    /// load checkpoint from file
-    async fn load_checkpoint_from_file(&self, file_path: &Path) -> Result<ScanProgress> {
-        if !file_path.exists() {
-            return Err(Error::NotFound(format!("checkpoint file not exists: {:?}", file_path)));
-        }
-
-        // read file content
-        let content = tokio::fs::read_to_string(file_path)
-            .await
-            .map_err(|e| Error::IO(format!("read checkpoint file failed: {}", e)))?;
-
-        // deserialize
-        let checkpoint_data: CheckpointData =
-            serde_json::from_str(&content).map_err(|e| Error::Serialization(format!("deserialize checkpoint failed: {}", e)))?;
-
-        // validate checkpoint data
-        self.validate_checkpoint(&checkpoint_data)?;
-
-        Ok(checkpoint_data.progress)
-    }
-
-    /// validate checkpoint data
-    fn validate_checkpoint(&self, checkpoint: &CheckpointData) -> Result<()> {
-        // validate data integrity
-        if !checkpoint.verify_integrity() {
-            return Err(Error::InvalidCheckpoint(
-                "checkpoint data verification failed, may be corrupted".to_string(),
-            ));
-        }
-
-        // validate node id match
-        if checkpoint.node_id != self.node_id {
-            return Err(Error::InvalidCheckpoint(format!(
-                "checkpoint node id not match: expected {}, actual {}",
-                self.node_id, checkpoint.node_id
-            )));
-        }
-
-        let now = SystemTime::now();
-        let checkpoint_age = now.duration_since(checkpoint.timestamp).unwrap_or(Duration::MAX);
-
-        // checkpoint is too old (more than 24 hours), may be data expired
-        if checkpoint_age > Duration::from_secs(24 * 3600) {
-            return Err(Error::InvalidCheckpoint(format!("checkpoint data is too old: {:?}", checkpoint_age)));
-        }
-
-        // validate version compatibility
-        if checkpoint.version > 1 {
-            return Err(Error::InvalidCheckpoint(format!(
-                "unsupported checkpoint version: {}",
-                checkpoint.version
-            )));
-        }
-
-        Ok(())
-    }
-
-    /// clean checkpoint file
-    ///
-    /// called when scanner stops or resets
-    pub async fn cleanup_checkpoint(&self) -> Result<()> {
-        // delete main file
-        if self.checkpoint_file.exists() {
-            tokio::fs::remove_file(&self.checkpoint_file)
-                .await
-                .map_err(|e| Error::IO(format!("delete main checkpoint file failed: {}", e)))?;
-        }
-
-        // delete backup file
-        if self.backup_file.exists() {
-            tokio::fs::remove_file(&self.backup_file)
-                .await
-                .map_err(|e| Error::IO(format!("delete backup checkpoint file failed: {}", e)))?;
-        }
-
-        // delete temp file
-        if self.temp_file.exists() {
-            tokio::fs::remove_file(&self.temp_file)
-                .await
-                .map_err(|e| Error::IO(format!("delete temp checkpoint file failed: {}", e)))?;
-        }
-
-        info!("cleaned up all checkpoint files");
-        Ok(())
-    }
-
-    /// get checkpoint file info
-    pub async fn get_checkpoint_info(&self) -> Result<Option<CheckpointInfo>> {
-        if !self.checkpoint_file.exists() {
-            return Ok(None);
-        }
-
-        let metadata = tokio::fs::metadata(&self.checkpoint_file)
-            .await
-            .map_err(|e| Error::IO(format!("get checkpoint file metadata failed: {}", e)))?;
-
-        let content = tokio::fs::read_to_string(&self.checkpoint_file)
-            .await
-            .map_err(|e| Error::IO(format!("read checkpoint file failed: {}", e)))?;
-
-        let checkpoint_data: CheckpointData =
-            serde_json::from_str(&content).map_err(|e| Error::Serialization(format!("deserialize checkpoint failed: {}", e)))?;
-
-        Ok(Some(CheckpointInfo {
-            file_size: metadata.len(),
-            last_modified: metadata.modified().unwrap_or(SystemTime::UNIX_EPOCH),
-            checkpoint_timestamp: checkpoint_data.timestamp,
-            current_cycle: checkpoint_data.progress.current_cycle,
-            current_disk_index: checkpoint_data.progress.current_disk_index,
-            completed_disks_count: checkpoint_data.progress.completed_disks.len(),
-            is_valid: checkpoint_data.verify_integrity(),
-        }))
-    }
-
-    /// force save checkpoint (ignore time interval limit)
-    pub async fn force_save_checkpoint(&self, progress: &ScanProgress) -> Result<()> {
-        // temporarily reset last save time, force save
-        *self.last_save.write().await = SystemTime::UNIX_EPOCH;
-        self.save_checkpoint(progress).await
-    }
-
-    /// set save interval
-    pub async fn set_save_interval(&mut self, interval: Duration) {
-        self.save_interval = interval;
-        info!("checkpoint save interval set to: {:?}", interval);
-    }
-}
-
-/// checkpoint info
-#[derive(Debug, Clone)]
-pub struct CheckpointInfo {
-    /// file size
-    pub file_size: u64,
-    /// file last modified time
-    pub last_modified: SystemTime,
-    /// checkpoint creation time
-    pub checkpoint_timestamp: SystemTime,
-    /// current scan cycle
-    pub current_cycle: u64,
-    /// current disk index
-    pub current_disk_index: usize,
-    /// completed disks count
-    pub completed_disks_count: usize,
-    /// checkpoint is valid
-    pub is_valid: bool,
-}

crates/ahm/src/scanner/histogram.rs

@@ -1,306 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::{
-    collections::HashMap,
-    sync::atomic::{AtomicU64, Ordering},
-    time::{Duration, SystemTime},
-};
-
-use serde::{Deserialize, Serialize};
-use tracing::info;
-
-/// Scanner metrics
-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
-pub struct ScannerMetrics {
-    /// Total objects scanned since server start
-    pub objects_scanned: u64,
-    /// Total object versions scanned since server start
-    pub versions_scanned: u64,
-    /// Total directories scanned since server start
-    pub directories_scanned: u64,
-    /// Total bucket scans started since server start
-    pub bucket_scans_started: u64,
-    /// Total bucket scans finished since server start
-    pub bucket_scans_finished: u64,
-    /// Total objects with health issues found
-    pub objects_with_issues: u64,
-    /// Total heal tasks queued
-    pub heal_tasks_queued: u64,
-    /// Total heal tasks completed
-    pub heal_tasks_completed: u64,
-    /// Total heal tasks failed
-    pub heal_tasks_failed: u64,
-    /// Total healthy objects found
-    pub healthy_objects: u64,
-    /// Total corrupted objects found
-    pub corrupted_objects: u64,
-    /// Last scan activity time
-    pub last_activity: Option<SystemTime>,
-    /// Current scan cycle
-    pub current_cycle: u64,
-    /// Total scan cycles completed
-    pub total_cycles: u64,
-    /// Current scan duration
-    pub current_scan_duration: Option<Duration>,
-    /// Average scan duration
-    pub avg_scan_duration: Duration,
-    /// Objects scanned per second
-    pub objects_per_second: f64,
-    /// Buckets scanned per second
-    pub buckets_per_second: f64,
-    /// Storage metrics by bucket
-    pub bucket_metrics: HashMap<String, BucketMetrics>,
-    /// Disk metrics
-    pub disk_metrics: HashMap<String, DiskMetrics>,
-}
-
-/// Bucket-specific metrics
-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
-pub struct BucketMetrics {
-    /// Bucket name
-    pub bucket: String,
-    /// Total objects in bucket
-    pub total_objects: u64,
-    /// Total size of objects in bucket (bytes)
-    pub total_size: u64,
-    /// Objects with health issues
-    pub objects_with_issues: u64,
-    /// Last scan time
-    pub last_scan_time: Option<SystemTime>,
-    /// Scan duration
-    pub scan_duration: Option<Duration>,
-    /// Heal tasks queued for this bucket
-    pub heal_tasks_queued: u64,
-    /// Heal tasks completed for this bucket
-    pub heal_tasks_completed: u64,
-    /// Heal tasks failed for this bucket
-    pub heal_tasks_failed: u64,
-}
-
-/// Disk-specific metrics
-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
-pub struct DiskMetrics {
-    /// Disk path
-    pub disk_path: String,
-    /// Total disk space (bytes)
-    pub total_space: u64,
-    /// Used disk space (bytes)
-    pub used_space: u64,
-    /// Free disk space (bytes)
-    pub free_space: u64,
-    /// Objects scanned on this disk
-    pub objects_scanned: u64,
-    /// Objects with issues on this disk
-    pub objects_with_issues: u64,
-    /// Last scan time
-    pub last_scan_time: Option<SystemTime>,
-    /// Whether disk is online
-    pub is_online: bool,
-    /// Whether disk is being scanned
-    pub is_scanning: bool,
-}
-
-/// Thread-safe metrics collector
-pub struct MetricsCollector {
-    /// Atomic counters for real-time metrics
-    objects_scanned: AtomicU64,
-    versions_scanned: AtomicU64,
-    directories_scanned: AtomicU64,
-    bucket_scans_started: AtomicU64,
-    bucket_scans_finished: AtomicU64,
-    objects_with_issues: AtomicU64,
-    heal_tasks_queued: AtomicU64,
-    heal_tasks_completed: AtomicU64,
-    heal_tasks_failed: AtomicU64,
-    current_cycle: AtomicU64,
-    total_cycles: AtomicU64,
-    healthy_objects: AtomicU64,
-    corrupted_objects: AtomicU64,
-}
-
-impl MetricsCollector {
-    /// Create a new metrics collector
-    pub fn new() -> Self {
-        Self {
-            objects_scanned: AtomicU64::new(0),
-            versions_scanned: AtomicU64::new(0),
-            directories_scanned: AtomicU64::new(0),
-            bucket_scans_started: AtomicU64::new(0),
-            bucket_scans_finished: AtomicU64::new(0),
-            objects_with_issues: AtomicU64::new(0),
-            heal_tasks_queued: AtomicU64::new(0),
-            heal_tasks_completed: AtomicU64::new(0),
-            heal_tasks_failed: AtomicU64::new(0),
-            current_cycle: AtomicU64::new(0),
-            total_cycles: AtomicU64::new(0),
-            healthy_objects: AtomicU64::new(0),
-            corrupted_objects: AtomicU64::new(0),
-        }
-    }
-
-    /// Increment objects scanned count
-    pub fn increment_objects_scanned(&self, count: u64) {
-        self.objects_scanned.fetch_add(count, Ordering::Relaxed);
-    }
-
-    /// Increment versions scanned count
-    pub fn increment_versions_scanned(&self, count: u64) {
-        self.versions_scanned.fetch_add(count, Ordering::Relaxed);
-    }
-
-    /// Increment directories scanned count
-    pub fn increment_directories_scanned(&self, count: u64) {
-        self.directories_scanned.fetch_add(count, Ordering::Relaxed);
-    }
-
-    /// Increment bucket scans started count
-    pub fn increment_bucket_scans_started(&self, count: u64) {
-        self.bucket_scans_started.fetch_add(count, Ordering::Relaxed);
-    }
-
-    /// Increment bucket scans finished count
-    pub fn increment_bucket_scans_finished(&self, count: u64) {
-        self.bucket_scans_finished.fetch_add(count, Ordering::Relaxed);
-    }
-
-    /// Increment objects with issues count
-    pub fn increment_objects_with_issues(&self, count: u64) {
-        self.objects_with_issues.fetch_add(count, Ordering::Relaxed);
-    }
-
-    /// Increment heal tasks queued count
-    pub fn increment_heal_tasks_queued(&self, count: u64) {
-        self.heal_tasks_queued.fetch_add(count, Ordering::Relaxed);
-    }
-
-    /// Increment heal tasks completed count
-    pub fn increment_heal_tasks_completed(&self, count: u64) {
-        self.heal_tasks_completed.fetch_add(count, Ordering::Relaxed);
-    }
-
-    /// Increment heal tasks failed count
-    pub fn increment_heal_tasks_failed(&self, count: u64) {
-        self.heal_tasks_failed.fetch_add(count, Ordering::Relaxed);
-    }
-
-    /// Set current cycle
-    pub fn set_current_cycle(&self, cycle: u64) {
-        self.current_cycle.store(cycle, Ordering::Relaxed);
-    }
-
-    /// Increment total cycles
-    pub fn increment_total_cycles(&self) {
-        self.total_cycles.fetch_add(1, Ordering::Relaxed);
-    }
-
-    /// Increment healthy objects count
-    pub fn increment_healthy_objects(&self) {
-        self.healthy_objects.fetch_add(1, Ordering::Relaxed);
-    }
-
-    /// Increment corrupted objects count
-    pub fn increment_corrupted_objects(&self) {
-        self.corrupted_objects.fetch_add(1, Ordering::Relaxed);
-    }
-
-    /// Get current metrics snapshot
-    pub fn get_metrics(&self) -> ScannerMetrics {
-        ScannerMetrics {
-            objects_scanned: self.objects_scanned.load(Ordering::Relaxed),
-            versions_scanned: self.versions_scanned.load(Ordering::Relaxed),
-            directories_scanned: self.directories_scanned.load(Ordering::Relaxed),
-            bucket_scans_started: self.bucket_scans_started.load(Ordering::Relaxed),
-            bucket_scans_finished: self.bucket_scans_finished.load(Ordering::Relaxed),
-            objects_with_issues: self.objects_with_issues.load(Ordering::Relaxed),
-            heal_tasks_queued: self.heal_tasks_queued.load(Ordering::Relaxed),
-            heal_tasks_completed: self.heal_tasks_completed.load(Ordering::Relaxed),
-            heal_tasks_failed: self.heal_tasks_failed.load(Ordering::Relaxed),
-            healthy_objects: self.healthy_objects.load(Ordering::Relaxed),
-            corrupted_objects: self.corrupted_objects.load(Ordering::Relaxed),
-            last_activity: Some(SystemTime::now()),
-            current_cycle: self.current_cycle.load(Ordering::Relaxed),
-            total_cycles: self.total_cycles.load(Ordering::Relaxed),
-            current_scan_duration: None,       // Will be set by scanner
-            avg_scan_duration: Duration::ZERO, // Will be calculated
-            objects_per_second: 0.0,           // Will be calculated
-            buckets_per_second: 0.0,           // Will be calculated
-            bucket_metrics: HashMap::new(),    // Will be populated by scanner
-            disk_metrics: HashMap::new(),      // Will be populated by scanner
-        }
-    }
-
-    /// Reset all metrics
-    pub fn reset(&self) {
-        self.objects_scanned.store(0, Ordering::Relaxed);
-        self.versions_scanned.store(0, Ordering::Relaxed);
-        self.directories_scanned.store(0, Ordering::Relaxed);
-        self.bucket_scans_started.store(0, Ordering::Relaxed);
-        self.bucket_scans_finished.store(0, Ordering::Relaxed);
-        self.objects_with_issues.store(0, Ordering::Relaxed);
-        self.heal_tasks_queued.store(0, Ordering::Relaxed);
-        self.heal_tasks_completed.store(0, Ordering::Relaxed);
-        self.heal_tasks_failed.store(0, Ordering::Relaxed);
-        self.current_cycle.store(0, Ordering::Relaxed);
-        self.total_cycles.store(0, Ordering::Relaxed);
-        self.healthy_objects.store(0, Ordering::Relaxed);
-        self.corrupted_objects.store(0, Ordering::Relaxed);
-
-        info!("Scanner metrics reset");
-    }
-}
-
-impl Default for MetricsCollector {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_metrics_collector_creation() {
-        let collector = MetricsCollector::new();
-        let metrics = collector.get_metrics();
-        assert_eq!(metrics.objects_scanned, 0);
-        assert_eq!(metrics.versions_scanned, 0);
-    }
-
-    #[test]
-    fn test_metrics_increment() {
-        let collector = MetricsCollector::new();
-
-        collector.increment_objects_scanned(10);
-        collector.increment_versions_scanned(5);
-        collector.increment_objects_with_issues(2);
-
-        let metrics = collector.get_metrics();
-        assert_eq!(metrics.objects_scanned, 10);
-        assert_eq!(metrics.versions_scanned, 5);
-        assert_eq!(metrics.objects_with_issues, 2);
-    }
-
-    #[test]
-    fn test_metrics_reset() {
-        let collector = MetricsCollector::new();
-
-        collector.increment_objects_scanned(10);
-        collector.reset();
-
-        let metrics = collector.get_metrics();
-        assert_eq!(metrics.objects_scanned, 0);
-    }
-}

crates/ahm/src/scanner/io_monitor.rs

@@ -1,557 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::{
-    collections::VecDeque,
-    sync::{
-        Arc,
-        atomic::{AtomicU64, Ordering},
-    },
-    time::{Duration, SystemTime},
-};
-
-use serde::{Deserialize, Serialize};
-use tokio::sync::RwLock;
-use tokio_util::sync::CancellationToken;
-use tracing::{debug, error, info, warn};
-
-use super::node_scanner::LoadLevel;
-use crate::error::Result;
-
-/// IO monitor config   
-#[derive(Debug, Clone)]
-pub struct IOMonitorConfig {
-    /// monitor interval
-    pub monitor_interval: Duration,
-    /// history data retention time
-    pub history_retention: Duration,
-    /// load evaluation window size
-    pub load_window_size: usize,
-    /// whether to enable actual system monitoring
-    pub enable_system_monitoring: bool,
-    /// disk path list (for monitoring specific disks)
-    pub disk_paths: Vec<String>,
-}
-
-impl Default for IOMonitorConfig {
-    fn default() -> Self {
-        Self {
-            monitor_interval: Duration::from_secs(1),    // 1 second monitor interval
-            history_retention: Duration::from_secs(300), // keep 5 minutes history
-            load_window_size: 30,                        // 30 sample points sliding window
-            enable_system_monitoring: false,             // default use simulated data
-            disk_paths: Vec::new(),
-        }
-    }
-}
-
-/// IO monitor metrics
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct IOMetrics {
-    /// timestamp
-    pub timestamp: SystemTime,
-    /// disk IOPS (read + write)
-    pub iops: u64,
-    /// read IOPS
-    pub read_iops: u64,
-    /// write IOPS
-    pub write_iops: u64,
-    /// disk queue depth
-    pub queue_depth: u64,
-    /// average latency (milliseconds)
-    pub avg_latency: u64,
-    /// read latency (milliseconds)
-    pub read_latency: u64,
-    /// write latency (milliseconds)
-    pub write_latency: u64,
-    /// CPU usage (0-100)
-    pub cpu_usage: u8,
-    /// memory usage (0-100)
-    pub memory_usage: u8,
-    /// disk usage (0-100)
-    pub disk_utilization: u8,
-    /// network IO (Mbps)
-    pub network_io: u64,
-}
-
-impl Default for IOMetrics {
-    fn default() -> Self {
-        Self {
-            timestamp: SystemTime::now(),
-            iops: 0,
-            read_iops: 0,
-            write_iops: 0,
-            queue_depth: 0,
-            avg_latency: 0,
-            read_latency: 0,
-            write_latency: 0,
-            cpu_usage: 0,
-            memory_usage: 0,
-            disk_utilization: 0,
-            network_io: 0,
-        }
-    }
-}
-
-/// load level stats
-#[derive(Debug, Clone, Default)]
-pub struct LoadLevelStats {
-    /// low load duration (seconds)
-    pub low_load_duration: u64,
-    /// medium load duration (seconds)
-    pub medium_load_duration: u64,
-    /// high load duration (seconds)
-    pub high_load_duration: u64,
-    /// critical load duration (seconds)
-    pub critical_load_duration: u64,
-    /// load transitions
-    pub load_transitions: u64,
-}
-
-/// advanced IO monitor
-pub struct AdvancedIOMonitor {
-    /// config
-    config: Arc<RwLock<IOMonitorConfig>>,
-    /// current metrics
-    current_metrics: Arc<RwLock<IOMetrics>>,
-    /// history metrics (sliding window)
-    history_metrics: Arc<RwLock<VecDeque<IOMetrics>>>,
-    /// current load level
-    current_load_level: Arc<RwLock<LoadLevel>>,
-    /// load level history
-    load_level_history: Arc<RwLock<VecDeque<(SystemTime, LoadLevel)>>>,
-    /// load level stats
-    load_stats: Arc<RwLock<LoadLevelStats>>,
-    /// business IO metrics (updated by external)
-    business_metrics: Arc<BusinessIOMetrics>,
-    /// cancel token
-    cancel_token: CancellationToken,
-}
-
-/// business IO metrics
-pub struct BusinessIOMetrics {
-    /// business request latency (milliseconds)
-    pub request_latency: AtomicU64,
-    /// business request QPS
-    pub request_qps: AtomicU64,
-    /// business error rate (0-10000, 0.00%-100.00%)
-    pub error_rate: AtomicU64,
-    /// active connections
-    pub active_connections: AtomicU64,
-    /// last update time
-    pub last_update: Arc<RwLock<SystemTime>>,
-}
-
-impl Default for BusinessIOMetrics {
-    fn default() -> Self {
-        Self {
-            request_latency: AtomicU64::new(0),
-            request_qps: AtomicU64::new(0),
-            error_rate: AtomicU64::new(0),
-            active_connections: AtomicU64::new(0),
-            last_update: Arc::new(RwLock::new(SystemTime::UNIX_EPOCH)),
-        }
-    }
-}
-
-impl AdvancedIOMonitor {
-    /// create new advanced IO monitor
-    pub fn new(config: IOMonitorConfig) -> Self {
-        Self {
-            config: Arc::new(RwLock::new(config)),
-            current_metrics: Arc::new(RwLock::new(IOMetrics::default())),
-            history_metrics: Arc::new(RwLock::new(VecDeque::new())),
-            current_load_level: Arc::new(RwLock::new(LoadLevel::Low)),
-            load_level_history: Arc::new(RwLock::new(VecDeque::new())),
-            load_stats: Arc::new(RwLock::new(LoadLevelStats::default())),
-            business_metrics: Arc::new(BusinessIOMetrics::default()),
-            cancel_token: CancellationToken::new(),
-        }
-    }
-
-    /// start monitoring
-    pub async fn start(&self) -> Result<()> {
-        info!("start advanced IO monitor");
-
-        let monitor = self.clone_for_background();
-        tokio::spawn(async move {
-            if let Err(e) = monitor.monitoring_loop().await {
-                error!("IO monitoring loop failed: {}", e);
-            }
-        });
-
-        Ok(())
-    }
-
-    /// stop monitoring
-    pub async fn stop(&self) {
-        info!("stop IO monitor");
-        self.cancel_token.cancel();
-    }
-
-    /// monitoring loop
-    async fn monitoring_loop(&self) -> Result<()> {
-        let mut interval = {
-            let config = self.config.read().await;
-            tokio::time::interval(config.monitor_interval)
-        };
-
-        let mut last_load_level = LoadLevel::Low;
-        let mut load_level_start_time = SystemTime::now();
-
-        loop {
-            tokio::select! {
-                _ = self.cancel_token.cancelled() => {
-                    info!("IO monitoring loop cancelled");
-                    break;
-                }
-                _ = interval.tick() => {
-                    // collect system metrics
-                    let metrics = self.collect_system_metrics().await;
-
-                    // update current metrics
-                    *self.current_metrics.write().await = metrics.clone();
-
-                    // update history metrics
-                    self.update_metrics_history(metrics.clone()).await;
-
-                    // calculate load level
-                    let new_load_level = self.calculate_load_level(&metrics).await;
-
-                    // check if load level changed
-                    if new_load_level != last_load_level {
-                        self.handle_load_level_change(last_load_level, new_load_level, load_level_start_time).await;
-                        last_load_level = new_load_level;
-                        load_level_start_time = SystemTime::now();
-                    }
-
-                    // update current load level
-                    *self.current_load_level.write().await = new_load_level;
-
-                    debug!("IO monitor updated: IOPS={}, queue depth={}, latency={}ms, load level={:?}",
-                           metrics.iops, metrics.queue_depth, metrics.avg_latency, new_load_level);
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    /// collect system metrics
-    async fn collect_system_metrics(&self) -> IOMetrics {
-        let config = self.config.read().await;
-
-        if config.enable_system_monitoring {
-            // actual system monitoring implementation
-            self.collect_real_system_metrics().await
-        } else {
-            // simulated data
-            self.generate_simulated_metrics().await
-        }
-    }
-
-    /// collect real system metrics (need to be implemented according to specific system)
-    async fn collect_real_system_metrics(&self) -> IOMetrics {
-        // TODO: implement actual system metrics collection
-        // can use procfs, sysfs or other system API
-
-        let metrics = IOMetrics {
-            timestamp: SystemTime::now(),
-            ..Default::default()
-        };
-
-        // example: read /proc/diskstats
-        if let Ok(diskstats) = tokio::fs::read_to_string("/proc/diskstats").await {
-            // parse disk stats info
-            // here need to implement specific parsing logic
-            debug!("read disk stats info: {} bytes", diskstats.len());
-        }
-
-        // example: read /proc/stat to get CPU info
-        if let Ok(stat) = tokio::fs::read_to_string("/proc/stat").await {
-            // parse CPU stats info
-            debug!("read CPU stats info: {} bytes", stat.len());
-        }
-
-        // example: read /proc/meminfo to get memory info
-        if let Ok(meminfo) = tokio::fs::read_to_string("/proc/meminfo").await {
-            // parse memory stats info
-            debug!("read memory stats info: {} bytes", meminfo.len());
-        }
-
-        metrics
-    }
-
-    /// generate simulated metrics (for testing and development)
-    async fn generate_simulated_metrics(&self) -> IOMetrics {
-        use rand::Rng;
-        let mut rng = rand::rng();
-
-        // get business metrics impact
-        let business_latency = self.business_metrics.request_latency.load(Ordering::Relaxed);
-        let business_qps = self.business_metrics.request_qps.load(Ordering::Relaxed);
-
-        // generate simulated system metrics based on business load
-        let base_iops = 100 + (business_qps / 10);
-        let base_latency = 5 + (business_latency / 10);
-
-        IOMetrics {
-            timestamp: SystemTime::now(),
-            iops: base_iops + rng.random_range(0..50),
-            read_iops: (base_iops * 6 / 10) + rng.random_range(0..20),
-            write_iops: (base_iops * 4 / 10) + rng.random_range(0..20),
-            queue_depth: rng.random_range(1..20),
-            avg_latency: base_latency + rng.random_range(0..10),
-            read_latency: base_latency + rng.random_range(0..5),
-            write_latency: base_latency + rng.random_range(0..15),
-            cpu_usage: rng.random_range(10..70),
-            memory_usage: rng.random_range(30..80),
-            disk_utilization: rng.random_range(20..90),
-            network_io: rng.random_range(10..1000),
-        }
-    }
-
-    /// update metrics history
-    async fn update_metrics_history(&self, metrics: IOMetrics) {
-        let mut history = self.history_metrics.write().await;
-        let config = self.config.read().await;
-
-        // add new metrics
-        history.push_back(metrics);
-
-        // clean expired data
-        let retention_cutoff = SystemTime::now() - config.history_retention;
-        while let Some(front) = history.front() {
-            if front.timestamp < retention_cutoff {
-                history.pop_front();
-            } else {
-                break;
-            }
-        }
-
-        // limit window size
-        while history.len() > config.load_window_size {
-            history.pop_front();
-        }
-    }
-
-    /// calculate load level
-    async fn calculate_load_level(&self, metrics: &IOMetrics) -> LoadLevel {
-        // multi-dimensional load evaluation algorithm
-        let mut load_score = 0u32;
-
-        // IOPS load evaluation (weight: 25%)
-        let iops_score = match metrics.iops {
-            0..=200 => 0,
-            201..=500 => 15,
-            501..=1000 => 25,
-            _ => 35,
-        };
-        load_score += iops_score;
-
-        // latency load evaluation (weight: 30%)
-        let latency_score = match metrics.avg_latency {
-            0..=10 => 0,
-            11..=50 => 20,
-            51..=100 => 30,
-            _ => 40,
-        };
-        load_score += latency_score;
-
-        // queue depth evaluation (weight: 20%)
-        let queue_score = match metrics.queue_depth {
-            0..=5 => 0,
-            6..=15 => 10,
-            16..=30 => 20,
-            _ => 25,
-        };
-        load_score += queue_score;
-
-        // CPU usage evaluation (weight: 15%)
-        let cpu_score = match metrics.cpu_usage {
-            0..=30 => 0,
-            31..=60 => 8,
-            61..=80 => 12,
-            _ => 15,
-        };
-        load_score += cpu_score;
-
-        // disk usage evaluation (weight: 10%)
-        let disk_score = match metrics.disk_utilization {
-            0..=50 => 0,
-            51..=75 => 5,
-            76..=90 => 8,
-            _ => 10,
-        };
-        load_score += disk_score;
-
-        // business metrics impact
-        let business_latency = self.business_metrics.request_latency.load(Ordering::Relaxed);
-        let business_error_rate = self.business_metrics.error_rate.load(Ordering::Relaxed);
-
-        if business_latency > 100 {
-            load_score += 20; // business latency too high
-        }
-        if business_error_rate > 100 {
-            // > 1%
-            load_score += 15; // business error rate too high
-        }
-
-        // history trend analysis
-        let trend_score = self.calculate_trend_score().await;
-        load_score += trend_score;
-
-        // determine load level based on total score
-        match load_score {
-            0..=30 => LoadLevel::Low,
-            31..=60 => LoadLevel::Medium,
-            61..=90 => LoadLevel::High,
-            _ => LoadLevel::Critical,
-        }
-    }
-
-    /// calculate trend score
-    async fn calculate_trend_score(&self) -> u32 {
-        let history = self.history_metrics.read().await;
-
-        if history.len() < 5 {
-            return 0; // data insufficient, cannot analyze trend
-        }
-
-        // analyze trend of last 5 samples
-        let recent: Vec<_> = history.iter().rev().take(5).collect();
-
-        // check IOPS rising trend
-        let mut iops_trend = 0;
-        for i in 1..recent.len() {
-            if recent[i - 1].iops > recent[i].iops {
-                iops_trend += 1;
-            }
-        }
-
-        // check latency rising trend
-        let mut latency_trend = 0;
-        for i in 1..recent.len() {
-            if recent[i - 1].avg_latency > recent[i].avg_latency {
-                latency_trend += 1;
-            }
-        }
-
-        // if IOPS and latency are both rising, increase load score
-        if iops_trend >= 3 && latency_trend >= 3 {
-            15 // obvious rising trend
-        } else if iops_trend >= 2 || latency_trend >= 2 {
-            5 // slight rising trend
-        } else {
-            0 // no obvious trend
-        }
-    }
-
-    /// handle load level change
-    async fn handle_load_level_change(&self, old_level: LoadLevel, new_level: LoadLevel, start_time: SystemTime) {
-        let duration = SystemTime::now().duration_since(start_time).unwrap_or(Duration::ZERO);
-
-        // update stats
-        {
-            let mut stats = self.load_stats.write().await;
-            match old_level {
-                LoadLevel::Low => stats.low_load_duration += duration.as_secs(),
-                LoadLevel::Medium => stats.medium_load_duration += duration.as_secs(),
-                LoadLevel::High => stats.high_load_duration += duration.as_secs(),
-                LoadLevel::Critical => stats.critical_load_duration += duration.as_secs(),
-            }
-            stats.load_transitions += 1;
-        }
-
-        // update history
-        {
-            let mut history = self.load_level_history.write().await;
-            history.push_back((SystemTime::now(), new_level));
-
-            // keep history record in reasonable range
-            while history.len() > 100 {
-                history.pop_front();
-            }
-        }
-
-        info!("load level changed: {:?} -> {:?}, duration: {:?}", old_level, new_level, duration);
-
-        // if enter critical load state, record warning
-        if new_level == LoadLevel::Critical {
-            warn!("system entered critical load state, Scanner will pause running");
-        }
-    }
-
-    /// get current load level
-    pub async fn get_business_load_level(&self) -> LoadLevel {
-        *self.current_load_level.read().await
-    }
-
-    /// get current metrics
-    pub async fn get_current_metrics(&self) -> IOMetrics {
-        self.current_metrics.read().await.clone()
-    }
-
-    /// get history metrics
-    pub async fn get_history_metrics(&self) -> Vec<IOMetrics> {
-        self.history_metrics.read().await.iter().cloned().collect()
-    }
-
-    /// get load stats
-    pub async fn get_load_stats(&self) -> LoadLevelStats {
-        self.load_stats.read().await.clone()
-    }
-
-    /// update business IO metrics
-    pub async fn update_business_metrics(&self, latency: u64, qps: u64, error_rate: u64, connections: u64) {
-        self.business_metrics.request_latency.store(latency, Ordering::Relaxed);
-        self.business_metrics.request_qps.store(qps, Ordering::Relaxed);
-        self.business_metrics.error_rate.store(error_rate, Ordering::Relaxed);
-        self.business_metrics.active_connections.store(connections, Ordering::Relaxed);
-
-        *self.business_metrics.last_update.write().await = SystemTime::now();
-
-        debug!(
-            "update business metrics: latency={}ms, QPS={}, error rate={}‰, connections={}",
-            latency, qps, error_rate, connections
-        );
-    }
-
-    /// clone for background task
-    fn clone_for_background(&self) -> Self {
-        Self {
-            config: self.config.clone(),
-            current_metrics: self.current_metrics.clone(),
-            history_metrics: self.history_metrics.clone(),
-            current_load_level: self.current_load_level.clone(),
-            load_level_history: self.load_level_history.clone(),
-            load_stats: self.load_stats.clone(),
-            business_metrics: self.business_metrics.clone(),
-            cancel_token: self.cancel_token.clone(),
-        }
-    }
-
-    /// reset stats
-    pub async fn reset_stats(&self) {
-        *self.load_stats.write().await = LoadLevelStats::default();
-        self.load_level_history.write().await.clear();
-        self.history_metrics.write().await.clear();
-        info!("IO monitor stats reset");
-    }
-
-    /// get load level history
-    pub async fn get_load_level_history(&self) -> Vec<(SystemTime, LoadLevel)> {
-        self.load_level_history.read().await.iter().cloned().collect()
-    }
-}

crates/ahm/src/scanner/io_throttler.rs

@@ -1,501 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::{
-    sync::{
-        Arc,
-        atomic::{AtomicU8, AtomicU64, Ordering},
-    },
-    time::{Duration, SystemTime},
-};
-
-use tokio::sync::RwLock;
-use tracing::{debug, info, warn};
-
-use super::node_scanner::LoadLevel;
-
-/// IO throttler config
-#[derive(Debug, Clone)]
-pub struct IOThrottlerConfig {
-    /// max IOPS limit
-    pub max_iops: u64,
-    /// business priority baseline (percentage)
-    pub base_business_priority: u8,
-    /// scanner minimum delay (milliseconds)
-    pub min_scan_delay: u64,
-    /// scanner maximum delay (milliseconds)
-    pub max_scan_delay: u64,
-    /// whether enable dynamic adjustment
-    pub enable_dynamic_adjustment: bool,
-    /// adjustment response time (seconds)
-    pub adjustment_response_time: u64,
-}
-
-impl Default for IOThrottlerConfig {
-    fn default() -> Self {
-        Self {
-            max_iops: 1000,             // default max 1000 IOPS
-            base_business_priority: 95, // business priority 95%
-            min_scan_delay: 5000,       // minimum 5s delay
-            max_scan_delay: 60000,      // maximum 60s delay
-            enable_dynamic_adjustment: true,
-            adjustment_response_time: 5, // 5 seconds response time
-        }
-    }
-}
-
-/// resource allocation strategy
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ResourceAllocationStrategy {
-    /// business priority strategy
-    BusinessFirst,
-    /// balanced strategy
-    Balanced,
-    /// maintenance priority strategy (only used in special cases)
-    MaintenanceFirst,
-}
-
-/// throttle decision
-#[derive(Debug, Clone)]
-pub struct ThrottleDecision {
-    /// whether should pause scanning
-    pub should_pause: bool,
-    /// suggested scanning delay
-    pub suggested_delay: Duration,
-    /// resource allocation suggestion
-    pub resource_allocation: ResourceAllocation,
-    /// decision reason
-    pub reason: String,
-}
-
-/// resource allocation
-#[derive(Debug, Clone)]
-pub struct ResourceAllocation {
-    /// business IO allocation percentage (0-100)
-    pub business_percentage: u8,
-    /// scanner IO allocation percentage (0-100)
-    pub scanner_percentage: u8,
-    /// allocation strategy
-    pub strategy: ResourceAllocationStrategy,
-}
-
-/// enhanced IO throttler
-///
-/// dynamically adjust the resource usage of the scanner based on real-time system load and business demand,
-/// ensure business IO gets priority protection.
-pub struct AdvancedIOThrottler {
-    /// config
-    config: Arc<RwLock<IOThrottlerConfig>>,
-    /// current IOPS usage (reserved field)
-    #[allow(dead_code)]
-    current_iops: Arc<AtomicU64>,
-    /// business priority weight (0-100)
-    business_priority: Arc<AtomicU8>,
-    /// scanning operation delay (milliseconds)
-    scan_delay: Arc<AtomicU64>,
-    /// resource allocation strategy
-    allocation_strategy: Arc<RwLock<ResourceAllocationStrategy>>,
-    /// throttle history record
-    throttle_history: Arc<RwLock<Vec<ThrottleRecord>>>,
-    /// last adjustment time (reserved field)
-    #[allow(dead_code)]
-    last_adjustment: Arc<RwLock<SystemTime>>,
-}
-
-/// throttle record
-#[derive(Debug, Clone)]
-pub struct ThrottleRecord {
-    /// timestamp
-    pub timestamp: SystemTime,
-    /// load level
-    pub load_level: LoadLevel,
-    /// decision
-    pub decision: ThrottleDecision,
-    /// system metrics snapshot
-    pub metrics_snapshot: MetricsSnapshot,
-}
-
-/// metrics snapshot
-#[derive(Debug, Clone)]
-pub struct MetricsSnapshot {
-    /// IOPS
-    pub iops: u64,
-    /// latency
-    pub latency: u64,
-    /// CPU usage
-    pub cpu_usage: u8,
-    /// memory usage
-    pub memory_usage: u8,
-}
-
-impl AdvancedIOThrottler {
-    /// create new advanced IO throttler
-    pub fn new(config: IOThrottlerConfig) -> Self {
-        Self {
-            config: Arc::new(RwLock::new(config)),
-            current_iops: Arc::new(AtomicU64::new(0)),
-            business_priority: Arc::new(AtomicU8::new(95)),
-            scan_delay: Arc::new(AtomicU64::new(5000)),
-            allocation_strategy: Arc::new(RwLock::new(ResourceAllocationStrategy::BusinessFirst)),
-            throttle_history: Arc::new(RwLock::new(Vec::new())),
-            last_adjustment: Arc::new(RwLock::new(SystemTime::UNIX_EPOCH)),
-        }
-    }
-
-    /// adjust scanning delay based on load level
-    pub async fn adjust_for_load_level(&self, load_level: LoadLevel) -> Duration {
-        let config = self.config.read().await;
-
-        let delay_ms = match load_level {
-            LoadLevel::Low => {
-                // low load: use minimum delay
-                self.scan_delay.store(config.min_scan_delay, Ordering::Relaxed);
-                self.business_priority
-                    .store(config.base_business_priority.saturating_sub(5), Ordering::Relaxed);
-                config.min_scan_delay
-            }
-            LoadLevel::Medium => {
-                // medium load: increase delay moderately
-                let delay = config.min_scan_delay * 5; // 500ms
-                self.scan_delay.store(delay, Ordering::Relaxed);
-                self.business_priority.store(config.base_business_priority, Ordering::Relaxed);
-                delay
-            }
-            LoadLevel::High => {
-                // high load: increase delay significantly
-                let delay = config.min_scan_delay * 10; // 50s
-                self.scan_delay.store(delay, Ordering::Relaxed);
-                self.business_priority
-                    .store(config.base_business_priority.saturating_add(3), Ordering::Relaxed);
-                delay
-            }
-            LoadLevel::Critical => {
-                // critical load: maximum delay or pause
-                let delay = config.max_scan_delay; // 60s
-                self.scan_delay.store(delay, Ordering::Relaxed);
-                self.business_priority.store(99, Ordering::Relaxed);
-                delay
-            }
-        };
-
-        let duration = Duration::from_millis(delay_ms);
-
-        debug!("Adjust scanning delay based on load level {:?}: {:?}", load_level, duration);
-
-        duration
-    }
-
-    /// create throttle decision
-    pub async fn make_throttle_decision(&self, load_level: LoadLevel, metrics: Option<MetricsSnapshot>) -> ThrottleDecision {
-        let _config = self.config.read().await;
-
-        let should_pause = matches!(load_level, LoadLevel::Critical);
-
-        let suggested_delay = self.adjust_for_load_level(load_level).await;
-
-        let resource_allocation = self.calculate_resource_allocation(load_level).await;
-
-        let reason = match load_level {
-            LoadLevel::Low => "system load is low, scanner can run normally".to_string(),
-            LoadLevel::Medium => "system load is moderate, scanner is running at reduced speed".to_string(),
-            LoadLevel::High => "system load is high, scanner is running at significantly reduced speed".to_string(),
-            LoadLevel::Critical => "system load is too high, scanner is paused".to_string(),
-        };
-
-        let decision = ThrottleDecision {
-            should_pause,
-            suggested_delay,
-            resource_allocation,
-            reason,
-        };
-
-        // record decision history
-        if let Some(snapshot) = metrics {
-            self.record_throttle_decision(load_level, decision.clone(), snapshot).await;
-        }
-
-        decision
-    }
-
-    /// calculate resource allocation
-    async fn calculate_resource_allocation(&self, load_level: LoadLevel) -> ResourceAllocation {
-        let strategy = *self.allocation_strategy.read().await;
-
-        let (business_pct, scanner_pct) = match (strategy, load_level) {
-            (ResourceAllocationStrategy::BusinessFirst, LoadLevel::Low) => (90, 10),
-            (ResourceAllocationStrategy::BusinessFirst, LoadLevel::Medium) => (95, 5),
-            (ResourceAllocationStrategy::BusinessFirst, LoadLevel::High) => (98, 2),
-            (ResourceAllocationStrategy::BusinessFirst, LoadLevel::Critical) => (99, 1),
-
-            (ResourceAllocationStrategy::Balanced, LoadLevel::Low) => (80, 20),
-            (ResourceAllocationStrategy::Balanced, LoadLevel::Medium) => (85, 15),
-            (ResourceAllocationStrategy::Balanced, LoadLevel::High) => (90, 10),
-            (ResourceAllocationStrategy::Balanced, LoadLevel::Critical) => (95, 5),
-
-            (ResourceAllocationStrategy::MaintenanceFirst, _) => (70, 30), // special maintenance mode
-        };
-
-        ResourceAllocation {
-            business_percentage: business_pct,
-            scanner_percentage: scanner_pct,
-            strategy,
-        }
-    }
-
-    /// check whether should pause scanning
-    pub async fn should_pause_scanning(&self, load_level: LoadLevel) -> bool {
-        match load_level {
-            LoadLevel::Critical => {
-                warn!("System load reached critical level, pausing scanner");
-                true
-            }
-            _ => false,
-        }
-    }
-
-    /// record throttle decision
-    async fn record_throttle_decision(&self, load_level: LoadLevel, decision: ThrottleDecision, metrics: MetricsSnapshot) {
-        let record = ThrottleRecord {
-            timestamp: SystemTime::now(),
-            load_level,
-            decision,
-            metrics_snapshot: metrics,
-        };
-
-        let mut history = self.throttle_history.write().await;
-        history.push(record);
-
-        // keep history record in reasonable range (last 1000 records)
-        while history.len() > 1000 {
-            history.remove(0);
-        }
-    }
-
-    /// set resource allocation strategy
-    pub async fn set_allocation_strategy(&self, strategy: ResourceAllocationStrategy) {
-        *self.allocation_strategy.write().await = strategy;
-        info!("Set resource allocation strategy: {:?}", strategy);
-    }
-
-    /// get current resource allocation
-    pub async fn get_current_allocation(&self) -> ResourceAllocation {
-        let current_load = LoadLevel::Low; // need to get from external
-        self.calculate_resource_allocation(current_load).await
-    }
-
-    /// get throttle history
-    pub async fn get_throttle_history(&self) -> Vec<ThrottleRecord> {
-        self.throttle_history.read().await.clone()
-    }
-
-    /// get throttle stats
-    pub async fn get_throttle_stats(&self) -> ThrottleStats {
-        let history = self.throttle_history.read().await;
-
-        let total_decisions = history.len();
-        let pause_decisions = history.iter().filter(|r| r.decision.should_pause).count();
-
-        let mut delay_sum = Duration::ZERO;
-        for record in history.iter() {
-            delay_sum += record.decision.suggested_delay;
-        }
-
-        let avg_delay = if total_decisions > 0 {
-            delay_sum / total_decisions as u32
-        } else {
-            Duration::ZERO
-        };
-
-        // count by load level
-        let low_count = history.iter().filter(|r| r.load_level == LoadLevel::Low).count();
-        let medium_count = history.iter().filter(|r| r.load_level == LoadLevel::Medium).count();
-        let high_count = history.iter().filter(|r| r.load_level == LoadLevel::High).count();
-        let critical_count = history.iter().filter(|r| r.load_level == LoadLevel::Critical).count();
-
-        ThrottleStats {
-            total_decisions,
-            pause_decisions,
-            average_delay: avg_delay,
-            load_level_distribution: LoadLevelDistribution {
-                low_count,
-                medium_count,
-                high_count,
-                critical_count,
-            },
-        }
-    }
-
-    /// reset throttle history
-    pub async fn reset_history(&self) {
-        self.throttle_history.write().await.clear();
-        info!("Reset throttle history");
-    }
-
-    /// update config
-    pub async fn update_config(&self, new_config: IOThrottlerConfig) {
-        *self.config.write().await = new_config;
-        info!("Updated IO throttler configuration");
-    }
-
-    /// get current scanning delay
-    pub fn get_current_scan_delay(&self) -> Duration {
-        let delay_ms = self.scan_delay.load(Ordering::Relaxed);
-        Duration::from_millis(delay_ms)
-    }
-
-    /// get current business priority
-    pub fn get_current_business_priority(&self) -> u8 {
-        self.business_priority.load(Ordering::Relaxed)
-    }
-
-    /// simulate business load pressure test
-    pub async fn simulate_business_pressure(&self, duration: Duration) -> SimulationResult {
-        info!("Start simulating business load pressure test, duration: {:?}", duration);
-
-        let start_time = SystemTime::now();
-        let mut simulation_records = Vec::new();
-
-        // simulate different load level changes
-        let load_levels = [
-            LoadLevel::Low,
-            LoadLevel::Medium,
-            LoadLevel::High,
-            LoadLevel::Critical,
-            LoadLevel::High,
-            LoadLevel::Medium,
-            LoadLevel::Low,
-        ];
-
-        let step_duration = duration / load_levels.len() as u32;
-
-        for (i, &load_level) in load_levels.iter().enumerate() {
-            let _step_start = SystemTime::now();
-
-            // simulate metrics for this load level
-            let metrics = MetricsSnapshot {
-                iops: match load_level {
-                    LoadLevel::Low => 200,
-                    LoadLevel::Medium => 500,
-                    LoadLevel::High => 800,
-                    LoadLevel::Critical => 1200,
-                },
-                latency: match load_level {
-                    LoadLevel::Low => 10,
-                    LoadLevel::Medium => 25,
-                    LoadLevel::High => 60,
-                    LoadLevel::Critical => 150,
-                },
-                cpu_usage: match load_level {
-                    LoadLevel::Low => 30,
-                    LoadLevel::Medium => 50,
-                    LoadLevel::High => 75,
-                    LoadLevel::Critical => 95,
-                },
-                memory_usage: match load_level {
-                    LoadLevel::Low => 40,
-                    LoadLevel::Medium => 60,
-                    LoadLevel::High => 80,
-                    LoadLevel::Critical => 90,
-                },
-            };
-
-            let decision = self.make_throttle_decision(load_level, Some(metrics.clone())).await;
-
-            simulation_records.push(SimulationRecord {
-                step: i + 1,
-                load_level,
-                metrics,
-                decision: decision.clone(),
-                step_duration,
-            });
-
-            info!(
-                "simulate step {}: load={:?}, delay={:?}, pause={}",
-                i + 1,
-                load_level,
-                decision.suggested_delay,
-                decision.should_pause
-            );
-
-            // wait for step duration
-            tokio::time::sleep(step_duration).await;
-        }
-
-        let total_duration = SystemTime::now().duration_since(start_time).unwrap_or(Duration::ZERO);
-
-        SimulationResult {
-            total_duration,
-            simulation_records,
-            final_stats: self.get_throttle_stats().await,
-        }
-    }
-}
-
-/// throttle stats
-#[derive(Debug, Clone)]
-pub struct ThrottleStats {
-    /// total decisions
-    pub total_decisions: usize,
-    /// pause decisions
-    pub pause_decisions: usize,
-    /// average delay
-    pub average_delay: Duration,
-    /// load level distribution
-    pub load_level_distribution: LoadLevelDistribution,
-}
-
-/// load level distribution
-#[derive(Debug, Clone)]
-pub struct LoadLevelDistribution {
-    /// low load count
-    pub low_count: usize,
-    /// medium load count
-    pub medium_count: usize,
-    /// high load count
-    pub high_count: usize,
-    /// critical load count
-    pub critical_count: usize,
-}
-
-/// simulation result
-#[derive(Debug, Clone)]
-pub struct SimulationResult {
-    /// total duration
-    pub total_duration: Duration,
-    /// simulation records
-    pub simulation_records: Vec<SimulationRecord>,
-    /// final stats
-    pub final_stats: ThrottleStats,
-}
-
-/// simulation record
-#[derive(Debug, Clone)]
-pub struct SimulationRecord {
-    /// step number
-    pub step: usize,
-    /// load level
-    pub load_level: LoadLevel,
-    /// metrics snapshot
-    pub metrics: MetricsSnapshot,
-    /// throttle decision
-    pub decision: ThrottleDecision,
-    /// step duration
-    pub step_duration: Duration,
-}
-
-impl Default for AdvancedIOThrottler {
-    fn default() -> Self {
-        Self::new(IOThrottlerConfig::default())
-    }
-}

crates/ahm/src/scanner/lifecycle.rs

@@ -1,262 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::sync::Arc;
-use std::sync::atomic::{AtomicU64, Ordering};
-
-use crate::error::Result;
-use rustfs_common::data_usage::SizeSummary;
-use rustfs_common::metrics::IlmAction;
-use rustfs_ecstore::bucket::lifecycle::{
-    bucket_lifecycle_audit::LcEventSrc,
-    bucket_lifecycle_ops::{GLOBAL_ExpiryState, apply_lifecycle_action, eval_action_from_lifecycle},
-    lifecycle,
-    lifecycle::Lifecycle,
-};
-use rustfs_ecstore::bucket::metadata_sys::get_object_lock_config;
-use rustfs_ecstore::bucket::object_lock::objectlock_sys::{BucketObjectLockSys, enforce_retention_for_deletion};
-use rustfs_ecstore::bucket::versioning::VersioningApi;
-use rustfs_ecstore::bucket::versioning_sys::BucketVersioningSys;
-use rustfs_ecstore::cmd::bucket_targets::VersioningConfig;
-use rustfs_ecstore::store_api::{ObjectInfo, ObjectToDelete};
-use rustfs_filemeta::FileInfo;
-use s3s::dto::BucketLifecycleConfiguration as LifecycleConfig;
-use time::OffsetDateTime;
-use tracing::info;
-
-static SCANNER_EXCESS_OBJECT_VERSIONS: AtomicU64 = AtomicU64::new(100);
-static SCANNER_EXCESS_OBJECT_VERSIONS_TOTAL_SIZE: AtomicU64 = AtomicU64::new(1024 * 1024 * 1024 * 1024); // 1 TB
-
-#[derive(Clone)]
-pub struct ScannerItem {
-    pub bucket: String,
-    pub object_name: String,
-    pub lifecycle: Option<Arc<LifecycleConfig>>,
-    pub versioning: Option<Arc<VersioningConfig>>,
-}
-
-impl ScannerItem {
-    pub fn new(bucket: String, lifecycle: Option<Arc<LifecycleConfig>>, versioning: Option<Arc<VersioningConfig>>) -> Self {
-        Self {
-            bucket,
-            object_name: "".to_string(),
-            lifecycle,
-            versioning,
-        }
-    }
-
-    pub async fn apply_versions_actions(&self, fivs: &[FileInfo]) -> Result<Vec<ObjectInfo>> {
-        let obj_infos = self.apply_newer_noncurrent_version_limit(fivs).await?;
-        if obj_infos.len() >= SCANNER_EXCESS_OBJECT_VERSIONS.load(Ordering::SeqCst) as usize {
-            // todo
-        }
-
-        let mut cumulative_size = 0;
-        for obj_info in obj_infos.iter() {
-            cumulative_size += obj_info.size;
-        }
-
-        if cumulative_size >= SCANNER_EXCESS_OBJECT_VERSIONS_TOTAL_SIZE.load(Ordering::SeqCst) as i64 {
-            //todo
-        }
-
-        Ok(obj_infos)
-    }
-
-    pub async fn apply_newer_noncurrent_version_limit(&self, fivs: &[FileInfo]) -> Result<Vec<ObjectInfo>> {
-        let lock_enabled = if let Some(rcfg) = BucketObjectLockSys::get(&self.bucket).await {
-            rcfg.mode.is_some()
-        } else {
-            false
-        };
-        let _vcfg = BucketVersioningSys::get(&self.bucket).await?;
-
-        let versioned = match BucketVersioningSys::get(&self.bucket).await {
-            Ok(vcfg) => vcfg.versioned(&self.object_name),
-            Err(_) => false,
-        };
-        let mut object_infos = Vec::with_capacity(fivs.len());
-
-        if self.lifecycle.is_none() {
-            for info in fivs.iter() {
-                object_infos.push(ObjectInfo::from_file_info(info, &self.bucket, &self.object_name, versioned));
-            }
-            return Ok(object_infos);
-        }
-
-        let event = self
-            .lifecycle
-            .as_ref()
-            .expect("lifecycle err.")
-            .clone()
-            .noncurrent_versions_expiration_limit(&lifecycle::ObjectOpts {
-                name: self.object_name.clone(),
-                ..Default::default()
-            })
-            .await;
-        let lim = event.newer_noncurrent_versions;
-        if lim == 0 || fivs.len() <= lim + 1 {
-            for fi in fivs.iter() {
-                object_infos.push(ObjectInfo::from_file_info(fi, &self.bucket, &self.object_name, versioned));
-            }
-            return Ok(object_infos);
-        }
-
-        let overflow_versions = &fivs[lim + 1..];
-        for fi in fivs[..lim + 1].iter() {
-            object_infos.push(ObjectInfo::from_file_info(fi, &self.bucket, &self.object_name, versioned));
-        }
-
-        let mut to_del = Vec::<ObjectToDelete>::with_capacity(overflow_versions.len());
-        for fi in overflow_versions.iter() {
-            let obj = ObjectInfo::from_file_info(fi, &self.bucket, &self.object_name, versioned);
-            if lock_enabled && enforce_retention_for_deletion(&obj) {
-                //if enforce_retention_for_deletion(&obj) {
-                /*if self.debug {
-                    if obj.version_id.is_some() {
-                        info!("lifecycle: {} v({}) is locked, not deleting\n", obj.name, obj.version_id.expect("err"));
-                    } else {
-                        info!("lifecycle: {} is locked, not deleting\n", obj.name);
-                    }
-                }*/
-                object_infos.push(obj);
-                continue;
-            }
-
-            if OffsetDateTime::now_utc().unix_timestamp()
-                < lifecycle::expected_expiry_time(obj.successor_mod_time.expect("err"), event.noncurrent_days as i32)
-                    .unix_timestamp()
-            {
-                object_infos.push(obj);
-                continue;
-            }
-
-            to_del.push(ObjectToDelete {
-                object_name: obj.name,
-                version_id: obj.version_id,
-            });
-        }
-
-        if !to_del.is_empty() {
-            let mut expiry_state = GLOBAL_ExpiryState.write().await;
-            expiry_state.enqueue_by_newer_noncurrent(&self.bucket, to_del, event).await;
-        }
-
-        Ok(object_infos)
-    }
-
-    pub async fn apply_actions(&mut self, oi: &ObjectInfo, _size_s: &mut SizeSummary) -> (bool, i64) {
-        let (action, _size) = self.apply_lifecycle(oi).await;
-
-        info!(
-            "apply_actions {} {} {:?} {:?}",
-            oi.bucket.clone(),
-            oi.name.clone(),
-            oi.version_id.clone(),
-            oi.user_defined.clone()
-        );
-
-        // Create a mutable clone if you need to modify fields
-        /*let mut oi = oi.clone();
-        oi.replication_status = ReplicationStatusType::from(
-            oi.user_defined
-                .get("x-amz-bucket-replication-status")
-                .unwrap_or(&"PENDING".to_string()),
-        );
-        info!("apply status is: {:?}", oi.replication_status);
-        self.heal_replication(&oi, _size_s).await;*/
-
-        if action.delete_all() {
-            return (true, 0);
-        }
-
-        (false, oi.size)
-    }
-
-    async fn apply_lifecycle(&mut self, oi: &ObjectInfo) -> (IlmAction, i64) {
-        let size = oi.size;
-        if self.lifecycle.is_none() {
-            info!("apply_lifecycle: No lifecycle config for object: {}", oi.name);
-            return (IlmAction::NoneAction, size);
-        }
-
-        info!("apply_lifecycle: Lifecycle config exists for object: {}", oi.name);
-
-        let (olcfg, rcfg) = if self.bucket != ".minio.sys" {
-            (
-                get_object_lock_config(&self.bucket).await.ok(),
-                None, // FIXME: replication config
-            )
-        } else {
-            (None, None)
-        };
-
-        info!("apply_lifecycle: Evaluating lifecycle for object: {}", oi.name);
-
-        let lifecycle = match self.lifecycle.as_ref() {
-            Some(lc) => lc,
-            None => {
-                info!("No lifecycle configuration found for object: {}", oi.name);
-                return (IlmAction::NoneAction, 0);
-            }
-        };
-
-        let lc_evt = eval_action_from_lifecycle(
-            lifecycle,
-            olcfg
-                .as_ref()
-                .and_then(|(c, _)| c.rule.as_ref().and_then(|r| r.default_retention.clone())),
-            rcfg.clone(),
-            oi, // Pass oi directly
-        )
-        .await;
-
-        info!("lifecycle: {} Initial scan: {} (action: {:?})", oi.name, lc_evt.action, lc_evt.action);
-
-        let mut new_size = size;
-        match lc_evt.action {
-            IlmAction::DeleteVersionAction | IlmAction::DeleteAllVersionsAction | IlmAction::DelMarkerDeleteAllVersionsAction => {
-                info!("apply_lifecycle: Object {} marked for version deletion, new_size=0", oi.name);
-                new_size = 0;
-            }
-            IlmAction::DeleteAction => {
-                info!("apply_lifecycle: Object {} marked for deletion", oi.name);
-                if let Some(vcfg) = &self.versioning {
-                    if !vcfg.is_enabled() {
-                        info!("apply_lifecycle: Versioning disabled, setting new_size=0");
-                        new_size = 0;
-                    }
-                } else {
-                    info!("apply_lifecycle: No versioning config, setting new_size=0");
-                    new_size = 0;
-                }
-            }
-            IlmAction::NoneAction => {
-                info!("apply_lifecycle: No action for object {}", oi.name);
-            }
-            _ => {
-                info!("apply_lifecycle: Other action {:?} for object {}", lc_evt.action, oi.name);
-            }
-        }
-
-        if lc_evt.action != IlmAction::NoneAction {
-            info!("apply_lifecycle: Applying lifecycle action {:?} for object {}", lc_evt.action, oi.name);
-            apply_lifecycle_action(&lc_evt, &LcEventSrc::Scanner, oi).await;
-        } else {
-            info!("apply_lifecycle: Skipping lifecycle action for object {} as no action is needed", oi.name);
-        }
-
-        (lc_evt.action, new_size)
-    }
-}

crates/ahm/src/scanner/local_stats.rs

@@ -1,430 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::{
-    path::{Path, PathBuf},
-    sync::Arc,
-    sync::atomic::{AtomicU64, Ordering},
-    time::{Duration, SystemTime},
-};
-
-use serde::{Deserialize, Serialize};
-use tokio::sync::RwLock;
-use tracing::{debug, error, info, warn};
-
-use rustfs_common::data_usage::DataUsageInfo;
-
-use super::node_scanner::{BucketStats, DiskStats, LocalScanStats};
-use crate::{Error, error::Result};
-
-/// local stats manager
-pub struct LocalStatsManager {
-    /// node id
-    node_id: String,
-    /// stats file path
-    stats_file: PathBuf,
-    /// backup file path
-    backup_file: PathBuf,
-    /// temp file path
-    temp_file: PathBuf,
-    /// local stats data
-    stats: Arc<RwLock<LocalScanStats>>,
-    /// save interval
-    save_interval: Duration,
-    /// last save time
-    last_save: Arc<RwLock<SystemTime>>,
-    /// stats counters
-    counters: Arc<StatsCounters>,
-}
-
-/// stats counters
-pub struct StatsCounters {
-    /// total scanned objects
-    pub total_objects_scanned: AtomicU64,
-    /// total healthy objects
-    pub total_healthy_objects: AtomicU64,
-    /// total corrupted objects  
-    pub total_corrupted_objects: AtomicU64,
-    /// total scanned bytes
-    pub total_bytes_scanned: AtomicU64,
-    /// total scan errors
-    pub total_scan_errors: AtomicU64,
-    /// total heal triggered
-    pub total_heal_triggered: AtomicU64,
-}
-
-impl Default for StatsCounters {
-    fn default() -> Self {
-        Self {
-            total_objects_scanned: AtomicU64::new(0),
-            total_healthy_objects: AtomicU64::new(0),
-            total_corrupted_objects: AtomicU64::new(0),
-            total_bytes_scanned: AtomicU64::new(0),
-            total_scan_errors: AtomicU64::new(0),
-            total_heal_triggered: AtomicU64::new(0),
-        }
-    }
-}
-
-/// scan result entry
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ScanResultEntry {
-    /// object path
-    pub object_path: String,
-    /// bucket name
-    pub bucket_name: String,
-    /// object size
-    pub object_size: u64,
-    /// is healthy
-    pub is_healthy: bool,
-    /// error message (if any)
-    pub error_message: Option<String>,
-    /// scan time
-    pub scan_time: SystemTime,
-    /// disk id
-    pub disk_id: String,
-}
-
-/// batch scan result
-#[derive(Debug, Clone)]
-pub struct BatchScanResult {
-    /// disk id
-    pub disk_id: String,
-    /// scan result entries
-    pub entries: Vec<ScanResultEntry>,
-    /// scan start time
-    pub scan_start: SystemTime,
-    /// scan end time
-    pub scan_end: SystemTime,
-    /// scan duration
-    pub scan_duration: Duration,
-}
-
-impl LocalStatsManager {
-    /// create new local stats manager
-    pub fn new(node_id: &str, data_dir: &Path) -> Self {
-        // ensure data directory exists
-        if !data_dir.exists() {
-            if let Err(e) = std::fs::create_dir_all(data_dir) {
-                error!("create stats data directory failed {:?}: {}", data_dir, e);
-            }
-        }
-
-        let stats_file = data_dir.join(format!("scanner_stats_{}.json", node_id));
-        let backup_file = data_dir.join(format!("scanner_stats_{}.backup", node_id));
-        let temp_file = data_dir.join(format!("scanner_stats_{}.tmp", node_id));
-
-        Self {
-            node_id: node_id.to_string(),
-            stats_file,
-            backup_file,
-            temp_file,
-            stats: Arc::new(RwLock::new(LocalScanStats::default())),
-            save_interval: Duration::from_secs(60), // 60 seconds save once
-            last_save: Arc::new(RwLock::new(SystemTime::UNIX_EPOCH)),
-            counters: Arc::new(StatsCounters::default()),
-        }
-    }
-
-    /// load local stats data
-    pub async fn load_stats(&self) -> Result<()> {
-        if !self.stats_file.exists() {
-            info!("stats data file not exists, will create new stats data");
-            return Ok(());
-        }
-
-        match self.load_stats_from_file(&self.stats_file).await {
-            Ok(stats) => {
-                *self.stats.write().await = stats;
-                info!("success load local stats data");
-                Ok(())
-            }
-            Err(e) => {
-                warn!("load main stats file failed: {}, try backup file", e);
-
-                match self.load_stats_from_file(&self.backup_file).await {
-                    Ok(stats) => {
-                        *self.stats.write().await = stats;
-                        warn!("restore stats data from backup file");
-                        Ok(())
-                    }
-                    Err(backup_e) => {
-                        warn!("backup file also cannot load: {}, will use default stats data", backup_e);
-                        Ok(())
-                    }
-                }
-            }
-        }
-    }
-
-    /// load stats data from file
-    async fn load_stats_from_file(&self, file_path: &Path) -> Result<LocalScanStats> {
-        let content = tokio::fs::read_to_string(file_path)
-            .await
-            .map_err(|e| Error::IO(format!("read stats file failed: {}", e)))?;
-
-        let stats: LocalScanStats =
-            serde_json::from_str(&content).map_err(|e| Error::Serialization(format!("deserialize stats data failed: {}", e)))?;
-
-        Ok(stats)
-    }
-
-    /// save stats data to disk
-    pub async fn save_stats(&self) -> Result<()> {
-        let now = SystemTime::now();
-        let last_save = *self.last_save.read().await;
-
-        // frequency control
-        if now.duration_since(last_save).unwrap_or(Duration::ZERO) < self.save_interval {
-            return Ok(());
-        }
-
-        let stats = self.stats.read().await.clone();
-
-        // serialize
-        let json_data = serde_json::to_string_pretty(&stats)
-            .map_err(|e| Error::Serialization(format!("serialize stats data failed: {}", e)))?;
-
-        // atomic write
-        tokio::fs::write(&self.temp_file, json_data)
-            .await
-            .map_err(|e| Error::IO(format!("write temp stats file failed: {}", e)))?;
-
-        // backup existing file
-        if self.stats_file.exists() {
-            tokio::fs::copy(&self.stats_file, &self.backup_file)
-                .await
-                .map_err(|e| Error::IO(format!("backup stats file failed: {}", e)))?;
-        }
-
-        // atomic replace
-        tokio::fs::rename(&self.temp_file, &self.stats_file)
-            .await
-            .map_err(|e| Error::IO(format!("replace stats file failed: {}", e)))?;
-
-        *self.last_save.write().await = now;
-
-        debug!("save local stats data to {:?}", self.stats_file);
-        Ok(())
-    }
-
-    /// force save stats data
-    pub async fn force_save_stats(&self) -> Result<()> {
-        *self.last_save.write().await = SystemTime::UNIX_EPOCH;
-        self.save_stats().await
-    }
-
-    /// update disk scan result
-    pub async fn update_disk_scan_result(&self, result: &BatchScanResult) -> Result<()> {
-        let mut stats = self.stats.write().await;
-
-        // update disk stats
-        let disk_stat = stats.disks_stats.entry(result.disk_id.clone()).or_insert_with(|| DiskStats {
-            disk_id: result.disk_id.clone(),
-            ..Default::default()
-        });
-
-        let healthy_count = result.entries.iter().filter(|e| e.is_healthy).count() as u64;
-        let error_count = result.entries.iter().filter(|e| !e.is_healthy).count() as u64;
-
-        disk_stat.objects_scanned += result.entries.len() as u64;
-        disk_stat.errors_count += error_count;
-        disk_stat.last_scan_time = result.scan_end;
-        disk_stat.scan_duration = result.scan_duration;
-        disk_stat.scan_completed = true;
-
-        // update overall stats
-        stats.objects_scanned += result.entries.len() as u64;
-        stats.healthy_objects += healthy_count;
-        stats.corrupted_objects += error_count;
-        stats.last_update = SystemTime::now();
-
-        // update bucket stats
-        for entry in &result.entries {
-            let _bucket_stat = stats
-                .buckets_stats
-                .entry(entry.bucket_name.clone())
-                .or_insert_with(BucketStats::default);
-
-            // TODO: update BucketStats
-        }
-
-        // update atomic counters
-        self.counters
-            .total_objects_scanned
-            .fetch_add(result.entries.len() as u64, Ordering::Relaxed);
-        self.counters
-            .total_healthy_objects
-            .fetch_add(healthy_count, Ordering::Relaxed);
-        self.counters
-            .total_corrupted_objects
-            .fetch_add(error_count, Ordering::Relaxed);
-
-        let total_bytes: u64 = result.entries.iter().map(|e| e.object_size).sum();
-        self.counters.total_bytes_scanned.fetch_add(total_bytes, Ordering::Relaxed);
-
-        if error_count > 0 {
-            self.counters.total_scan_errors.fetch_add(error_count, Ordering::Relaxed);
-        }
-
-        drop(stats);
-
-        debug!(
-            "update disk {} scan result: objects {}, healthy {}, error {}",
-            result.disk_id,
-            result.entries.len(),
-            healthy_count,
-            error_count
-        );
-
-        Ok(())
-    }
-
-    /// record single object scan result
-    pub async fn record_object_scan(&self, entry: ScanResultEntry) -> Result<()> {
-        let result = BatchScanResult {
-            disk_id: entry.disk_id.clone(),
-            entries: vec![entry],
-            scan_start: SystemTime::now(),
-            scan_end: SystemTime::now(),
-            scan_duration: Duration::from_millis(0),
-        };
-
-        self.update_disk_scan_result(&result).await
-    }
-
-    /// get local stats data copy
-    pub async fn get_stats(&self) -> LocalScanStats {
-        self.stats.read().await.clone()
-    }
-
-    /// get real-time counters
-    pub fn get_counters(&self) -> Arc<StatsCounters> {
-        self.counters.clone()
-    }
-
-    /// reset stats data
-    pub async fn reset_stats(&self) -> Result<()> {
-        {
-            let mut stats = self.stats.write().await;
-            *stats = LocalScanStats::default();
-        }
-
-        // reset counters
-        self.counters.total_objects_scanned.store(0, Ordering::Relaxed);
-        self.counters.total_healthy_objects.store(0, Ordering::Relaxed);
-        self.counters.total_corrupted_objects.store(0, Ordering::Relaxed);
-        self.counters.total_bytes_scanned.store(0, Ordering::Relaxed);
-        self.counters.total_scan_errors.store(0, Ordering::Relaxed);
-        self.counters.total_heal_triggered.store(0, Ordering::Relaxed);
-
-        info!("reset local stats data");
-        Ok(())
-    }
-
-    /// get stats summary
-    pub async fn get_stats_summary(&self) -> StatsSummary {
-        let stats = self.stats.read().await;
-
-        StatsSummary {
-            node_id: self.node_id.clone(),
-            total_objects_scanned: self.counters.total_objects_scanned.load(Ordering::Relaxed),
-            total_healthy_objects: self.counters.total_healthy_objects.load(Ordering::Relaxed),
-            total_corrupted_objects: self.counters.total_corrupted_objects.load(Ordering::Relaxed),
-            total_bytes_scanned: self.counters.total_bytes_scanned.load(Ordering::Relaxed),
-            total_scan_errors: self.counters.total_scan_errors.load(Ordering::Relaxed),
-            total_heal_triggered: self.counters.total_heal_triggered.load(Ordering::Relaxed),
-            total_disks: stats.disks_stats.len(),
-            total_buckets: stats.buckets_stats.len(),
-            last_update: stats.last_update,
-            scan_progress: stats.scan_progress.clone(),
-        }
-    }
-
-    /// record heal triggered
-    pub async fn record_heal_triggered(&self, object_path: &str, error_message: &str) {
-        self.counters.total_heal_triggered.fetch_add(1, Ordering::Relaxed);
-
-        info!("record heal triggered: object={}, error={}", object_path, error_message);
-    }
-
-    /// update data usage stats
-    pub async fn update_data_usage(&self, data_usage: DataUsageInfo) {
-        let mut stats = self.stats.write().await;
-        stats.data_usage = data_usage;
-        stats.last_update = SystemTime::now();
-
-        debug!("update data usage stats");
-    }
-
-    /// cleanup stats files
-    pub async fn cleanup_stats_files(&self) -> Result<()> {
-        // delete main file
-        if self.stats_file.exists() {
-            tokio::fs::remove_file(&self.stats_file)
-                .await
-                .map_err(|e| Error::IO(format!("delete stats file failed: {}", e)))?;
-        }
-
-        // delete backup file
-        if self.backup_file.exists() {
-            tokio::fs::remove_file(&self.backup_file)
-                .await
-                .map_err(|e| Error::IO(format!("delete backup stats file failed: {}", e)))?;
-        }
-
-        // delete temp file
-        if self.temp_file.exists() {
-            tokio::fs::remove_file(&self.temp_file)
-                .await
-                .map_err(|e| Error::IO(format!("delete temp stats file failed: {}", e)))?;
-        }
-
-        info!("cleanup all stats files");
-        Ok(())
-    }
-
-    /// set save interval
-    pub fn set_save_interval(&mut self, interval: Duration) {
-        self.save_interval = interval;
-        info!("set stats data save interval to {:?}", interval);
-    }
-}
-
-/// stats summary
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct StatsSummary {
-    /// node id
-    pub node_id: String,
-    /// total scanned objects
-    pub total_objects_scanned: u64,
-    /// total healthy objects
-    pub total_healthy_objects: u64,
-    /// total corrupted objects
-    pub total_corrupted_objects: u64,
-    /// total scanned bytes
-    pub total_bytes_scanned: u64,
-    /// total scan errors
-    pub total_scan_errors: u64,
-    /// total heal triggered
-    pub total_heal_triggered: u64,
-    /// total disks
-    pub total_disks: usize,
-    /// total buckets
-    pub total_buckets: usize,
-    /// last update time
-    pub last_update: SystemTime,
-    /// scan progress
-    pub scan_progress: super::node_scanner::ScanProgress,
-}

crates/ahm/src/scanner/metrics.rs

@@ -1,306 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::{
-    collections::HashMap,
-    sync::atomic::{AtomicU64, Ordering},
-    time::{Duration, SystemTime},
-};
-
-use serde::{Deserialize, Serialize};
-use tracing::info;
-
-/// Scanner metrics
-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
-pub struct ScannerMetrics {
-    /// Total objects scanned since server start
-    pub objects_scanned: u64,
-    /// Total object versions scanned since server start
-    pub versions_scanned: u64,
-    /// Total directories scanned since server start
-    pub directories_scanned: u64,
-    /// Total bucket scans started since server start
-    pub bucket_scans_started: u64,
-    /// Total bucket scans finished since server start
-    pub bucket_scans_finished: u64,
-    /// Total objects with health issues found
-    pub objects_with_issues: u64,
-    /// Total heal tasks queued
-    pub heal_tasks_queued: u64,
-    /// Total heal tasks completed
-    pub heal_tasks_completed: u64,
-    /// Total heal tasks failed
-    pub heal_tasks_failed: u64,
-    /// Total healthy objects found
-    pub healthy_objects: u64,
-    /// Total corrupted objects found
-    pub corrupted_objects: u64,
-    /// Last scan activity time
-    pub last_activity: Option<SystemTime>,
-    /// Current scan cycle
-    pub current_cycle: u64,
-    /// Total scan cycles completed
-    pub total_cycles: u64,
-    /// Current scan duration
-    pub current_scan_duration: Option<Duration>,
-    /// Average scan duration
-    pub avg_scan_duration: Duration,
-    /// Objects scanned per second
-    pub objects_per_second: f64,
-    /// Buckets scanned per second
-    pub buckets_per_second: f64,
-    /// Storage metrics by bucket
-    pub bucket_metrics: HashMap<String, BucketMetrics>,
-    /// Disk metrics
-    pub disk_metrics: HashMap<String, DiskMetrics>,
-}
-
-/// Bucket-specific metrics
-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
-pub struct BucketMetrics {
-    /// Bucket name
-    pub bucket: String,
-    /// Total objects in bucket
-    pub total_objects: u64,
-    /// Total size of objects in bucket (bytes)
-    pub total_size: u64,
-    /// Objects with health issues
-    pub objects_with_issues: u64,
-    /// Last scan time
-    pub last_scan_time: Option<SystemTime>,
-    /// Scan duration
-    pub scan_duration: Option<Duration>,
-    /// Heal tasks queued for this bucket
-    pub heal_tasks_queued: u64,
-    /// Heal tasks completed for this bucket
-    pub heal_tasks_completed: u64,
-    /// Heal tasks failed for this bucket
-    pub heal_tasks_failed: u64,
-}
-
-/// Disk-specific metrics
-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
-pub struct DiskMetrics {
-    /// Disk path
-    pub disk_path: String,
-    /// Total disk space (bytes)
-    pub total_space: u64,
-    /// Used disk space (bytes)
-    pub used_space: u64,
-    /// Free disk space (bytes)
-    pub free_space: u64,
-    /// Objects scanned on this disk
-    pub objects_scanned: u64,
-    /// Objects with issues on this disk
-    pub objects_with_issues: u64,
-    /// Last scan time
-    pub last_scan_time: Option<SystemTime>,
-    /// Whether disk is online
-    pub is_online: bool,
-    /// Whether disk is being scanned
-    pub is_scanning: bool,
-}
-
-/// Thread-safe metrics collector
-pub struct MetricsCollector {
-    /// Atomic counters for real-time metrics
-    objects_scanned: AtomicU64,
-    versions_scanned: AtomicU64,
-    directories_scanned: AtomicU64,
-    bucket_scans_started: AtomicU64,
-    bucket_scans_finished: AtomicU64,
-    objects_with_issues: AtomicU64,
-    heal_tasks_queued: AtomicU64,
-    heal_tasks_completed: AtomicU64,
-    heal_tasks_failed: AtomicU64,
-    current_cycle: AtomicU64,
-    total_cycles: AtomicU64,
-    healthy_objects: AtomicU64,
-    corrupted_objects: AtomicU64,
-}
-
-impl MetricsCollector {
-    /// Create a new metrics collector
-    pub fn new() -> Self {
-        Self {
-            objects_scanned: AtomicU64::new(0),
-            versions_scanned: AtomicU64::new(0),
-            directories_scanned: AtomicU64::new(0),
-            bucket_scans_started: AtomicU64::new(0),
-            bucket_scans_finished: AtomicU64::new(0),
-            objects_with_issues: AtomicU64::new(0),
-            heal_tasks_queued: AtomicU64::new(0),
-            heal_tasks_completed: AtomicU64::new(0),
-            heal_tasks_failed: AtomicU64::new(0),
-            current_cycle: AtomicU64::new(0),
-            total_cycles: AtomicU64::new(0),
-            healthy_objects: AtomicU64::new(0),
-            corrupted_objects: AtomicU64::new(0),
-        }
-    }
-
-    /// Increment objects scanned count
-    pub fn increment_objects_scanned(&self, count: u64) {
-        self.objects_scanned.fetch_add(count, Ordering::Relaxed);
-    }
-
-    /// Increment versions scanned count
-    pub fn increment_versions_scanned(&self, count: u64) {
-        self.versions_scanned.fetch_add(count, Ordering::Relaxed);
-    }
-
-    /// Increment directories scanned count
-    pub fn increment_directories_scanned(&self, count: u64) {
-        self.directories_scanned.fetch_add(count, Ordering::Relaxed);
-    }
-
-    /// Increment bucket scans started count
-    pub fn increment_bucket_scans_started(&self, count: u64) {
-        self.bucket_scans_started.fetch_add(count, Ordering::Relaxed);
-    }
-
-    /// Increment bucket scans finished count
-    pub fn increment_bucket_scans_finished(&self, count: u64) {
-        self.bucket_scans_finished.fetch_add(count, Ordering::Relaxed);
-    }
-
-    /// Increment objects with issues count
-    pub fn increment_objects_with_issues(&self, count: u64) {
-        self.objects_with_issues.fetch_add(count, Ordering::Relaxed);
-    }
-
-    /// Increment heal tasks queued count
-    pub fn increment_heal_tasks_queued(&self, count: u64) {
-        self.heal_tasks_queued.fetch_add(count, Ordering::Relaxed);
-    }
-
-    /// Increment heal tasks completed count
-    pub fn increment_heal_tasks_completed(&self, count: u64) {
-        self.heal_tasks_completed.fetch_add(count, Ordering::Relaxed);
-    }
-
-    /// Increment heal tasks failed count
-    pub fn increment_heal_tasks_failed(&self, count: u64) {
-        self.heal_tasks_failed.fetch_add(count, Ordering::Relaxed);
-    }
-
-    /// Set current cycle
-    pub fn set_current_cycle(&self, cycle: u64) {
-        self.current_cycle.store(cycle, Ordering::Relaxed);
-    }
-
-    /// Increment total cycles
-    pub fn increment_total_cycles(&self) {
-        self.total_cycles.fetch_add(1, Ordering::Relaxed);
-    }
-
-    /// Increment healthy objects count
-    pub fn increment_healthy_objects(&self) {
-        self.healthy_objects.fetch_add(1, Ordering::Relaxed);
-    }
-
-    /// Increment corrupted objects count
-    pub fn increment_corrupted_objects(&self) {
-        self.corrupted_objects.fetch_add(1, Ordering::Relaxed);
-    }
-
-    /// Get current metrics snapshot
-    pub fn get_metrics(&self) -> ScannerMetrics {
-        ScannerMetrics {
-            objects_scanned: self.objects_scanned.load(Ordering::Relaxed),
-            versions_scanned: self.versions_scanned.load(Ordering::Relaxed),
-            directories_scanned: self.directories_scanned.load(Ordering::Relaxed),
-            bucket_scans_started: self.bucket_scans_started.load(Ordering::Relaxed),
-            bucket_scans_finished: self.bucket_scans_finished.load(Ordering::Relaxed),
-            objects_with_issues: self.objects_with_issues.load(Ordering::Relaxed),
-            heal_tasks_queued: self.heal_tasks_queued.load(Ordering::Relaxed),
-            heal_tasks_completed: self.heal_tasks_completed.load(Ordering::Relaxed),
-            heal_tasks_failed: self.heal_tasks_failed.load(Ordering::Relaxed),
-            healthy_objects: self.healthy_objects.load(Ordering::Relaxed),
-            corrupted_objects: self.corrupted_objects.load(Ordering::Relaxed),
-            last_activity: Some(SystemTime::now()),
-            current_cycle: self.current_cycle.load(Ordering::Relaxed),
-            total_cycles: self.total_cycles.load(Ordering::Relaxed),
-            current_scan_duration: None,       // Will be set by scanner
-            avg_scan_duration: Duration::ZERO, // Will be calculated
-            objects_per_second: 0.0,           // Will be calculated
-            buckets_per_second: 0.0,           // Will be calculated
-            bucket_metrics: HashMap::new(),    // Will be populated by scanner
-            disk_metrics: HashMap::new(),      // Will be populated by scanner
-        }
-    }
-
-    /// Reset all metrics
-    pub fn reset(&self) {
-        self.objects_scanned.store(0, Ordering::Relaxed);
-        self.versions_scanned.store(0, Ordering::Relaxed);
-        self.directories_scanned.store(0, Ordering::Relaxed);
-        self.bucket_scans_started.store(0, Ordering::Relaxed);
-        self.bucket_scans_finished.store(0, Ordering::Relaxed);
-        self.objects_with_issues.store(0, Ordering::Relaxed);
-        self.heal_tasks_queued.store(0, Ordering::Relaxed);
-        self.heal_tasks_completed.store(0, Ordering::Relaxed);
-        self.heal_tasks_failed.store(0, Ordering::Relaxed);
-        self.current_cycle.store(0, Ordering::Relaxed);
-        self.total_cycles.store(0, Ordering::Relaxed);
-        self.healthy_objects.store(0, Ordering::Relaxed);
-        self.corrupted_objects.store(0, Ordering::Relaxed);
-
-        info!("Scanner metrics reset");
-    }
-}
-
-impl Default for MetricsCollector {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_metrics_collector_creation() {
-        let collector = MetricsCollector::new();
-        let metrics = collector.get_metrics();
-        assert_eq!(metrics.objects_scanned, 0);
-        assert_eq!(metrics.versions_scanned, 0);
-    }
-
-    #[test]
-    fn test_metrics_increment() {
-        let collector = MetricsCollector::new();
-
-        collector.increment_objects_scanned(10);
-        collector.increment_versions_scanned(5);
-        collector.increment_objects_with_issues(2);
-
-        let metrics = collector.get_metrics();
-        assert_eq!(metrics.objects_scanned, 10);
-        assert_eq!(metrics.versions_scanned, 5);
-        assert_eq!(metrics.objects_with_issues, 2);
-    }
-
-    #[test]
-    fn test_metrics_reset() {
-        let collector = MetricsCollector::new();
-
-        collector.increment_objects_scanned(10);
-        collector.reset();
-
-        let metrics = collector.get_metrics();
-        assert_eq!(metrics.objects_scanned, 0);
-    }
-}

crates/ahm/src/scanner/mod.rs

@@ -1,33 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-pub mod checkpoint;
-pub mod data_scanner;
-pub mod histogram;
-pub mod io_monitor;
-pub mod io_throttler;
-pub mod lifecycle;
-pub mod local_stats;
-pub mod metrics;
-pub mod node_scanner;
-pub mod stats_aggregator;
-
-pub use checkpoint::{CheckpointData, CheckpointInfo, CheckpointManager};
-pub use data_scanner::{ScanMode, Scanner, ScannerConfig, ScannerState};
-pub use io_monitor::{AdvancedIOMonitor, IOMetrics, IOMonitorConfig};
-pub use io_throttler::{AdvancedIOThrottler, IOThrottlerConfig, ResourceAllocation, ThrottleDecision};
-pub use local_stats::{BatchScanResult, LocalStatsManager, ScanResultEntry, StatsSummary};
-pub use metrics::ScannerMetrics;
-pub use node_scanner::{IOMonitor, IOThrottler, LoadLevel, LocalScanStats, NodeScanner, NodeScannerConfig};
-pub use stats_aggregator::{AggregatedStats, DecentralizedStatsAggregator, NodeClient, NodeInfo};

crates/ahm/src/scanner/stats_aggregator.rs

@@ -1,572 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::{
-    collections::HashMap,
-    sync::Arc,
-    time::{Duration, SystemTime},
-};
-
-use serde::{Deserialize, Serialize};
-use tokio::sync::RwLock;
-use tracing::{debug, info, warn};
-
-use rustfs_common::data_usage::DataUsageInfo;
-
-use super::{
-    local_stats::StatsSummary,
-    node_scanner::{BucketStats, LoadLevel, ScanProgress},
-};
-use crate::{Error, error::Result};
-
-/// node client config
-#[derive(Debug, Clone)]
-pub struct NodeClientConfig {
-    /// connect timeout
-    pub connect_timeout: Duration,
-    /// request timeout
-    pub request_timeout: Duration,
-    /// retry times
-    pub max_retries: u32,
-    /// retry interval
-    pub retry_interval: Duration,
-}
-
-impl Default for NodeClientConfig {
-    fn default() -> Self {
-        Self {
-            connect_timeout: Duration::from_secs(5),
-            request_timeout: Duration::from_secs(10),
-            max_retries: 3,
-            retry_interval: Duration::from_secs(1),
-        }
-    }
-}
-
-/// node info
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct NodeInfo {
-    /// node id
-    pub node_id: String,
-    /// node address
-    pub address: String,
-    /// node port
-    pub port: u16,
-    /// is online
-    pub is_online: bool,
-    /// last heartbeat time
-    pub last_heartbeat: SystemTime,
-    /// node version
-    pub version: String,
-}
-
-/// aggregated stats
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AggregatedStats {
-    /// aggregation timestamp
-    pub aggregation_timestamp: SystemTime,
-    /// number of nodes participating in aggregation
-    pub node_count: usize,
-    /// number of online nodes
-    pub online_node_count: usize,
-    /// total scanned objects
-    pub total_objects_scanned: u64,
-    /// total healthy objects
-    pub total_healthy_objects: u64,
-    /// total corrupted objects
-    pub total_corrupted_objects: u64,
-    /// total scanned bytes
-    pub total_bytes_scanned: u64,
-    /// total scan errors
-    pub total_scan_errors: u64,
-    /// total heal triggered
-    pub total_heal_triggered: u64,
-    /// total disks
-    pub total_disks: usize,
-    /// total buckets
-    pub total_buckets: usize,
-    /// aggregated data usage
-    pub aggregated_data_usage: DataUsageInfo,
-    /// node summaries
-    pub node_summaries: HashMap<String, StatsSummary>,
-    /// aggregated bucket stats
-    pub aggregated_bucket_stats: HashMap<String, BucketStats>,
-    /// aggregated scan progress
-    pub scan_progress_summary: ScanProgressSummary,
-    /// load level distribution
-    pub load_level_distribution: HashMap<LoadLevel, usize>,
-}
-
-impl Default for AggregatedStats {
-    fn default() -> Self {
-        Self {
-            aggregation_timestamp: SystemTime::now(),
-            node_count: 0,
-            online_node_count: 0,
-            total_objects_scanned: 0,
-            total_healthy_objects: 0,
-            total_corrupted_objects: 0,
-            total_bytes_scanned: 0,
-            total_scan_errors: 0,
-            total_heal_triggered: 0,
-            total_disks: 0,
-            total_buckets: 0,
-            aggregated_data_usage: DataUsageInfo::default(),
-            node_summaries: HashMap::new(),
-            aggregated_bucket_stats: HashMap::new(),
-            scan_progress_summary: ScanProgressSummary::default(),
-            load_level_distribution: HashMap::new(),
-        }
-    }
-}
-
-/// scan progress summary
-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
-pub struct ScanProgressSummary {
-    /// average current cycle
-    pub average_current_cycle: f64,
-    /// total completed disks
-    pub total_completed_disks: usize,
-    /// total completed buckets
-    pub total_completed_buckets: usize,
-    /// latest scan start time
-    pub earliest_scan_start: Option<SystemTime>,
-    /// estimated completion time
-    pub estimated_completion: Option<SystemTime>,
-    /// node progress
-    pub node_progress: HashMap<String, ScanProgress>,
-}
-
-/// node client
-///
-/// responsible for communicating with other nodes, getting stats data
-pub struct NodeClient {
-    /// node info
-    node_info: NodeInfo,
-    /// config
-    config: NodeClientConfig,
-    /// HTTP client
-    http_client: reqwest::Client,
-}
-
-impl NodeClient {
-    /// create new node client
-    pub fn new(node_info: NodeInfo, config: NodeClientConfig) -> Self {
-        let http_client = reqwest::Client::builder()
-            .timeout(config.request_timeout)
-            .connect_timeout(config.connect_timeout)
-            .build()
-            .expect("Failed to create HTTP client");
-
-        Self {
-            node_info,
-            config,
-            http_client,
-        }
-    }
-
-    /// get node stats summary
-    pub async fn get_stats_summary(&self) -> Result<StatsSummary> {
-        let url = format!("http://{}:{}/internal/scanner/stats", self.node_info.address, self.node_info.port);
-
-        for attempt in 1..=self.config.max_retries {
-            match self.try_get_stats_summary(&url).await {
-                Ok(summary) => return Ok(summary),
-                Err(e) => {
-                    warn!("try to get node {} stats failed: {}", self.node_info.node_id, e);
-
-                    if attempt < self.config.max_retries {
-                        tokio::time::sleep(self.config.retry_interval).await;
-                    }
-                }
-            }
-        }
-
-        Err(Error::Other(format!("cannot get stats data from node {}", self.node_info.node_id)))
-    }
-
-    /// try to get stats summary
-    async fn try_get_stats_summary(&self, url: &str) -> Result<StatsSummary> {
-        let response = self
-            .http_client
-            .get(url)
-            .send()
-            .await
-            .map_err(|e| Error::Other(format!("HTTP request failed: {}", e)))?;
-
-        if !response.status().is_success() {
-            return Err(Error::Other(format!("HTTP status error: {}", response.status())));
-        }
-
-        let summary = response
-            .json::<StatsSummary>()
-            .await
-            .map_err(|e| Error::Serialization(format!("deserialize stats data failed: {}", e)))?;
-
-        Ok(summary)
-    }
-
-    /// check node health status
-    pub async fn check_health(&self) -> bool {
-        let url = format!("http://{}:{}/internal/health", self.node_info.address, self.node_info.port);
-
-        match self.http_client.get(&url).send().await {
-            Ok(response) => response.status().is_success(),
-            Err(_) => false,
-        }
-    }
-
-    /// get node info
-    pub fn get_node_info(&self) -> &NodeInfo {
-        &self.node_info
-    }
-
-    /// update node online status
-    pub fn update_online_status(&mut self, is_online: bool) {
-        self.node_info.is_online = is_online;
-        if is_online {
-            self.node_info.last_heartbeat = SystemTime::now();
-        }
-    }
-}
-
-/// decentralized stats aggregator config
-#[derive(Debug, Clone)]
-pub struct DecentralizedStatsAggregatorConfig {
-    /// aggregation interval
-    pub aggregation_interval: Duration,
-    /// cache ttl
-    pub cache_ttl: Duration,
-    /// node timeout
-    pub node_timeout: Duration,
-    /// max concurrent aggregations
-    pub max_concurrent_aggregations: usize,
-}
-
-impl Default for DecentralizedStatsAggregatorConfig {
-    fn default() -> Self {
-        Self {
-            aggregation_interval: Duration::from_secs(30), // 30 seconds to aggregate
-            cache_ttl: Duration::from_secs(3),             // 3 seconds to cache
-            node_timeout: Duration::from_secs(5),          // 5 seconds to node timeout
-            max_concurrent_aggregations: 10,               // max 10 nodes to aggregate concurrently
-        }
-    }
-}
-
-/// decentralized stats aggregator
-///
-/// real-time aggregate stats data from all nodes, provide global view
-pub struct DecentralizedStatsAggregator {
-    /// config
-    config: Arc<RwLock<DecentralizedStatsAggregatorConfig>>,
-    /// node clients
-    node_clients: Arc<RwLock<HashMap<String, Arc<NodeClient>>>>,
-    /// cached aggregated stats
-    cached_stats: Arc<RwLock<Option<AggregatedStats>>>,
-    /// cache timestamp
-    cache_timestamp: Arc<RwLock<SystemTime>>,
-    /// local node stats summary
-    local_stats_summary: Arc<RwLock<Option<StatsSummary>>>,
-}
-
-impl DecentralizedStatsAggregator {
-    /// create new decentralized stats aggregator
-    pub fn new(config: DecentralizedStatsAggregatorConfig) -> Self {
-        Self {
-            config: Arc::new(RwLock::new(config)),
-            node_clients: Arc::new(RwLock::new(HashMap::new())),
-            cached_stats: Arc::new(RwLock::new(None)),
-            cache_timestamp: Arc::new(RwLock::new(SystemTime::UNIX_EPOCH)),
-            local_stats_summary: Arc::new(RwLock::new(None)),
-        }
-    }
-
-    /// add node client
-    pub async fn add_node(&self, node_info: NodeInfo) {
-        let client_config = NodeClientConfig::default();
-        let client = Arc::new(NodeClient::new(node_info.clone(), client_config));
-
-        self.node_clients.write().await.insert(node_info.node_id.clone(), client);
-
-        info!("add node to aggregator: {}", node_info.node_id);
-    }
-
-    /// remove node client
-    pub async fn remove_node(&self, node_id: &str) {
-        self.node_clients.write().await.remove(node_id);
-        info!("remove node from aggregator: {}", node_id);
-    }
-
-    /// set local node stats summary
-    pub async fn set_local_stats(&self, stats: StatsSummary) {
-        *self.local_stats_summary.write().await = Some(stats);
-    }
-
-    /// get aggregated stats data (with cache)
-    pub async fn get_aggregated_stats(&self) -> Result<AggregatedStats> {
-        let config = self.config.read().await;
-        let cache_ttl = config.cache_ttl;
-        drop(config);
-
-        // check cache validity
-        let cache_timestamp = *self.cache_timestamp.read().await;
-        let now = SystemTime::now();
-
-        debug!(
-            "cache check: cache_timestamp={:?}, now={:?}, cache_ttl={:?}",
-            cache_timestamp, now, cache_ttl
-        );
-
-        // Check cache validity if timestamp is not initial value (UNIX_EPOCH)
-        if cache_timestamp != SystemTime::UNIX_EPOCH {
-            if let Ok(elapsed) = now.duration_since(cache_timestamp) {
-                if elapsed < cache_ttl {
-                    if let Some(cached) = self.cached_stats.read().await.as_ref() {
-                        debug!("Returning cached aggregated stats, remaining TTL: {:?}", cache_ttl - elapsed);
-                        return Ok(cached.clone());
-                    }
-                } else {
-                    debug!("Cache expired: elapsed={:?} >= ttl={:?}", elapsed, cache_ttl);
-                }
-            }
-        }
-
-        // cache expired, re-aggregate
-        info!("cache expired, start re-aggregating stats data");
-        let aggregation_timestamp = now;
-        let aggregated = self.aggregate_stats_from_all_nodes(aggregation_timestamp).await?;
-
-        // update cache
-        *self.cached_stats.write().await = Some(aggregated.clone());
-        *self.cache_timestamp.write().await = aggregation_timestamp;
-
-        Ok(aggregated)
-    }
-
-    /// force refresh aggregated stats (ignore cache)
-    pub async fn force_refresh_aggregated_stats(&self) -> Result<AggregatedStats> {
-        let now = SystemTime::now();
-        let aggregated = self.aggregate_stats_from_all_nodes(now).await?;
-
-        // update cache
-        *self.cached_stats.write().await = Some(aggregated.clone());
-        *self.cache_timestamp.write().await = now;
-
-        Ok(aggregated)
-    }
-
-    /// aggregate stats data from all nodes
-    async fn aggregate_stats_from_all_nodes(&self, aggregation_timestamp: SystemTime) -> Result<AggregatedStats> {
-        let node_clients = self.node_clients.read().await;
-        let config = self.config.read().await;
-
-        // concurrent get stats data from all nodes
-        let mut tasks = Vec::new();
-        let semaphore = Arc::new(tokio::sync::Semaphore::new(config.max_concurrent_aggregations));
-
-        // add local node stats
-        let mut node_summaries = HashMap::new();
-        if let Some(local_stats) = self.local_stats_summary.read().await.as_ref() {
-            node_summaries.insert(local_stats.node_id.clone(), local_stats.clone());
-        }
-
-        // get remote node stats
-        for (node_id, client) in node_clients.iter() {
-            let client = client.clone();
-            let semaphore = semaphore.clone();
-            let node_id = node_id.clone();
-
-            let task = tokio::spawn(async move {
-                let _permit = match semaphore.acquire().await {
-                    Ok(permit) => permit,
-                    Err(e) => {
-                        warn!("Failed to acquire semaphore for node {}: {}", node_id, e);
-                        return None;
-                    }
-                };
-
-                match client.get_stats_summary().await {
-                    Ok(summary) => {
-                        debug!("successfully get node {} stats data", node_id);
-                        Some((node_id, summary))
-                    }
-                    Err(e) => {
-                        warn!("get node {} stats data failed: {}", node_id, e);
-                        None
-                    }
-                }
-            });
-
-            tasks.push(task);
-        }
-
-        // wait for all tasks to complete
-        for task in tasks {
-            if let Ok(Some((node_id, summary))) = task.await {
-                node_summaries.insert(node_id, summary);
-            }
-        }
-
-        drop(node_clients);
-        drop(config);
-
-        // aggregate stats data
-        let aggregated = self.aggregate_node_summaries(node_summaries, aggregation_timestamp).await;
-
-        info!(
-            "aggregate stats completed: {} nodes, {} online",
-            aggregated.node_count, aggregated.online_node_count
-        );
-
-        Ok(aggregated)
-    }
-
-    /// aggregate node summaries
-    async fn aggregate_node_summaries(
-        &self,
-        node_summaries: HashMap<String, StatsSummary>,
-        aggregation_timestamp: SystemTime,
-    ) -> AggregatedStats {
-        let mut aggregated = AggregatedStats {
-            aggregation_timestamp,
-            node_count: node_summaries.len(),
-            online_node_count: node_summaries.len(), // assume all nodes with data are online
-            node_summaries: node_summaries.clone(),
-            ..Default::default()
-        };
-
-        // aggregate numeric stats
-        for (node_id, summary) in &node_summaries {
-            aggregated.total_objects_scanned += summary.total_objects_scanned;
-            aggregated.total_healthy_objects += summary.total_healthy_objects;
-            aggregated.total_corrupted_objects += summary.total_corrupted_objects;
-            aggregated.total_bytes_scanned += summary.total_bytes_scanned;
-            aggregated.total_scan_errors += summary.total_scan_errors;
-            aggregated.total_heal_triggered += summary.total_heal_triggered;
-            aggregated.total_disks += summary.total_disks;
-            aggregated.total_buckets += summary.total_buckets;
-
-            // aggregate scan progress
-            aggregated
-                .scan_progress_summary
-                .node_progress
-                .insert(node_id.clone(), summary.scan_progress.clone());
-
-            aggregated.scan_progress_summary.total_completed_disks += summary.scan_progress.completed_disks.len();
-            aggregated.scan_progress_summary.total_completed_buckets += summary.scan_progress.completed_buckets.len();
-        }
-
-        // calculate average scan cycle
-        if !node_summaries.is_empty() {
-            let total_cycles: u64 = node_summaries.values().map(|s| s.scan_progress.current_cycle).sum();
-            aggregated.scan_progress_summary.average_current_cycle = total_cycles as f64 / node_summaries.len() as f64;
-        }
-
-        // find earliest scan start time
-        aggregated.scan_progress_summary.earliest_scan_start =
-            node_summaries.values().map(|s| s.scan_progress.scan_start_time).min();
-
-        // TODO: aggregate bucket stats and data usage
-        // here we need to implement it based on the specific BucketStats and DataUsageInfo structure
-
-        aggregated
-    }
-
-    /// get nodes health status
-    pub async fn get_nodes_health(&self) -> HashMap<String, bool> {
-        let node_clients = self.node_clients.read().await;
-        let mut health_status = HashMap::new();
-
-        // concurrent check all nodes health status
-        let mut tasks = Vec::new();
-
-        for (node_id, client) in node_clients.iter() {
-            let client = client.clone();
-            let node_id = node_id.clone();
-
-            let task = tokio::spawn(async move {
-                let is_healthy = client.check_health().await;
-                (node_id, is_healthy)
-            });
-
-            tasks.push(task);
-        }
-
-        // collect results
-        for task in tasks {
-            if let Ok((node_id, is_healthy)) = task.await {
-                health_status.insert(node_id, is_healthy);
-            }
-        }
-
-        health_status
-    }
-
-    /// get online nodes list
-    pub async fn get_online_nodes(&self) -> Vec<String> {
-        let health_status = self.get_nodes_health().await;
-
-        health_status
-            .into_iter()
-            .filter_map(|(node_id, is_healthy)| if is_healthy { Some(node_id) } else { None })
-            .collect()
-    }
-
-    /// clear cache
-    pub async fn clear_cache(&self) {
-        *self.cached_stats.write().await = None;
-        *self.cache_timestamp.write().await = SystemTime::UNIX_EPOCH;
-        info!("clear aggregated stats cache");
-    }
-
-    /// get cache status
-    pub async fn get_cache_status(&self) -> CacheStatus {
-        let cached_stats = self.cached_stats.read().await;
-        let cache_timestamp = *self.cache_timestamp.read().await;
-        let config = self.config.read().await;
-
-        let is_valid = if let Ok(elapsed) = SystemTime::now().duration_since(cache_timestamp) {
-            elapsed < config.cache_ttl
-        } else {
-            false
-        };
-
-        CacheStatus {
-            has_cached_data: cached_stats.is_some(),
-            cache_timestamp,
-            is_valid,
-            ttl: config.cache_ttl,
-        }
-    }
-
-    /// update config
-    pub async fn update_config(&self, new_config: DecentralizedStatsAggregatorConfig) {
-        *self.config.write().await = new_config;
-        info!("update aggregator config");
-    }
-}
-
-/// cache status
-#[derive(Debug, Clone)]
-pub struct CacheStatus {
-    /// has cached data
-    pub has_cached_data: bool,
-    /// cache timestamp
-    pub cache_timestamp: SystemTime,
-    /// cache is valid
-    pub is_valid: bool,
-    /// cache ttl
-    pub ttl: Duration,
-}

crates/ahm/tests/endpoint_index_test.rs

@@ -1,81 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//! test endpoint index settings
-
-use rustfs_ecstore::disk::endpoint::Endpoint;
-use rustfs_ecstore::endpoints::{EndpointServerPools, Endpoints, PoolEndpoints};
-use std::net::SocketAddr;
-use tempfile::TempDir;
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-async fn test_endpoint_index_settings() -> anyhow::Result<()> {
-    let temp_dir = TempDir::new()?;
-
-    // create test disk paths
-    let disk_paths: Vec<_> = (0..4).map(|i| temp_dir.path().join(format!("disk{}", i))).collect();
-
-    for path in &disk_paths {
-        tokio::fs::create_dir_all(path).await?;
-    }
-
-    // build endpoints
-    let mut endpoints: Vec<Endpoint> = disk_paths
-        .iter()
-        .map(|p| Endpoint::try_from(p.to_string_lossy().as_ref()).unwrap())
-        .collect();
-
-    // set endpoint indexes correctly
-    for (i, endpoint) in endpoints.iter_mut().enumerate() {
-        endpoint.set_pool_index(0);
-        endpoint.set_set_index(0);
-        endpoint.set_disk_index(i); // note: disk_index is usize type
-        println!(
-            "Endpoint {}: pool_idx={}, set_idx={}, disk_idx={}",
-            i, endpoint.pool_idx, endpoint.set_idx, endpoint.disk_idx
-        );
-    }
-
-    let pool_endpoints = PoolEndpoints {
-        legacy: false,
-        set_count: 1,
-        drives_per_set: endpoints.len(),
-        endpoints: Endpoints::from(endpoints.clone()),
-        cmd_line: "test".to_string(),
-        platform: format!("OS: {} | Arch: {}", std::env::consts::OS, std::env::consts::ARCH),
-    };
-
-    let endpoint_pools = EndpointServerPools(vec![pool_endpoints]);
-
-    // validate all endpoint indexes are in valid range
-    for (i, ep) in endpoints.iter().enumerate() {
-        assert_eq!(ep.pool_idx, 0, "Endpoint {} pool_idx should be 0", i);
-        assert_eq!(ep.set_idx, 0, "Endpoint {} set_idx should be 0", i);
-        assert_eq!(ep.disk_idx, i as i32, "Endpoint {} disk_idx should be {}", i, i);
-        println!(
-            "Endpoint {} indices are valid: pool={}, set={}, disk={}",
-            i, ep.pool_idx, ep.set_idx, ep.disk_idx
-        );
-    }
-
-    // test ECStore initialization
-    rustfs_ecstore::store::init_local_disks(endpoint_pools.clone()).await?;
-
-    let server_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
-    let ecstore = rustfs_ecstore::store::ECStore::new(server_addr, endpoint_pools).await?;
-
-    println!("ECStore initialized successfully with {} pools", ecstore.pools.len());
-
-    Ok(())
-}

crates/ahm/tests/heal_integration_test.rs

@@ -1,424 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use rustfs_ahm::heal::{
-    manager::{HealConfig, HealManager},
-    storage::{ECStoreHealStorage, HealStorageAPI},
-    task::{HealOptions, HealPriority, HealRequest, HealTaskStatus, HealType},
-};
-use rustfs_common::heal_channel::{HealOpts, HealScanMode};
-use rustfs_ecstore::{
-    disk::endpoint::Endpoint,
-    endpoints::{EndpointServerPools, Endpoints, PoolEndpoints},
-    store::ECStore,
-    store_api::{ObjectIO, ObjectOptions, PutObjReader, StorageAPI},
-};
-use serial_test::serial;
-use std::sync::Once;
-use std::sync::OnceLock;
-use std::{path::PathBuf, sync::Arc, time::Duration};
-use tokio::fs;
-use tracing::info;
-use walkdir::WalkDir;
-
-static GLOBAL_ENV: OnceLock<(Vec<PathBuf>, Arc<ECStore>, Arc<ECStoreHealStorage>)> = OnceLock::new();
-static INIT: Once = Once::new();
-
-fn init_tracing() {
-    INIT.call_once(|| {
-        let _ = tracing_subscriber::fmt::try_init();
-    });
-}
-
-/// Test helper: Create test environment with ECStore
-async fn setup_test_env() -> (Vec<PathBuf>, Arc<ECStore>, Arc<ECStoreHealStorage>) {
-    init_tracing();
-
-    // Fast path: already initialized, just clone and return
-    if let Some((paths, ecstore, heal_storage)) = GLOBAL_ENV.get() {
-        return (paths.clone(), ecstore.clone(), heal_storage.clone());
-    }
-
-    // create temp dir as 4 disks with unique base dir
-    let test_base_dir = format!("/tmp/rustfs_ahm_heal_test_{}", uuid::Uuid::new_v4());
-    let temp_dir = std::path::PathBuf::from(&test_base_dir);
-    if temp_dir.exists() {
-        fs::remove_dir_all(&temp_dir).await.ok();
-    }
-    fs::create_dir_all(&temp_dir).await.unwrap();
-
-    // create 4 disk dirs
-    let disk_paths = vec![
-        temp_dir.join("disk1"),
-        temp_dir.join("disk2"),
-        temp_dir.join("disk3"),
-        temp_dir.join("disk4"),
-    ];
-
-    for disk_path in &disk_paths {
-        fs::create_dir_all(disk_path).await.unwrap();
-    }
-
-    // create EndpointServerPools
-    let mut endpoints = Vec::new();
-    for (i, disk_path) in disk_paths.iter().enumerate() {
-        let mut endpoint = Endpoint::try_from(disk_path.to_str().unwrap()).unwrap();
-        // set correct index
-        endpoint.set_pool_index(0);
-        endpoint.set_set_index(0);
-        endpoint.set_disk_index(i);
-        endpoints.push(endpoint);
-    }
-
-    let pool_endpoints = PoolEndpoints {
-        legacy: false,
-        set_count: 1,
-        drives_per_set: 4,
-        endpoints: Endpoints::from(endpoints),
-        cmd_line: "test".to_string(),
-        platform: format!("OS: {} | Arch: {}", std::env::consts::OS, std::env::consts::ARCH),
-    };
-
-    let endpoint_pools = EndpointServerPools(vec![pool_endpoints]);
-
-    // format disks (only first time)
-    rustfs_ecstore::store::init_local_disks(endpoint_pools.clone()).await.unwrap();
-
-    // create ECStore with dynamic port 0 (let OS assign) or fixed 9001 if free
-    let port = 9001; // for simplicity
-    let server_addr: std::net::SocketAddr = format!("127.0.0.1:{port}").parse().unwrap();
-    let ecstore = ECStore::new(server_addr, endpoint_pools).await.unwrap();
-
-    // init bucket metadata system
-    let buckets_list = ecstore
-        .list_bucket(&rustfs_ecstore::store_api::BucketOptions {
-            no_metadata: true,
-            ..Default::default()
-        })
-        .await
-        .unwrap();
-    let buckets = buckets_list.into_iter().map(|v| v.name).collect();
-    rustfs_ecstore::bucket::metadata_sys::init_bucket_metadata_sys(ecstore.clone(), buckets).await;
-
-    // Create heal storage layer
-    let heal_storage = Arc::new(ECStoreHealStorage::new(ecstore.clone()));
-
-    // Store in global once lock
-    let _ = GLOBAL_ENV.set((disk_paths.clone(), ecstore.clone(), heal_storage.clone()));
-
-    (disk_paths, ecstore, heal_storage)
-}
-
-/// Test helper: Create a test bucket
-async fn create_test_bucket(ecstore: &Arc<ECStore>, bucket_name: &str) {
-    (**ecstore)
-        .make_bucket(bucket_name, &Default::default())
-        .await
-        .expect("Failed to create test bucket");
-    info!("Created test bucket: {}", bucket_name);
-}
-
-/// Test helper: Upload test object
-async fn upload_test_object(ecstore: &Arc<ECStore>, bucket: &str, object: &str, data: &[u8]) {
-    let mut reader = PutObjReader::from_vec(data.to_vec());
-    let object_info = (**ecstore)
-        .put_object(bucket, object, &mut reader, &ObjectOptions::default())
-        .await
-        .expect("Failed to upload test object");
-
-    info!("Uploaded test object: {}/{} ({} bytes)", bucket, object, object_info.size);
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[serial]
-async fn test_heal_object_basic() {
-    let (disk_paths, ecstore, heal_storage) = setup_test_env().await;
-
-    // Create test bucket and object
-    let bucket_name = "test-bucket";
-    let object_name = "test-object.txt";
-    let test_data = b"Hello, this is test data for healing!";
-
-    create_test_bucket(&ecstore, bucket_name).await;
-    upload_test_object(&ecstore, bucket_name, object_name, test_data).await;
-
-    // ─── 1️⃣ delete single data shard file ─────────────────────────────────────
-    let obj_dir = disk_paths[0].join(bucket_name).join(object_name);
-    // find part file at depth 2, e.g. .../<uuid>/part.1
-    let target_part = WalkDir::new(&obj_dir)
-        .min_depth(2)
-        .max_depth(2)
-        .into_iter()
-        .filter_map(Result::ok)
-        .find(|e| e.file_type().is_file() && e.file_name().to_str().map(|n| n.starts_with("part.")).unwrap_or(false))
-        .map(|e| e.into_path())
-        .expect("Failed to locate part file to delete");
-
-    std::fs::remove_file(&target_part).expect("failed to delete part file");
-    assert!(!target_part.exists());
-    println!("✅ Deleted shard part file: {target_part:?}");
-
-    // Create heal manager with faster interval
-    let cfg = HealConfig {
-        heal_interval: Duration::from_millis(1),
-        ..Default::default()
-    };
-    let heal_manager = HealManager::new(heal_storage.clone(), Some(cfg));
-    heal_manager.start().await.unwrap();
-
-    // Submit heal request for the object
-    let heal_request = HealRequest::new(
-        HealType::Object {
-            bucket: bucket_name.to_string(),
-            object: object_name.to_string(),
-            version_id: None,
-        },
-        HealOptions {
-            dry_run: false,
-            recursive: false,
-            remove_corrupted: false,
-            recreate_missing: true,
-            scan_mode: HealScanMode::Normal,
-            update_parity: true,
-            timeout: Some(Duration::from_secs(300)),
-            pool_index: None,
-            set_index: None,
-        },
-        HealPriority::Normal,
-    );
-
-    let task_id = heal_manager
-        .submit_heal_request(heal_request)
-        .await
-        .expect("Failed to submit heal request");
-
-    info!("Submitted heal request with task ID: {}", task_id);
-
-    // Wait for task completion
-    tokio::time::sleep(tokio::time::Duration::from_secs(8)).await;
-
-    // Attempt to fetch task status (might be removed if finished)
-    match heal_manager.get_task_status(&task_id).await {
-        Ok(status) => info!("Task status: {:?}", status),
-        Err(e) => info!("Task status not found (likely completed): {}", e),
-    }
-
-    // ─── 2️⃣ verify each part file is restored ───────
-    assert!(target_part.exists());
-
-    info!("Heal object basic test passed");
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[serial]
-async fn test_heal_bucket_basic() {
-    let (disk_paths, ecstore, heal_storage) = setup_test_env().await;
-
-    // Create test bucket
-    let bucket_name = "test-bucket-heal";
-    create_test_bucket(&ecstore, bucket_name).await;
-
-    // ─── 1️⃣ delete bucket dir on disk ──────────────
-    let broken_bucket_path = disk_paths[0].join(bucket_name);
-    assert!(broken_bucket_path.exists(), "bucket dir does not exist on disk");
-    std::fs::remove_dir_all(&broken_bucket_path).expect("failed to delete bucket dir on disk");
-    assert!(!broken_bucket_path.exists(), "bucket dir still exists after deletion");
-    println!("✅ Deleted bucket directory on disk: {broken_bucket_path:?}");
-
-    // Create heal manager with faster interval
-    let cfg = HealConfig {
-        heal_interval: Duration::from_millis(1),
-        ..Default::default()
-    };
-    let heal_manager = HealManager::new(heal_storage.clone(), Some(cfg));
-    heal_manager.start().await.unwrap();
-
-    // Submit heal request for the bucket
-    let heal_request = HealRequest::new(
-        HealType::Bucket {
-            bucket: bucket_name.to_string(),
-        },
-        HealOptions {
-            dry_run: false,
-            recursive: true,
-            remove_corrupted: false,
-            recreate_missing: false,
-            scan_mode: HealScanMode::Normal,
-            update_parity: false,
-            timeout: Some(Duration::from_secs(300)),
-            pool_index: None,
-            set_index: None,
-        },
-        HealPriority::Normal,
-    );
-
-    let task_id = heal_manager
-        .submit_heal_request(heal_request)
-        .await
-        .expect("Failed to submit bucket heal request");
-
-    info!("Submitted bucket heal request with task ID: {}", task_id);
-
-    // Wait for task completion
-    tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
-
-    // Attempt to fetch task status (optional)
-    if let Ok(status) = heal_manager.get_task_status(&task_id).await {
-        if status == HealTaskStatus::Completed {
-            info!("Bucket heal task status: {:?}", status);
-        } else {
-            panic!("Bucket heal task status: {status:?}");
-        }
-    }
-
-    // ─── 3️⃣ Verify bucket directory is restored on every disk ───────
-    assert!(broken_bucket_path.exists(), "bucket dir does not exist on disk");
-
-    info!("Heal bucket basic test passed");
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[serial]
-async fn test_heal_format_basic() {
-    let (disk_paths, _ecstore, heal_storage) = setup_test_env().await;
-
-    // ─── 1️⃣ delete format.json on one disk ──────────────
-    let format_path = disk_paths[0].join(".rustfs.sys").join("format.json");
-    assert!(format_path.exists(), "format.json does not exist on disk");
-    std::fs::remove_file(&format_path).expect("failed to delete format.json on disk");
-    assert!(!format_path.exists(), "format.json still exists after deletion");
-    println!("✅ Deleted format.json on disk: {format_path:?}");
-
-    // Create heal manager with faster interval
-    let cfg = HealConfig {
-        heal_interval: Duration::from_secs(2),
-        ..Default::default()
-    };
-    let heal_manager = HealManager::new(heal_storage.clone(), Some(cfg));
-    heal_manager.start().await.unwrap();
-
-    // Wait for task completion
-    tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
-
-    // ─── 2️⃣ verify format.json is restored ───────
-    assert!(format_path.exists(), "format.json does not exist on disk after heal");
-
-    info!("Heal format basic test passed");
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[serial]
-async fn test_heal_format_with_data() {
-    let (disk_paths, ecstore, heal_storage) = setup_test_env().await;
-
-    // Create test bucket and object
-    let bucket_name = "test-bucket";
-    let object_name = "test-object.txt";
-    let test_data = b"Hello, this is test data for healing!";
-
-    create_test_bucket(&ecstore, bucket_name).await;
-    upload_test_object(&ecstore, bucket_name, object_name, test_data).await;
-
-    let obj_dir = disk_paths[0].join(bucket_name).join(object_name);
-    let target_part = WalkDir::new(&obj_dir)
-        .min_depth(2)
-        .max_depth(2)
-        .into_iter()
-        .filter_map(Result::ok)
-        .find(|e| e.file_type().is_file() && e.file_name().to_str().map(|n| n.starts_with("part.")).unwrap_or(false))
-        .map(|e| e.into_path())
-        .expect("Failed to locate part file to delete");
-
-    // ─── 1️⃣ delete format.json on one disk ──────────────
-    let format_path = disk_paths[0].join(".rustfs.sys").join("format.json");
-    std::fs::remove_dir_all(&disk_paths[0]).expect("failed to delete all contents under disk_paths[0]");
-    std::fs::create_dir_all(&disk_paths[0]).expect("failed to recreate disk_paths[0] directory");
-    println!("✅ Deleted format.json on disk: {:?}", disk_paths[0]);
-
-    // Create heal manager with faster interval
-    let cfg = HealConfig {
-        heal_interval: Duration::from_secs(2),
-        ..Default::default()
-    };
-    let heal_manager = HealManager::new(heal_storage.clone(), Some(cfg));
-    heal_manager.start().await.unwrap();
-
-    // Wait for task completion
-    tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
-
-    // ─── 2️⃣ verify format.json is restored ───────
-    assert!(format_path.exists(), "format.json does not exist on disk after heal");
-    // ─── 3 verify each part file is restored ───────
-    assert!(target_part.exists());
-
-    info!("Heal format basic test passed");
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[serial]
-async fn test_heal_storage_api_direct() {
-    let (_disk_paths, ecstore, heal_storage) = setup_test_env().await;
-
-    // Test direct heal storage API calls
-
-    // Test heal_format
-    let format_result = heal_storage.heal_format(true).await; // dry run
-    assert!(format_result.is_ok());
-    info!("Direct heal_format test passed");
-
-    // Test heal_bucket
-    let bucket_name = "test-bucket-direct";
-    create_test_bucket(&ecstore, bucket_name).await;
-
-    let heal_opts = HealOpts {
-        recursive: true,
-        dry_run: true,
-        remove: false,
-        recreate: false,
-        scan_mode: HealScanMode::Normal,
-        update_parity: false,
-        no_lock: false,
-        pool: None,
-        set: None,
-    };
-
-    let bucket_result = heal_storage.heal_bucket(bucket_name, &heal_opts).await;
-    assert!(bucket_result.is_ok());
-    info!("Direct heal_bucket test passed");
-
-    // Test heal_object
-    let object_name = "test-object-direct.txt";
-    let test_data = b"Test data for direct heal API";
-    upload_test_object(&ecstore, bucket_name, object_name, test_data).await;
-
-    let object_heal_opts = HealOpts {
-        recursive: false,
-        dry_run: true,
-        remove: false,
-        recreate: false,
-        scan_mode: HealScanMode::Normal,
-        update_parity: false,
-        no_lock: false,
-        pool: None,
-        set: None,
-    };
-
-    let object_result = heal_storage
-        .heal_object(bucket_name, object_name, None, &object_heal_opts)
-        .await;
-    assert!(object_result.is_ok());
-    info!("Direct heal_object test passed");
-
-    info!("Direct heal storage API test passed");
-}

crates/ahm/tests/integration_tests.rs

@@ -1,388 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::{sync::Arc, time::Duration};
-use tempfile::TempDir;
-
-use rustfs_ahm::scanner::{
-    io_throttler::MetricsSnapshot,
-    local_stats::StatsSummary,
-    node_scanner::{LoadLevel, NodeScanner, NodeScannerConfig},
-    stats_aggregator::{DecentralizedStatsAggregator, DecentralizedStatsAggregatorConfig, NodeInfo},
-};
-
-mod scanner_optimization_tests;
-use scanner_optimization_tests::{PerformanceBenchmark, create_test_scanner};
-
-#[tokio::test]
-async fn test_end_to_end_scanner_lifecycle() {
-    let temp_dir = TempDir::new().unwrap();
-    let scanner = create_test_scanner(&temp_dir).await;
-
-    scanner.initialize_stats().await.expect("Failed to initialize stats");
-
-    let initial_progress = scanner.get_scan_progress().await;
-    assert_eq!(initial_progress.current_cycle, 0);
-
-    scanner.force_save_checkpoint().await.expect("Failed to save checkpoint");
-
-    let checkpoint_info = scanner.get_checkpoint_info().await.unwrap();
-    assert!(checkpoint_info.is_some());
-}
-
-#[tokio::test]
-async fn test_load_balancing_and_throttling_integration() {
-    let temp_dir = TempDir::new().unwrap();
-    let scanner = create_test_scanner(&temp_dir).await;
-
-    let io_monitor = scanner.get_io_monitor();
-    let throttler = scanner.get_io_throttler();
-
-    // Start IO monitoring
-    io_monitor.start().await.expect("Failed to start IO monitor");
-
-    // Simulate load variation scenarios
-    let load_scenarios = vec![
-        (LoadLevel::Low, 10, 100, 0, 5), // (load level, latency, QPS, error rate, connections)
-        (LoadLevel::Medium, 30, 300, 10, 20),
-        (LoadLevel::High, 80, 800, 50, 50),
-        (LoadLevel::Critical, 200, 1200, 100, 100),
-    ];
-
-    for (expected_level, latency, qps, error_rate, connections) in load_scenarios {
-        // Update business metrics
-        scanner.update_business_metrics(latency, qps, error_rate, connections).await;
-
-        // Wait for monitoring system response
-        tokio::time::sleep(Duration::from_millis(1200)).await;
-
-        // Get current load level
-        let current_level = io_monitor.get_business_load_level().await;
-
-        // Get throttling decision
-        let metrics_snapshot = MetricsSnapshot {
-            iops: 100 + qps / 10,
-            latency,
-            cpu_usage: std::cmp::min(50 + (qps / 20) as u8, 100),
-            memory_usage: 40,
-        };
-
-        let decision = throttler.make_throttle_decision(current_level, Some(metrics_snapshot)).await;
-
-        println!(
-            "Load scenario test: Expected={:?}, Actual={:?}, Should_pause={}, Delay={:?}",
-            expected_level, current_level, decision.should_pause, decision.suggested_delay
-        );
-
-        // Verify throttling effect under high load
-        if matches!(current_level, LoadLevel::High | LoadLevel::Critical) {
-            assert!(decision.suggested_delay > Duration::from_millis(1000));
-        }
-
-        if matches!(current_level, LoadLevel::Critical) {
-            assert!(decision.should_pause);
-        }
-    }
-
-    io_monitor.stop().await;
-}
-
-#[tokio::test]
-async fn test_checkpoint_resume_functionality() {
-    let temp_dir = TempDir::new().unwrap();
-
-    // Create first scanner instance
-    let scanner1 = {
-        let config = NodeScannerConfig {
-            data_dir: temp_dir.path().to_path_buf(),
-            ..Default::default()
-        };
-        NodeScanner::new("checkpoint-test-node".to_string(), config)
-    };
-
-    // Initialize and simulate some scan progress
-    scanner1.initialize_stats().await.unwrap();
-
-    // Simulate scan progress
-    scanner1
-        .update_scan_progress_for_test(3, 1, Some("checkpoint-test-key".to_string()))
-        .await;
-
-    // Save checkpoint
-    scanner1.force_save_checkpoint().await.unwrap();
-
-    // Stop first scanner
-    scanner1.stop().await.unwrap();
-
-    // Create second scanner instance (simulate restart)
-    let scanner2 = {
-        let config = NodeScannerConfig {
-            data_dir: temp_dir.path().to_path_buf(),
-            ..Default::default()
-        };
-        NodeScanner::new("checkpoint-test-node".to_string(), config)
-    };
-
-    // Try to recover from checkpoint
-    scanner2.start_with_resume().await.unwrap();
-
-    // Verify recovered progress
-    let recovered_progress = scanner2.get_scan_progress().await;
-    assert_eq!(recovered_progress.current_cycle, 3);
-    assert_eq!(recovered_progress.current_disk_index, 1);
-    assert_eq!(recovered_progress.last_scan_key, Some("checkpoint-test-key".to_string()));
-
-    // Cleanup
-    scanner2.cleanup_checkpoint().await.unwrap();
-}
-
-#[tokio::test]
-async fn test_distributed_stats_aggregation() {
-    // Create decentralized stats aggregator
-    let config = DecentralizedStatsAggregatorConfig {
-        cache_ttl: Duration::from_secs(10), // Increase cache TTL to ensure cache is valid during test
-        node_timeout: Duration::from_millis(500), // Reduce timeout
-        ..Default::default()
-    };
-    let aggregator = DecentralizedStatsAggregator::new(config);
-
-    // Simulate multiple nodes (these nodes don't exist in test environment, will cause connection failures)
-    let node_infos = vec![
-        NodeInfo {
-            node_id: "node-1".to_string(),
-            address: "127.0.0.1".to_string(),
-            port: 9001,
-            is_online: true,
-            last_heartbeat: std::time::SystemTime::now(),
-            version: "1.0.0".to_string(),
-        },
-        NodeInfo {
-            node_id: "node-2".to_string(),
-            address: "127.0.0.1".to_string(),
-            port: 9002,
-            is_online: true,
-            last_heartbeat: std::time::SystemTime::now(),
-            version: "1.0.0".to_string(),
-        },
-    ];
-
-    // Add nodes to aggregator
-    for node_info in node_infos {
-        aggregator.add_node(node_info).await;
-    }
-
-    // Set local statistics (simulate local node)
-    let local_stats = StatsSummary {
-        node_id: "local-node".to_string(),
-        total_objects_scanned: 1000,
-        total_healthy_objects: 950,
-        total_corrupted_objects: 50,
-        total_bytes_scanned: 1024 * 1024 * 100, // 100MB
-        total_scan_errors: 5,
-        total_heal_triggered: 10,
-        total_disks: 4,
-        total_buckets: 5,
-        last_update: std::time::SystemTime::now(),
-        scan_progress: Default::default(),
-    };
-
-    aggregator.set_local_stats(local_stats).await;
-
-    // Get aggregated statistics (remote nodes will fail, but local node should succeed)
-    let aggregated = aggregator.get_aggregated_stats().await.unwrap();
-
-    // Verify local node statistics are included
-    assert!(aggregated.node_summaries.contains_key("local-node"));
-    assert!(aggregated.total_objects_scanned >= 1000);
-
-    // Only local node data due to remote node connection failures
-    assert_eq!(aggregated.node_summaries.len(), 1);
-
-    // Test caching mechanism
-    let original_timestamp = aggregated.aggregation_timestamp;
-
-    let start_time = std::time::Instant::now();
-    let cached_result = aggregator.get_aggregated_stats().await.unwrap();
-    let cached_duration = start_time.elapsed();
-
-    // Verify cache is effective: timestamps should be the same
-    assert_eq!(original_timestamp, cached_result.aggregation_timestamp);
-
-    // Cached calls should be fast (relaxed to 200ms for test environment)
-    assert!(cached_duration < Duration::from_millis(200));
-
-    // Force refresh
-    let _refreshed = aggregator.force_refresh_aggregated_stats().await.unwrap();
-
-    // Clear cache
-    aggregator.clear_cache().await;
-
-    // Verify cache status
-    let cache_status = aggregator.get_cache_status().await;
-    assert!(!cache_status.has_cached_data);
-}
-
-#[tokio::test]
-async fn test_performance_impact_measurement() {
-    let temp_dir = TempDir::new().unwrap();
-    let scanner = create_test_scanner(&temp_dir).await;
-
-    // Start performance monitoring
-    let io_monitor = scanner.get_io_monitor();
-    let _throttler = scanner.get_io_throttler();
-
-    io_monitor.start().await.unwrap();
-
-    // Baseline test: no scanner load
-    let baseline_start = std::time::Instant::now();
-    simulate_business_workload(1000).await;
-    let baseline_duration = baseline_start.elapsed();
-
-    // Simulate scanner activity
-    scanner.update_business_metrics(50, 500, 0, 25).await;
-
-    tokio::time::sleep(Duration::from_millis(100)).await;
-
-    // Performance test: with scanner load
-    let with_scanner_start = std::time::Instant::now();
-    simulate_business_workload(1000).await;
-    let with_scanner_duration = with_scanner_start.elapsed();
-
-    // Calculate performance impact
-    let overhead_ms = with_scanner_duration.saturating_sub(baseline_duration).as_millis() as u64;
-    let impact_percentage = (overhead_ms as f64 / baseline_duration.as_millis() as f64) * 100.0;
-
-    let benchmark = PerformanceBenchmark {
-        _scanner_overhead_ms: overhead_ms,
-        business_impact_percentage: impact_percentage,
-        _throttle_effectiveness: 95.0, // Simulated value
-    };
-
-    println!("Performance impact measurement:");
-    println!("  Baseline duration: {:?}", baseline_duration);
-    println!("  With scanner duration: {:?}", with_scanner_duration);
-    println!("  Overhead: {} ms", overhead_ms);
-    println!("  Impact percentage: {:.2}%", impact_percentage);
-    println!("  Meets optimization goals: {}", benchmark.meets_optimization_goals());
-
-    // Verify optimization target (business impact < 10%)
-    // Note: In real environment this test may need longer time and real load
-    assert!(impact_percentage < 50.0, "Performance impact too high: {:.2}%", impact_percentage);
-
-    io_monitor.stop().await;
-}
-
-#[tokio::test]
-async fn test_concurrent_scanner_operations() {
-    let temp_dir = TempDir::new().unwrap();
-    let scanner = Arc::new(create_test_scanner(&temp_dir).await);
-
-    scanner.initialize_stats().await.unwrap();
-
-    // Execute multiple scanner operations concurrently
-    let tasks = vec![
-        // Task 1: Periodically update business metrics
-        {
-            let scanner = scanner.clone();
-            tokio::spawn(async move {
-                for i in 0..10 {
-                    scanner.update_business_metrics(10 + i * 5, 100 + i * 10, i, 5 + i).await;
-                    tokio::time::sleep(Duration::from_millis(50)).await;
-                }
-            })
-        },
-        // Task 2: Periodically save checkpoints
-        {
-            let scanner = scanner.clone();
-            tokio::spawn(async move {
-                for _i in 0..5 {
-                    if let Err(e) = scanner.force_save_checkpoint().await {
-                        eprintln!("Checkpoint save failed: {}", e);
-                    }
-                    tokio::time::sleep(Duration::from_millis(100)).await;
-                }
-            })
-        },
-        // Task 3: Periodically get statistics
-        {
-            let scanner = scanner.clone();
-            tokio::spawn(async move {
-                for _i in 0..8 {
-                    let _summary = scanner.get_stats_summary().await;
-                    let _progress = scanner.get_scan_progress().await;
-                    tokio::time::sleep(Duration::from_millis(75)).await;
-                }
-            })
-        },
-    ];
-
-    // Wait for all tasks to complete
-    for task in tasks {
-        task.await.unwrap();
-    }
-
-    // Verify final state
-    let final_stats = scanner.get_stats_summary().await;
-    let _final_progress = scanner.get_scan_progress().await;
-
-    assert_eq!(final_stats.node_id, "integration-test-node");
-    assert!(final_stats.last_update > std::time::SystemTime::UNIX_EPOCH);
-
-    // Cleanup
-    scanner.cleanup_checkpoint().await.unwrap();
-}
-
-// Helper function to simulate business workload
-async fn simulate_business_workload(operations: usize) {
-    for _i in 0..operations {
-        // Simulate some CPU-intensive operations
-        let _result: u64 = (0..100).map(|x| x * x).sum();
-
-        // Small delay to simulate IO operations
-        if _i % 100 == 0 {
-            tokio::task::yield_now().await;
-        }
-    }
-}
-
-#[tokio::test]
-async fn test_error_recovery_and_resilience() {
-    let temp_dir = TempDir::new().unwrap();
-    let scanner = create_test_scanner(&temp_dir).await;
-
-    // Test recovery from stats initialization failure
-    scanner.initialize_stats().await.unwrap();
-
-    // Test recovery from checkpoint corruption
-    scanner.force_save_checkpoint().await.unwrap();
-
-    // Artificially corrupt checkpoint file (by writing invalid data)
-    let checkpoint_file = temp_dir.path().join("scanner_checkpoint_integration-test-node.json");
-    if checkpoint_file.exists() {
-        tokio::fs::write(&checkpoint_file, "invalid json data").await.unwrap();
-    }
-
-    // Verify system can gracefully handle corrupted checkpoint
-    let checkpoint_info = scanner.get_checkpoint_info().await;
-    // Should return error or null value, not crash
-    assert!(checkpoint_info.is_err() || checkpoint_info.unwrap().is_none());
-
-    // Clean up corrupted checkpoint
-    scanner.cleanup_checkpoint().await.unwrap();
-
-    // Verify ability to recreate valid checkpoint
-    scanner.force_save_checkpoint().await.unwrap();
-    let new_checkpoint_info = scanner.get_checkpoint_info().await.unwrap();
-    assert!(new_checkpoint_info.is_some());
-}

crates/ahm/tests/lifecycle_integration_test.rs

@@ -1,581 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use rustfs_ahm::scanner::{Scanner, data_scanner::ScannerConfig};
-use rustfs_ecstore::{
-    bucket::metadata::BUCKET_LIFECYCLE_CONFIG,
-    bucket::metadata_sys,
-    disk::endpoint::Endpoint,
-    endpoints::{EndpointServerPools, Endpoints, PoolEndpoints},
-    store::ECStore,
-    store_api::{MakeBucketOptions, ObjectIO, ObjectOptions, PutObjReader, StorageAPI},
-    tier::tier::TierConfigMgr,
-    tier::tier_config::{TierConfig, TierMinIO, TierType},
-};
-use serial_test::serial;
-use std::sync::Once;
-use std::sync::OnceLock;
-use std::{path::PathBuf, sync::Arc, time::Duration};
-use tokio::fs;
-use tokio::sync::RwLock;
-use tracing::warn;
-use tracing::{debug, info};
-
-static GLOBAL_ENV: OnceLock<(Vec<PathBuf>, Arc<ECStore>)> = OnceLock::new();
-static INIT: Once = Once::new();
-static GLOBAL_TIER_CONFIG_MGR: OnceLock<Arc<RwLock<TierConfigMgr>>> = OnceLock::new();
-
-fn init_tracing() {
-    INIT.call_once(|| {
-        let _ = tracing_subscriber::fmt::try_init();
-    });
-}
-
-/// Test helper: Create test environment with ECStore
-async fn setup_test_env() -> (Vec<PathBuf>, Arc<ECStore>) {
-    init_tracing();
-
-    // Fast path: already initialized, just clone and return
-    if let Some((paths, ecstore)) = GLOBAL_ENV.get() {
-        return (paths.clone(), ecstore.clone());
-    }
-
-    // create temp dir as 4 disks with unique base dir
-    let test_base_dir = format!("/tmp/rustfs_ahm_lifecycle_test_{}", uuid::Uuid::new_v4());
-    let temp_dir = std::path::PathBuf::from(&test_base_dir);
-    if temp_dir.exists() {
-        fs::remove_dir_all(&temp_dir).await.ok();
-    }
-    fs::create_dir_all(&temp_dir).await.unwrap();
-
-    // create 4 disk dirs
-    let disk_paths = vec![
-        temp_dir.join("disk1"),
-        temp_dir.join("disk2"),
-        temp_dir.join("disk3"),
-        temp_dir.join("disk4"),
-    ];
-
-    for disk_path in &disk_paths {
-        fs::create_dir_all(disk_path).await.unwrap();
-    }
-
-    // create EndpointServerPools
-    let mut endpoints = Vec::new();
-    for (i, disk_path) in disk_paths.iter().enumerate() {
-        let mut endpoint = Endpoint::try_from(disk_path.to_str().unwrap()).unwrap();
-        // set correct index
-        endpoint.set_pool_index(0);
-        endpoint.set_set_index(0);
-        endpoint.set_disk_index(i);
-        endpoints.push(endpoint);
-    }
-
-    let pool_endpoints = PoolEndpoints {
-        legacy: false,
-        set_count: 1,
-        drives_per_set: 4,
-        endpoints: Endpoints::from(endpoints),
-        cmd_line: "test".to_string(),
-        platform: format!("OS: {} | Arch: {}", std::env::consts::OS, std::env::consts::ARCH),
-    };
-
-    let endpoint_pools = EndpointServerPools(vec![pool_endpoints]);
-
-    // format disks (only first time)
-    rustfs_ecstore::store::init_local_disks(endpoint_pools.clone()).await.unwrap();
-
-    // create ECStore with dynamic port 0 (let OS assign) or fixed 9002 if free
-    let port = 9002; // for simplicity
-    let server_addr: std::net::SocketAddr = format!("127.0.0.1:{port}").parse().unwrap();
-    let ecstore = ECStore::new(server_addr, endpoint_pools).await.unwrap();
-
-    // init bucket metadata system
-    let buckets_list = ecstore
-        .list_bucket(&rustfs_ecstore::store_api::BucketOptions {
-            no_metadata: true,
-            ..Default::default()
-        })
-        .await
-        .unwrap();
-    let buckets = buckets_list.into_iter().map(|v| v.name).collect();
-    rustfs_ecstore::bucket::metadata_sys::init_bucket_metadata_sys(ecstore.clone(), buckets).await;
-
-    // Initialize background expiry workers
-    rustfs_ecstore::bucket::lifecycle::bucket_lifecycle_ops::init_background_expiry(ecstore.clone()).await;
-
-    // Store in global once lock
-    let _ = GLOBAL_ENV.set((disk_paths.clone(), ecstore.clone()));
-
-    let _ = GLOBAL_TIER_CONFIG_MGR.set(TierConfigMgr::new());
-
-    (disk_paths, ecstore)
-}
-
-/// Test helper: Create a test bucket
-async fn create_test_bucket(ecstore: &Arc<ECStore>, bucket_name: &str) {
-    (**ecstore)
-        .make_bucket(bucket_name, &Default::default())
-        .await
-        .expect("Failed to create test bucket");
-    info!("Created test bucket: {}", bucket_name);
-}
-
-/// Test helper: Create a test lock bucket
-async fn create_test_lock_bucket(ecstore: &Arc<ECStore>, bucket_name: &str) {
-    (**ecstore)
-        .make_bucket(
-            bucket_name,
-            &MakeBucketOptions {
-                lock_enabled: true,
-                versioning_enabled: true,
-                ..Default::default()
-            },
-        )
-        .await
-        .expect("Failed to create test bucket");
-    info!("Created test bucket: {}", bucket_name);
-}
-
-/// Test helper: Upload test object
-async fn upload_test_object(ecstore: &Arc<ECStore>, bucket: &str, object: &str, data: &[u8]) {
-    let mut reader = PutObjReader::from_vec(data.to_vec());
-    let object_info = (**ecstore)
-        .put_object(bucket, object, &mut reader, &ObjectOptions::default())
-        .await
-        .expect("Failed to upload test object");
-
-    info!("Uploaded test object: {}/{} ({} bytes)", bucket, object, object_info.size);
-}
-
-/// Test helper: Set bucket lifecycle configuration
-async fn set_bucket_lifecycle(bucket_name: &str) -> Result<(), Box<dyn std::error::Error>> {
-    // Create a simple lifecycle configuration XML with 0 days expiry for immediate testing
-    let lifecycle_xml = r#"<?xml version="1.0" encoding="UTF-8"?>
-<LifecycleConfiguration>
-    <Rule>
-        <ID>test-rule</ID>
-        <Status>Enabled</Status>
-        <Filter>
-            <Prefix>test/</Prefix>
-        </Filter>
-        <Expiration>
-            <Days>0</Days>
-        </Expiration>
-    </Rule>
-</LifecycleConfiguration>"#;
-
-    metadata_sys::update(bucket_name, BUCKET_LIFECYCLE_CONFIG, lifecycle_xml.as_bytes().to_vec()).await?;
-
-    Ok(())
-}
-
-/// Test helper: Set bucket lifecycle configuration
-async fn set_bucket_lifecycle_deletemarker(bucket_name: &str) -> Result<(), Box<dyn std::error::Error>> {
-    // Create a simple lifecycle configuration XML with 0 days expiry for immediate testing
-    let lifecycle_xml = r#"<?xml version="1.0" encoding="UTF-8"?>
-<LifecycleConfiguration>
-    <Rule>
-        <ID>test-rule</ID>
-        <Status>Enabled</Status>
-        <Filter>
-            <Prefix>test/</Prefix>
-        </Filter>
-        <Expiration>
-            <Days>0</Days>
-            <ExpiredObjectDeleteMarker>true</ExpiredObjectDeleteMarker>
-        </Expiration>
-    </Rule>
-</LifecycleConfiguration>"#;
-
-    metadata_sys::update(bucket_name, BUCKET_LIFECYCLE_CONFIG, lifecycle_xml.as_bytes().to_vec()).await?;
-
-    Ok(())
-}
-
-#[allow(dead_code)]
-async fn set_bucket_lifecycle_transition(bucket_name: &str) -> Result<(), Box<dyn std::error::Error>> {
-    // Create a simple lifecycle configuration XML with 0 days expiry for immediate testing
-    let lifecycle_xml = r#"<?xml version="1.0" encoding="UTF-8"?>
-<LifecycleConfiguration>
-    <Rule>
-        <ID>test-rule</ID>
-        <Status>Enabled</Status>
-        <Filter>
-            <Prefix>test/</Prefix>
-        </Filter>
-        <Transition>
-          <Days>0</Days>
-          <StorageClass>COLDTIER</StorageClass>
-        </Transition>
-    </Rule>
-    <Rule>
-        <ID>test-rule2</ID>
-        <Status>Desabled</Status>
-        <Filter>
-            <Prefix>test/</Prefix>
-        </Filter>
-        <NoncurrentVersionTransition>
-          <NoncurrentDays>0</NoncurrentDays>
-          <StorageClass>COLDTIER</StorageClass>
-        </NoncurrentVersionTransition>
-    </Rule>
-</LifecycleConfiguration>"#;
-
-    metadata_sys::update(bucket_name, BUCKET_LIFECYCLE_CONFIG, lifecycle_xml.as_bytes().to_vec()).await?;
-
-    Ok(())
-}
-
-/// Test helper: Create a test tier
-#[allow(dead_code)]
-async fn create_test_tier() {
-    let args = TierConfig {
-        version: "v1".to_string(),
-        tier_type: TierType::MinIO,
-        name: "COLDTIER".to_string(),
-        s3: None,
-        rustfs: None,
-        minio: Some(TierMinIO {
-            access_key: "minioadmin".to_string(),
-            secret_key: "minioadmin".to_string(),
-            bucket: "mblock2".to_string(),
-            endpoint: "http://127.0.0.1:9020".to_string(),
-            prefix: "mypre3/".to_string(),
-            region: "".to_string(),
-            ..Default::default()
-        }),
-    };
-    let mut tier_config_mgr = GLOBAL_TIER_CONFIG_MGR.get().unwrap().write().await;
-    if let Err(err) = tier_config_mgr.add(args, false).await {
-        warn!("tier_config_mgr add failed, e: {:?}", err);
-        panic!("tier add failed. {err}");
-    }
-    if let Err(e) = tier_config_mgr.save().await {
-        warn!("tier_config_mgr save failed, e: {:?}", e);
-        panic!("tier save failed");
-    }
-    info!("Created test tier: {}", "COLDTIER");
-}
-
-/// Test helper: Check if object exists
-async fn object_exists(ecstore: &Arc<ECStore>, bucket: &str, object: &str) -> bool {
-    ((**ecstore).get_object_info(bucket, object, &ObjectOptions::default()).await).is_ok()
-}
-
-/// Test helper: Check if object exists
-#[allow(dead_code)]
-async fn object_is_delete_marker(ecstore: &Arc<ECStore>, bucket: &str, object: &str) -> bool {
-    if let Ok(oi) = (**ecstore).get_object_info(bucket, object, &ObjectOptions::default()).await {
-        debug!("oi: {:?}", oi);
-        oi.delete_marker
-    } else {
-        panic!("object_is_delete_marker is error");
-    }
-}
-
-/// Test helper: Check if object exists
-#[allow(dead_code)]
-async fn object_is_transitioned(ecstore: &Arc<ECStore>, bucket: &str, object: &str) -> bool {
-    if let Ok(oi) = (**ecstore).get_object_info(bucket, object, &ObjectOptions::default()).await {
-        info!("oi: {:?}", oi);
-        !oi.transitioned_object.status.is_empty()
-    } else {
-        panic!("object_is_transitioned is error");
-    }
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[serial]
-async fn test_lifecycle_expiry_basic() {
-    let (_disk_paths, ecstore) = setup_test_env().await;
-
-    // Create test bucket and object
-    let bucket_name = "test-lifecycle-bucket";
-    let object_name = "test/object.txt"; // Match the lifecycle rule prefix "test/"
-    let test_data = b"Hello, this is test data for lifecycle expiry!";
-
-    create_test_bucket(&ecstore, bucket_name).await;
-    upload_test_object(&ecstore, bucket_name, object_name, test_data).await;
-
-    // Verify object exists initially
-    assert!(object_exists(&ecstore, bucket_name, object_name).await);
-    println!("✅ Object exists before lifecycle processing");
-
-    // Set lifecycle configuration with very short expiry (0 days = immediate expiry)
-    set_bucket_lifecycle(bucket_name)
-        .await
-        .expect("Failed to set lifecycle configuration");
-    println!("✅ Lifecycle configuration set for bucket: {bucket_name}");
-
-    // Verify lifecycle configuration was set
-    match rustfs_ecstore::bucket::metadata_sys::get(bucket_name).await {
-        Ok(bucket_meta) => {
-            assert!(bucket_meta.lifecycle_config.is_some());
-            println!("✅ Bucket metadata retrieved successfully");
-        }
-        Err(e) => {
-            println!("❌ Error retrieving bucket metadata: {e:?}");
-        }
-    }
-
-    // Create scanner with very short intervals for testing
-    let scanner_config = ScannerConfig {
-        scan_interval: Duration::from_millis(100),
-        deep_scan_interval: Duration::from_millis(500),
-        max_concurrent_scans: 1,
-        ..Default::default()
-    };
-
-    let scanner = Scanner::new(Some(scanner_config), None);
-
-    // Start scanner
-    scanner.start().await.expect("Failed to start scanner");
-    println!("✅ Scanner started");
-
-    // Wait for scanner to process lifecycle rules
-    tokio::time::sleep(Duration::from_secs(2)).await;
-
-    // Manually trigger a scan cycle to ensure lifecycle processing
-    scanner.scan_cycle().await.expect("Failed to trigger scan cycle");
-    println!("✅ Manual scan cycle completed");
-
-    // Wait a bit more for background workers to process expiry tasks
-    tokio::time::sleep(Duration::from_secs(5)).await;
-
-    // Check if object has been expired (delete_marker)
-    let check_result = object_exists(&ecstore, bucket_name, object_name).await;
-    println!("Object is_delete_marker after lifecycle processing: {check_result}");
-
-    if check_result {
-        println!("❌ Object was not deleted by lifecycle processing");
-    } else {
-        println!("✅ Object was successfully deleted by lifecycle processing");
-        // Let's try to get object info to see its details
-        match ecstore
-            .get_object_info(bucket_name, object_name, &rustfs_ecstore::store_api::ObjectOptions::default())
-            .await
-        {
-            Ok(obj_info) => {
-                println!(
-                    "Object info: name={}, size={}, mod_time={:?}",
-                    obj_info.name, obj_info.size, obj_info.mod_time
-                );
-            }
-            Err(e) => {
-                println!("Error getting object info: {e:?}");
-            }
-        }
-    }
-
-    assert!(!check_result);
-    println!("✅ Object successfully expired");
-
-    // Stop scanner
-    let _ = scanner.stop().await;
-    println!("✅ Scanner stopped");
-
-    println!("Lifecycle expiry basic test completed");
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[serial]
-async fn test_lifecycle_expiry_deletemarker() {
-    let (_disk_paths, ecstore) = setup_test_env().await;
-
-    // Create test bucket and object
-    let bucket_name = "test-lifecycle-bucket";
-    let object_name = "test/object.txt"; // Match the lifecycle rule prefix "test/"
-    let test_data = b"Hello, this is test data for lifecycle expiry!";
-
-    create_test_lock_bucket(&ecstore, bucket_name).await;
-    upload_test_object(&ecstore, bucket_name, object_name, test_data).await;
-
-    // Verify object exists initially
-    assert!(object_exists(&ecstore, bucket_name, object_name).await);
-    println!("✅ Object exists before lifecycle processing");
-
-    // Set lifecycle configuration with very short expiry (0 days = immediate expiry)
-    set_bucket_lifecycle_deletemarker(bucket_name)
-        .await
-        .expect("Failed to set lifecycle configuration");
-    println!("✅ Lifecycle configuration set for bucket: {bucket_name}");
-
-    // Verify lifecycle configuration was set
-    match rustfs_ecstore::bucket::metadata_sys::get(bucket_name).await {
-        Ok(bucket_meta) => {
-            assert!(bucket_meta.lifecycle_config.is_some());
-            println!("✅ Bucket metadata retrieved successfully");
-        }
-        Err(e) => {
-            println!("❌ Error retrieving bucket metadata: {e:?}");
-        }
-    }
-
-    // Create scanner with very short intervals for testing
-    let scanner_config = ScannerConfig {
-        scan_interval: Duration::from_millis(100),
-        deep_scan_interval: Duration::from_millis(500),
-        max_concurrent_scans: 1,
-        ..Default::default()
-    };
-
-    let scanner = Scanner::new(Some(scanner_config), None);
-
-    // Start scanner
-    scanner.start().await.expect("Failed to start scanner");
-    println!("✅ Scanner started");
-
-    // Wait for scanner to process lifecycle rules
-    tokio::time::sleep(Duration::from_secs(2)).await;
-
-    // Manually trigger a scan cycle to ensure lifecycle processing
-    scanner.scan_cycle().await.expect("Failed to trigger scan cycle");
-    println!("✅ Manual scan cycle completed");
-
-    // Wait a bit more for background workers to process expiry tasks
-    tokio::time::sleep(Duration::from_secs(5)).await;
-
-    // Check if object has been expired (deleted)
-    //let check_result = object_is_delete_marker(&ecstore, bucket_name, object_name).await;
-    let check_result = object_exists(&ecstore, bucket_name, object_name).await;
-    println!("Object exists after lifecycle processing: {check_result}");
-
-    if !check_result {
-        println!("❌ Object was not deleted by lifecycle processing");
-        // Let's try to get object info to see its details
-        match ecstore
-            .get_object_info(bucket_name, object_name, &rustfs_ecstore::store_api::ObjectOptions::default())
-            .await
-        {
-            Ok(obj_info) => {
-                println!(
-                    "Object info: name={}, size={}, mod_time={:?}",
-                    obj_info.name, obj_info.size, obj_info.mod_time
-                );
-            }
-            Err(e) => {
-                println!("Error getting object info: {e:?}");
-            }
-        }
-    } else {
-        println!("✅ Object was successfully deleted by lifecycle processing");
-    }
-
-    assert!(check_result);
-    println!("✅ Object successfully expired");
-
-    // Stop scanner
-    let _ = scanner.stop().await;
-    println!("✅ Scanner stopped");
-
-    println!("Lifecycle expiry basic test completed");
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[serial]
-async fn test_lifecycle_transition_basic() {
-    let (_disk_paths, ecstore) = setup_test_env().await;
-
-    //create_test_tier().await;
-
-    // Create test bucket and object
-    let bucket_name = "test-lifecycle-bucket";
-    let object_name = "test/object.txt"; // Match the lifecycle rule prefix "test/"
-    let test_data = b"Hello, this is test data for lifecycle expiry!";
-
-    create_test_bucket(&ecstore, bucket_name).await;
-    upload_test_object(&ecstore, bucket_name, object_name, test_data).await;
-
-    // Verify object exists initially
-    assert!(object_exists(&ecstore, bucket_name, object_name).await);
-    println!("✅ Object exists before lifecycle processing");
-
-    // Set lifecycle configuration with very short expiry (0 days = immediate expiry)
-    /*set_bucket_lifecycle_transition(bucket_name)
-        .await
-        .expect("Failed to set lifecycle configuration");
-    println!("✅ Lifecycle configuration set for bucket: {bucket_name}");
-
-    // Verify lifecycle configuration was set
-    match rustfs_ecstore::bucket::metadata_sys::get(bucket_name).await {
-        Ok(bucket_meta) => {
-            assert!(bucket_meta.lifecycle_config.is_some());
-            println!("✅ Bucket metadata retrieved successfully");
-        }
-        Err(e) => {
-            println!("❌ Error retrieving bucket metadata: {e:?}");
-        }
-    }*/
-
-    // Create scanner with very short intervals for testing
-    let scanner_config = ScannerConfig {
-        scan_interval: Duration::from_millis(100),
-        deep_scan_interval: Duration::from_millis(500),
-        max_concurrent_scans: 1,
-        ..Default::default()
-    };
-
-    let scanner = Scanner::new(Some(scanner_config), None);
-
-    // Start scanner
-    scanner.start().await.expect("Failed to start scanner");
-    println!("✅ Scanner started");
-
-    // Wait for scanner to process lifecycle rules
-    tokio::time::sleep(Duration::from_secs(2)).await;
-
-    // Manually trigger a scan cycle to ensure lifecycle processing
-    scanner.scan_cycle().await.expect("Failed to trigger scan cycle");
-    println!("✅ Manual scan cycle completed");
-
-    // Wait a bit more for background workers to process expiry tasks
-    tokio::time::sleep(Duration::from_secs(5)).await;
-
-    // Check if object has been expired (deleted)
-    //let check_result = object_is_transitioned(&ecstore, bucket_name, object_name).await;
-    let check_result = object_exists(&ecstore, bucket_name, object_name).await;
-    println!("Object exists after lifecycle processing: {check_result}");
-
-    if check_result {
-        println!("✅ Object was not deleted by lifecycle processing");
-        // Let's try to get object info to see its details
-        match ecstore
-            .get_object_info(bucket_name, object_name, &rustfs_ecstore::store_api::ObjectOptions::default())
-            .await
-        {
-            Ok(obj_info) => {
-                println!(
-                    "Object info: name={}, size={}, mod_time={:?}",
-                    obj_info.name, obj_info.size, obj_info.mod_time
-                );
-                println!("Object info: transitioned_object={:?}", obj_info.transitioned_object);
-            }
-            Err(e) => {
-                println!("Error getting object info: {e:?}");
-            }
-        }
-    } else {
-        println!("❌ Object was deleted by lifecycle processing");
-    }
-
-    assert!(check_result);
-    println!("✅ Object successfully transitioned");
-
-    // Stop scanner
-    let _ = scanner.stop().await;
-    println!("✅ Scanner stopped");
-
-    println!("Lifecycle transition basic test completed");
-}

crates/ahm/tests/optimized_scanner_tests.rs

@@ -1,817 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::{fs, net::SocketAddr, sync::Arc, sync::OnceLock, time::Duration};
-use tempfile::TempDir;
-
-use serial_test::serial;
-
-use rustfs_ahm::heal::manager::HealConfig;
-use rustfs_ahm::scanner::{
-    Scanner,
-    data_scanner::ScanMode,
-    node_scanner::{LoadLevel, NodeScanner, NodeScannerConfig},
-};
-
-use rustfs_ecstore::disk::endpoint::Endpoint;
-use rustfs_ecstore::endpoints::{EndpointServerPools, Endpoints, PoolEndpoints};
-use rustfs_ecstore::store::ECStore;
-use rustfs_ecstore::{
-    StorageAPI,
-    store_api::{MakeBucketOptions, ObjectIO, PutObjReader},
-};
-
-// Global test environment cache to avoid repeated initialization
-static GLOBAL_TEST_ENV: OnceLock<(Vec<std::path::PathBuf>, Arc<ECStore>)> = OnceLock::new();
-
-async fn prepare_test_env(test_dir: Option<&str>, port: Option<u16>) -> (Vec<std::path::PathBuf>, Arc<ECStore>) {
-    // Check if global environment is already initialized
-    if let Some((disk_paths, ecstore)) = GLOBAL_TEST_ENV.get() {
-        return (disk_paths.clone(), ecstore.clone());
-    }
-
-    // create temp dir as 4 disks
-    let test_base_dir = test_dir.unwrap_or("/tmp/rustfs_ahm_optimized_test");
-    let temp_dir = std::path::PathBuf::from(test_base_dir);
-    if temp_dir.exists() {
-        fs::remove_dir_all(&temp_dir).unwrap();
-    }
-    fs::create_dir_all(&temp_dir).unwrap();
-
-    // create 4 disk dirs
-    let disk_paths = vec![
-        temp_dir.join("disk1"),
-        temp_dir.join("disk2"),
-        temp_dir.join("disk3"),
-        temp_dir.join("disk4"),
-    ];
-
-    for disk_path in &disk_paths {
-        fs::create_dir_all(disk_path).unwrap();
-    }
-
-    // create EndpointServerPools
-    let mut endpoints = Vec::new();
-    for (i, disk_path) in disk_paths.iter().enumerate() {
-        let mut endpoint = Endpoint::try_from(disk_path.to_str().unwrap()).unwrap();
-        // set correct index
-        endpoint.set_pool_index(0);
-        endpoint.set_set_index(0);
-        endpoint.set_disk_index(i);
-        endpoints.push(endpoint);
-    }
-
-    let pool_endpoints = PoolEndpoints {
-        legacy: false,
-        set_count: 1,
-        drives_per_set: 4,
-        endpoints: Endpoints::from(endpoints),
-        cmd_line: "test".to_string(),
-        platform: format!("OS: {} | Arch: {}", std::env::consts::OS, std::env::consts::ARCH),
-    };
-
-    let endpoint_pools = EndpointServerPools(vec![pool_endpoints]);
-
-    // format disks
-    rustfs_ecstore::store::init_local_disks(endpoint_pools.clone()).await.unwrap();
-
-    // create ECStore with dynamic port
-    let port = port.unwrap_or(9000);
-    let server_addr: SocketAddr = format!("127.0.0.1:{port}").parse().unwrap();
-    let ecstore = ECStore::new(server_addr, endpoint_pools).await.unwrap();
-
-    // init bucket metadata system
-    let buckets_list = ecstore
-        .list_bucket(&rustfs_ecstore::store_api::BucketOptions {
-            no_metadata: true,
-            ..Default::default()
-        })
-        .await
-        .unwrap();
-    let buckets = buckets_list.into_iter().map(|v| v.name).collect();
-    rustfs_ecstore::bucket::metadata_sys::init_bucket_metadata_sys(ecstore.clone(), buckets).await;
-
-    // Store in global cache
-    let _ = GLOBAL_TEST_ENV.set((disk_paths.clone(), ecstore.clone()));
-
-    (disk_paths, ecstore)
-}
-
-#[tokio::test(flavor = "multi_thread")]
-#[ignore = "Please run it manually."]
-#[serial]
-async fn test_optimized_scanner_basic_functionality() {
-    const TEST_DIR_BASIC: &str = "/tmp/rustfs_ahm_optimized_test_basic";
-    let (disk_paths, ecstore) = prepare_test_env(Some(TEST_DIR_BASIC), Some(9101)).await;
-
-    // create some test data
-    let bucket_name = "test-bucket";
-    let object_name = "test-object";
-    let test_data = b"Hello, Optimized RustFS!";
-
-    // create bucket and verify
-    let bucket_opts = MakeBucketOptions::default();
-    ecstore
-        .make_bucket(bucket_name, &bucket_opts)
-        .await
-        .expect("make_bucket failed");
-
-    // check bucket really exists
-    let buckets = ecstore
-        .list_bucket(&rustfs_ecstore::store_api::BucketOptions::default())
-        .await
-        .unwrap();
-    assert!(buckets.iter().any(|b| b.name == bucket_name), "bucket not found after creation");
-
-    // write object
-    let mut put_reader = PutObjReader::from_vec(test_data.to_vec());
-    let object_opts = rustfs_ecstore::store_api::ObjectOptions::default();
-    ecstore
-        .put_object(bucket_name, object_name, &mut put_reader, &object_opts)
-        .await
-        .expect("put_object failed");
-
-    // create optimized Scanner and test basic functionality
-    let scanner = Scanner::new(None, None);
-
-    // Test 1: Normal scan - verify object is found
-    println!("=== Test 1: Optimized Normal scan ===");
-    let scan_result = scanner.scan_cycle().await;
-    assert!(scan_result.is_ok(), "Optimized normal scan should succeed");
-    let _metrics = scanner.get_metrics().await;
-    // Note: The optimized scanner may not immediately show scanned objects as it works differently
-    println!("Optimized normal scan completed successfully");
-
-    // Test 2: Simulate disk corruption - delete object data from disk1
-    println!("=== Test 2: Optimized corruption handling ===");
-    let disk1_bucket_path = disk_paths[0].join(bucket_name);
-    let disk1_object_path = disk1_bucket_path.join(object_name);
-
-    // Try to delete the object file from disk1 (simulate corruption)
-    // Note: This might fail if ECStore is actively using the file
-    match fs::remove_dir_all(&disk1_object_path) {
-        Ok(_) => {
-            println!("Successfully deleted object from disk1: {disk1_object_path:?}");
-
-            // Verify deletion by checking if the directory still exists
-            if disk1_object_path.exists() {
-                println!("WARNING: Directory still exists after deletion: {disk1_object_path:?}");
-            } else {
-                println!("Confirmed: Directory was successfully deleted");
-            }
-        }
-        Err(e) => {
-            println!("Could not delete object from disk1 (file may be in use): {disk1_object_path:?} - {e}");
-            // This is expected behavior - ECStore might be holding file handles
-        }
-    }
-
-    // Scan again - should still complete (even with missing data)
-    let scan_result_after_corruption = scanner.scan_cycle().await;
-    println!("Optimized scan after corruption result: {scan_result_after_corruption:?}");
-
-    // Scanner should handle missing data gracefully
-    assert!(
-        scan_result_after_corruption.is_ok(),
-        "Optimized scanner should handle missing data gracefully"
-    );
-
-    // Test 3: Test metrics collection
-    println!("=== Test 3: Optimized metrics collection ===");
-    let final_metrics = scanner.get_metrics().await;
-    println!("Optimized final metrics: {final_metrics:?}");
-
-    // Verify metrics are available (even if different from legacy scanner)
-    assert!(final_metrics.last_activity.is_some(), "Should have scan activity");
-
-    // clean up temp dir
-    let temp_dir = std::path::PathBuf::from(TEST_DIR_BASIC);
-    if let Err(e) = fs::remove_dir_all(&temp_dir) {
-        eprintln!("Warning: Failed to clean up temp directory {temp_dir:?}: {e}");
-    }
-}
-
-#[tokio::test(flavor = "multi_thread")]
-#[ignore = "Please run it manually."]
-#[serial]
-async fn test_optimized_scanner_usage_stats() {
-    const TEST_DIR_USAGE_STATS: &str = "/tmp/rustfs_ahm_optimized_test_usage_stats";
-    let (_, ecstore) = prepare_test_env(Some(TEST_DIR_USAGE_STATS), Some(9102)).await;
-
-    // prepare test bucket and object
-    let bucket = "test-bucket-optimized";
-    ecstore.make_bucket(bucket, &Default::default()).await.unwrap();
-    let mut pr = PutObjReader::from_vec(b"hello optimized".to_vec());
-    ecstore
-        .put_object(bucket, "obj1", &mut pr, &Default::default())
-        .await
-        .unwrap();
-
-    let scanner = Scanner::new(None, None);
-
-    // enable statistics
-    scanner.set_config_enable_data_usage_stats(true).await;
-
-    // first scan and get statistics
-    scanner.scan_cycle().await.unwrap();
-    let du_initial = scanner.get_data_usage_info().await.unwrap();
-    // Note: Optimized scanner may work differently, so we're less strict about counts
-    println!("Initial data usage: {du_initial:?}");
-
-    // write 3 more objects and get statistics again
-    for size in [1024, 2048, 4096] {
-        let name = format!("obj_{size}");
-        let mut pr = PutObjReader::from_vec(vec![b'x'; size]);
-        ecstore.put_object(bucket, &name, &mut pr, &Default::default()).await.unwrap();
-    }
-
-    scanner.scan_cycle().await.unwrap();
-    let du_after = scanner.get_data_usage_info().await.unwrap();
-    println!("Data usage after adding objects: {du_after:?}");
-
-    // The optimized scanner should at least not crash and return valid data
-    // buckets_count is u64, so it's always >= 0
-    assert!(du_after.buckets_count == du_after.buckets_count);
-
-    // clean up temp dir
-    let _ = std::fs::remove_dir_all(std::path::Path::new(TEST_DIR_USAGE_STATS));
-}
-
-#[tokio::test(flavor = "multi_thread")]
-#[ignore = "Please run it manually."]
-#[serial]
-async fn test_optimized_volume_healing_functionality() {
-    const TEST_DIR_VOLUME_HEAL: &str = "/tmp/rustfs_ahm_optimized_test_volume_heal";
-    let (disk_paths, ecstore) = prepare_test_env(Some(TEST_DIR_VOLUME_HEAL), Some(9103)).await;
-
-    // Create test buckets
-    let bucket1 = "test-bucket-1-opt";
-    let bucket2 = "test-bucket-2-opt";
-
-    ecstore.make_bucket(bucket1, &Default::default()).await.unwrap();
-    ecstore.make_bucket(bucket2, &Default::default()).await.unwrap();
-
-    // Add some test objects
-    let mut pr1 = PutObjReader::from_vec(b"test data 1 optimized".to_vec());
-    ecstore
-        .put_object(bucket1, "obj1", &mut pr1, &Default::default())
-        .await
-        .unwrap();
-
-    let mut pr2 = PutObjReader::from_vec(b"test data 2 optimized".to_vec());
-    ecstore
-        .put_object(bucket2, "obj2", &mut pr2, &Default::default())
-        .await
-        .unwrap();
-
-    // Simulate missing bucket on one disk by removing bucket directory
-    let disk1_bucket1_path = disk_paths[0].join(bucket1);
-    if disk1_bucket1_path.exists() {
-        println!("Removing bucket directory to simulate missing volume: {disk1_bucket1_path:?}");
-        match fs::remove_dir_all(&disk1_bucket1_path) {
-            Ok(_) => println!("Successfully removed bucket directory from disk 0"),
-            Err(e) => println!("Failed to remove bucket directory: {e}"),
-        }
-    }
-
-    // Create optimized scanner
-    let scanner = Scanner::new(None, None);
-
-    // Enable healing in config
-    scanner.set_config_enable_healing(true).await;
-
-    println!("=== Testing optimized volume healing functionality ===");
-
-    // Run scan cycle which should detect missing volume
-    let scan_result = scanner.scan_cycle().await;
-    assert!(scan_result.is_ok(), "Optimized scan cycle should succeed");
-
-    // Get metrics to verify scan completed
-    let metrics = scanner.get_metrics().await;
-    println!("Optimized volume healing detection test completed successfully");
-    println!("Optimized scan metrics: {metrics:?}");
-
-    // Clean up
-    let _ = std::fs::remove_dir_all(std::path::Path::new(TEST_DIR_VOLUME_HEAL));
-}
-
-#[tokio::test(flavor = "multi_thread")]
-#[ignore = "Please run it manually."]
-#[serial]
-async fn test_optimized_performance_characteristics() {
-    const TEST_DIR_PERF: &str = "/tmp/rustfs_ahm_optimized_test_perf";
-    let (_, ecstore) = prepare_test_env(Some(TEST_DIR_PERF), Some(9104)).await;
-
-    // Create test bucket with multiple objects
-    let bucket_name = "performance-test-bucket";
-    ecstore.make_bucket(bucket_name, &Default::default()).await.unwrap();
-
-    // Create several test objects
-    for i in 0..10 {
-        let object_name = format!("perf-object-{}", i);
-        let test_data = vec![b'A' + (i % 26) as u8; 1024 * (i + 1)]; // Variable size objects
-        let mut put_reader = PutObjReader::from_vec(test_data);
-        let object_opts = rustfs_ecstore::store_api::ObjectOptions::default();
-        ecstore
-            .put_object(bucket_name, &object_name, &mut put_reader, &object_opts)
-            .await
-            .unwrap_or_else(|_| panic!("Failed to create object {}", object_name));
-    }
-
-    // Create optimized scanner
-    let scanner = Scanner::new(None, None);
-
-    // Test performance characteristics
-    println!("=== Testing optimized scanner performance ===");
-
-    // Measure scan time
-    let start_time = std::time::Instant::now();
-    let scan_result = scanner.scan_cycle().await;
-    let scan_duration = start_time.elapsed();
-
-    println!("Optimized scan completed in: {:?}", scan_duration);
-    assert!(scan_result.is_ok(), "Performance scan should succeed");
-
-    // Verify the scan was reasonably fast (should be faster than old concurrent scanner)
-    // Note: This is a rough check - in practice, optimized scanner should be much faster
-    assert!(
-        scan_duration < Duration::from_secs(30),
-        "Optimized scan should complete within 30 seconds"
-    );
-
-    // Test memory usage is reasonable (indirect test through successful completion)
-    let metrics = scanner.get_metrics().await;
-    println!("Performance test metrics: {metrics:?}");
-
-    // Test that multiple scans don't degrade performance significantly
-    let start_time2 = std::time::Instant::now();
-    let _scan_result2 = scanner.scan_cycle().await;
-    let scan_duration2 = start_time2.elapsed();
-
-    println!("Second optimized scan completed in: {:?}", scan_duration2);
-
-    // Second scan should be similar or faster due to caching
-    let performance_ratio = scan_duration2.as_millis() as f64 / scan_duration.as_millis() as f64;
-    println!("Performance ratio (second/first): {:.2}", performance_ratio);
-
-    // Clean up
-    let _ = std::fs::remove_dir_all(std::path::Path::new(TEST_DIR_PERF));
-}
-
-#[tokio::test(flavor = "multi_thread")]
-#[ignore = "Please run it manually."]
-#[serial]
-async fn test_optimized_load_balancing_and_throttling() {
-    let temp_dir = TempDir::new().unwrap();
-
-    // Create a node scanner with optimized configuration
-    let config = NodeScannerConfig {
-        data_dir: temp_dir.path().to_path_buf(),
-        enable_smart_scheduling: true,
-        scan_interval: Duration::from_millis(100), // Fast for testing
-        disk_scan_delay: Duration::from_millis(50),
-        ..Default::default()
-    };
-
-    let node_scanner = NodeScanner::new("test-optimized-node".to_string(), config);
-
-    // Initialize the scanner
-    node_scanner.initialize_stats().await.unwrap();
-
-    let io_monitor = node_scanner.get_io_monitor();
-    let throttler = node_scanner.get_io_throttler();
-
-    // Start IO monitoring
-    io_monitor.start().await.expect("Failed to start IO monitor");
-
-    // Test load balancing scenarios
-    let load_scenarios = vec![
-        (LoadLevel::Low, 10, 100, 0, 5), // (load level, latency, qps, error rate, connections)
-        (LoadLevel::Medium, 30, 300, 10, 20),
-        (LoadLevel::High, 80, 800, 50, 50),
-        (LoadLevel::Critical, 200, 1200, 100, 100),
-    ];
-
-    for (expected_level, latency, qps, error_rate, connections) in load_scenarios {
-        println!("Testing load scenario: {:?}", expected_level);
-
-        // Update business metrics to simulate load
-        node_scanner
-            .update_business_metrics(latency, qps, error_rate, connections)
-            .await;
-
-        // Wait for monitoring system to respond
-        tokio::time::sleep(Duration::from_millis(500)).await;
-
-        // Get current load level
-        let current_level = io_monitor.get_business_load_level().await;
-        println!("Detected load level: {:?}", current_level);
-
-        // Get throttling decision
-        let _current_metrics = io_monitor.get_current_metrics().await;
-        let metrics_snapshot = rustfs_ahm::scanner::io_throttler::MetricsSnapshot {
-            iops: 100 + qps / 10,
-            latency,
-            cpu_usage: std::cmp::min(50 + (qps / 20) as u8, 100),
-            memory_usage: 40,
-        };
-
-        let decision = throttler.make_throttle_decision(current_level, Some(metrics_snapshot)).await;
-
-        println!(
-            "Throttle decision: should_pause={}, delay={:?}",
-            decision.should_pause, decision.suggested_delay
-        );
-
-        // Verify throttling behavior
-        match current_level {
-            LoadLevel::Critical => {
-                assert!(decision.should_pause, "Critical load should trigger pause");
-            }
-            LoadLevel::High => {
-                assert!(
-                    decision.suggested_delay > Duration::from_millis(1000),
-                    "High load should suggest significant delay"
-                );
-            }
-            _ => {
-                // Lower loads should have reasonable delays
-                assert!(
-                    decision.suggested_delay < Duration::from_secs(5),
-                    "Lower loads should not have excessive delays"
-                );
-            }
-        }
-    }
-
-    io_monitor.stop().await;
-
-    println!("Optimized load balancing and throttling test completed successfully");
-}
-
-#[tokio::test(flavor = "multi_thread")]
-#[ignore = "Please run it manually."]
-#[serial]
-async fn test_optimized_scanner_detect_missing_data_parts() {
-    const TEST_DIR_MISSING_PARTS: &str = "/tmp/rustfs_ahm_optimized_test_missing_parts";
-    let (disk_paths, ecstore) = prepare_test_env(Some(TEST_DIR_MISSING_PARTS), Some(9105)).await;
-
-    // Create test bucket
-    let bucket_name = "test-bucket-parts-opt";
-    let object_name = "large-object-20mb-opt";
-
-    ecstore.make_bucket(bucket_name, &Default::default()).await.unwrap();
-
-    // Create a 20MB object to ensure it has multiple parts
-    let large_data = vec![b'A'; 20 * 1024 * 1024]; // 20MB of 'A' characters
-    let mut put_reader = PutObjReader::from_vec(large_data);
-    let object_opts = rustfs_ecstore::store_api::ObjectOptions::default();
-
-    println!("=== Creating 20MB object ===");
-    ecstore
-        .put_object(bucket_name, object_name, &mut put_reader, &object_opts)
-        .await
-        .expect("put_object failed for large object");
-
-    // Verify object was created and get its info
-    let obj_info = ecstore
-        .get_object_info(bucket_name, object_name, &object_opts)
-        .await
-        .expect("get_object_info failed");
-
-    println!(
-        "Object info: size={}, parts={}, inlined={}",
-        obj_info.size,
-        obj_info.parts.len(),
-        obj_info.inlined
-    );
-    assert!(!obj_info.inlined, "20MB object should not be inlined");
-    println!("Object has {} parts", obj_info.parts.len());
-
-    // Create HealManager and optimized Scanner
-    let heal_storage = Arc::new(rustfs_ahm::heal::storage::ECStoreHealStorage::new(ecstore.clone()));
-    let heal_config = HealConfig {
-        enable_auto_heal: true,
-        heal_interval: Duration::from_millis(100),
-        max_concurrent_heals: 4,
-        task_timeout: Duration::from_secs(300),
-        queue_size: 1000,
-    };
-    let heal_manager = Arc::new(rustfs_ahm::heal::HealManager::new(heal_storage, Some(heal_config)));
-    heal_manager.start().await.unwrap();
-    let scanner = Scanner::new(None, Some(heal_manager.clone()));
-
-    // Enable healing to detect missing parts
-    scanner.set_config_enable_healing(true).await;
-    scanner.set_config_scan_mode(ScanMode::Deep).await;
-
-    println!("=== Initial scan (all parts present) ===");
-    let initial_scan = scanner.scan_cycle().await;
-    assert!(initial_scan.is_ok(), "Initial scan should succeed");
-
-    let initial_metrics = scanner.get_metrics().await;
-    println!("Initial scan metrics: objects_scanned={}", initial_metrics.objects_scanned);
-
-    // Simulate data part loss by deleting part files from some disks
-    println!("=== Simulating data part loss ===");
-    let mut deleted_parts = 0;
-    let mut deleted_part_paths = Vec::new();
-
-    for (disk_idx, disk_path) in disk_paths.iter().enumerate() {
-        if disk_idx > 0 {
-            // Only delete from first disk
-            break;
-        }
-        let bucket_path = disk_path.join(bucket_name);
-        let object_path = bucket_path.join(object_name);
-
-        if !object_path.exists() {
-            continue;
-        }
-
-        // Find the data directory (UUID)
-        if let Ok(entries) = fs::read_dir(&object_path) {
-            for entry in entries.flatten() {
-                let entry_path = entry.path();
-                if entry_path.is_dir() {
-                    // This is likely the data_dir, look for part files inside
-                    let part_file_path = entry_path.join("part.1");
-                    if part_file_path.exists() {
-                        match fs::remove_file(&part_file_path) {
-                            Ok(_) => {
-                                println!("Deleted part file: {part_file_path:?}");
-                                deleted_part_paths.push(part_file_path);
-                                deleted_parts += 1;
-                            }
-                            Err(e) => {
-                                println!("Failed to delete part file {part_file_path:?}: {e}");
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    println!("Deleted {deleted_parts} part files to simulate data loss");
-
-    // Scan again to detect missing parts
-    println!("=== Scan after data deletion (should detect missing data) ===");
-    let scan_after_deletion = scanner.scan_cycle().await;
-
-    // Wait a bit for the heal manager to process
-    tokio::time::sleep(Duration::from_millis(500)).await;
-
-    // Check heal statistics
-    let heal_stats = heal_manager.get_statistics().await;
-    println!("Heal statistics:");
-    println!("  - total_tasks: {}", heal_stats.total_tasks);
-    println!("  - successful_tasks: {}", heal_stats.successful_tasks);
-    println!("  - failed_tasks: {}", heal_stats.failed_tasks);
-
-    // Get scanner metrics
-    let final_metrics = scanner.get_metrics().await;
-    println!("Scanner metrics after deletion scan:");
-    println!("  - objects_scanned: {}", final_metrics.objects_scanned);
-
-    // The optimized scanner should handle missing data gracefully
-    match scan_after_deletion {
-        Ok(_) => {
-            println!("Optimized scanner completed successfully despite missing data");
-        }
-        Err(e) => {
-            println!("Optimized scanner detected errors (acceptable): {e}");
-        }
-    }
-
-    println!("=== Test completed ===");
-    println!("Optimized scanner successfully handled missing data scenario");
-
-    // Clean up
-    let _ = std::fs::remove_dir_all(std::path::Path::new(TEST_DIR_MISSING_PARTS));
-}
-
-#[tokio::test(flavor = "multi_thread")]
-#[ignore = "Please run it manually."]
-#[serial]
-async fn test_optimized_scanner_detect_missing_xl_meta() {
-    const TEST_DIR_MISSING_META: &str = "/tmp/rustfs_ahm_optimized_test_missing_meta";
-    let (disk_paths, ecstore) = prepare_test_env(Some(TEST_DIR_MISSING_META), Some(9106)).await;
-
-    // Create test bucket
-    let bucket_name = "test-bucket-meta-opt";
-    let object_name = "test-object-meta-opt";
-
-    ecstore.make_bucket(bucket_name, &Default::default()).await.unwrap();
-
-    // Create a test object
-    let test_data = vec![b'B'; 5 * 1024 * 1024]; // 5MB of 'B' characters
-    let mut put_reader = PutObjReader::from_vec(test_data);
-    let object_opts = rustfs_ecstore::store_api::ObjectOptions::default();
-
-    println!("=== Creating test object ===");
-    ecstore
-        .put_object(bucket_name, object_name, &mut put_reader, &object_opts)
-        .await
-        .expect("put_object failed");
-
-    // Create HealManager and optimized Scanner
-    let heal_storage = Arc::new(rustfs_ahm::heal::storage::ECStoreHealStorage::new(ecstore.clone()));
-    let heal_config = HealConfig {
-        enable_auto_heal: true,
-        heal_interval: Duration::from_millis(100),
-        max_concurrent_heals: 4,
-        task_timeout: Duration::from_secs(300),
-        queue_size: 1000,
-    };
-    let heal_manager = Arc::new(rustfs_ahm::heal::HealManager::new(heal_storage, Some(heal_config)));
-    heal_manager.start().await.unwrap();
-    let scanner = Scanner::new(None, Some(heal_manager.clone()));
-
-    // Enable healing to detect missing metadata
-    scanner.set_config_enable_healing(true).await;
-    scanner.set_config_scan_mode(ScanMode::Deep).await;
-
-    println!("=== Initial scan (all metadata present) ===");
-    let initial_scan = scanner.scan_cycle().await;
-    assert!(initial_scan.is_ok(), "Initial scan should succeed");
-
-    // Simulate xl.meta file loss by deleting xl.meta files from some disks
-    println!("=== Simulating xl.meta file loss ===");
-    let mut deleted_meta_files = 0;
-    let mut deleted_meta_paths = Vec::new();
-
-    for (disk_idx, disk_path) in disk_paths.iter().enumerate() {
-        if disk_idx >= 2 {
-            // Only delete from first two disks to ensure some copies remain
-            break;
-        }
-        let bucket_path = disk_path.join(bucket_name);
-        let object_path = bucket_path.join(object_name);
-
-        if !object_path.exists() {
-            continue;
-        }
-
-        // Delete xl.meta file
-        let xl_meta_path = object_path.join("xl.meta");
-        if xl_meta_path.exists() {
-            match fs::remove_file(&xl_meta_path) {
-                Ok(_) => {
-                    println!("Deleted xl.meta file: {xl_meta_path:?}");
-                    deleted_meta_paths.push(xl_meta_path);
-                    deleted_meta_files += 1;
-                }
-                Err(e) => {
-                    println!("Failed to delete xl.meta file {xl_meta_path:?}: {e}");
-                }
-            }
-        }
-    }
-
-    println!("Deleted {deleted_meta_files} xl.meta files to simulate metadata loss");
-
-    // Scan again to detect missing metadata
-    println!("=== Scan after xl.meta deletion ===");
-    let scan_after_deletion = scanner.scan_cycle().await;
-
-    // Wait for heal manager to process
-    tokio::time::sleep(Duration::from_millis(1000)).await;
-
-    // Check heal statistics
-    let final_heal_stats = heal_manager.get_statistics().await;
-    println!("Final heal statistics:");
-    println!("  - total_tasks: {}", final_heal_stats.total_tasks);
-    println!("  - successful_tasks: {}", final_heal_stats.successful_tasks);
-    println!("  - failed_tasks: {}", final_heal_stats.failed_tasks);
-    let _ = final_heal_stats; // Use the variable to avoid unused warning
-
-    // The optimized scanner should handle missing metadata gracefully
-    match scan_after_deletion {
-        Ok(_) => {
-            println!("Optimized scanner completed successfully despite missing metadata");
-        }
-        Err(e) => {
-            println!("Optimized scanner detected errors (acceptable): {e}");
-        }
-    }
-
-    println!("=== Test completed ===");
-    println!("Optimized scanner successfully handled missing xl.meta scenario");
-
-    // Clean up
-    let _ = std::fs::remove_dir_all(std::path::Path::new(TEST_DIR_MISSING_META));
-}
-
-#[tokio::test(flavor = "multi_thread")]
-#[ignore = "Please run it manually."]
-#[serial]
-async fn test_optimized_scanner_healthy_objects_not_marked_corrupted() {
-    const TEST_DIR_HEALTHY: &str = "/tmp/rustfs_ahm_optimized_test_healthy_objects";
-    let (_, ecstore) = prepare_test_env(Some(TEST_DIR_HEALTHY), Some(9107)).await;
-
-    // Create heal manager for this test
-    let heal_config = HealConfig::default();
-    let heal_storage = Arc::new(rustfs_ahm::heal::storage::ECStoreHealStorage::new(ecstore.clone()));
-    let heal_manager = Arc::new(rustfs_ahm::heal::manager::HealManager::new(heal_storage, Some(heal_config)));
-    heal_manager.start().await.unwrap();
-
-    // Create optimized scanner with healing enabled
-    let scanner = Scanner::new(None, Some(heal_manager.clone()));
-    scanner.set_config_enable_healing(true).await;
-    scanner.set_config_scan_mode(ScanMode::Deep).await;
-
-    // Create test bucket and multiple healthy objects
-    let bucket_name = "healthy-test-bucket-opt";
-    let bucket_opts = MakeBucketOptions::default();
-    ecstore.make_bucket(bucket_name, &bucket_opts).await.unwrap();
-
-    // Create multiple test objects with different sizes
-    let test_objects = vec![
-        ("small-object-opt", b"Small test data optimized".to_vec()),
-        ("medium-object-opt", vec![42u8; 1024]),  // 1KB
-        ("large-object-opt", vec![123u8; 10240]), // 10KB
-    ];
-
-    let object_opts = rustfs_ecstore::store_api::ObjectOptions::default();
-
-    // Write all test objects
-    for (object_name, test_data) in &test_objects {
-        let mut put_reader = PutObjReader::from_vec(test_data.clone());
-        ecstore
-            .put_object(bucket_name, object_name, &mut put_reader, &object_opts)
-            .await
-            .expect("Failed to put test object");
-        println!("Created test object: {object_name} (size: {} bytes)", test_data.len());
-    }
-
-    // Wait a moment for objects to be fully written
-    tokio::time::sleep(Duration::from_millis(100)).await;
-
-    // Get initial heal statistics
-    let initial_heal_stats = heal_manager.get_statistics().await;
-    println!("Initial heal statistics:");
-    println!("  - total_tasks: {}", initial_heal_stats.total_tasks);
-
-    // Perform initial scan on healthy objects
-    println!("=== Scanning healthy objects ===");
-    let scan_result = scanner.scan_cycle().await;
-    assert!(scan_result.is_ok(), "Scan of healthy objects should succeed");
-
-    // Wait for any potential heal tasks to be processed
-    tokio::time::sleep(Duration::from_millis(1000)).await;
-
-    // Get scanner metrics after scanning
-    let metrics = scanner.get_metrics().await;
-    println!("Optimized scanner metrics after scanning healthy objects:");
-    println!("  - objects_scanned: {}", metrics.objects_scanned);
-    println!("  - healthy_objects: {}", metrics.healthy_objects);
-    println!("  - corrupted_objects: {}", metrics.corrupted_objects);
-
-    // Get heal statistics after scanning
-    let post_scan_heal_stats = heal_manager.get_statistics().await;
-    println!("Heal statistics after scanning healthy objects:");
-    println!("  - total_tasks: {}", post_scan_heal_stats.total_tasks);
-    println!("  - successful_tasks: {}", post_scan_heal_stats.successful_tasks);
-    println!("  - failed_tasks: {}", post_scan_heal_stats.failed_tasks);
-
-    // Critical assertion: healthy objects should not trigger unnecessary heal tasks
-    let heal_tasks_created = post_scan_heal_stats.total_tasks - initial_heal_stats.total_tasks;
-    if heal_tasks_created > 0 {
-        println!("WARNING: {heal_tasks_created} heal tasks were created for healthy objects");
-        // For optimized scanner, we're more lenient as it may work differently
-        println!("Note: Optimized scanner may have different behavior than legacy scanner");
-    } else {
-        println!("✓ No heal tasks created for healthy objects - optimized scanner working correctly");
-    }
-
-    // Perform a second scan to ensure consistency
-    println!("=== Second scan to verify consistency ===");
-    let second_scan_result = scanner.scan_cycle().await;
-    assert!(second_scan_result.is_ok(), "Second scan should also succeed");
-
-    let second_metrics = scanner.get_metrics().await;
-    let _final_heal_stats = heal_manager.get_statistics().await;
-
-    println!("Second scan metrics:");
-    println!("  - objects_scanned: {}", second_metrics.objects_scanned);
-
-    println!("=== Test completed successfully ===");
-    println!("✓ Optimized scanner handled healthy objects correctly");
-    println!("✓ No false positive corruption detection");
-    println!("✓ Objects remain accessible after scanning");
-
-    // Clean up
-    let _ = std::fs::remove_dir_all(std::path::Path::new(TEST_DIR_HEALTHY));
-}

crates/ahm/tests/scanner_optimization_tests.rs

@@ -1,381 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::time::Duration;
-use tempfile::TempDir;
-
-use rustfs_ahm::scanner::{
-    checkpoint::{CheckpointData, CheckpointManager},
-    io_monitor::{AdvancedIOMonitor, IOMonitorConfig},
-    io_throttler::{AdvancedIOThrottler, IOThrottlerConfig},
-    local_stats::LocalStatsManager,
-    node_scanner::{LoadLevel, NodeScanner, NodeScannerConfig, ScanProgress},
-    stats_aggregator::{DecentralizedStatsAggregator, DecentralizedStatsAggregatorConfig},
-};
-
-#[tokio::test]
-async fn test_checkpoint_manager_save_and_load() {
-    let temp_dir = TempDir::new().unwrap();
-    let node_id = "test-node-1";
-    let checkpoint_manager = CheckpointManager::new(node_id, temp_dir.path());
-
-    // create checkpoint
-    let progress = ScanProgress {
-        current_cycle: 5,
-        current_disk_index: 2,
-        last_scan_key: Some("test-object-key".to_string()),
-        ..Default::default()
-    };
-
-    // save checkpoint
-    checkpoint_manager
-        .force_save_checkpoint(&progress)
-        .await
-        .expect("Failed to save checkpoint");
-
-    // load checkpoint
-    let loaded_progress = checkpoint_manager
-        .load_checkpoint()
-        .await
-        .expect("Failed to load checkpoint")
-        .expect("No checkpoint found");
-
-    // verify data
-    assert_eq!(loaded_progress.current_cycle, 5);
-    assert_eq!(loaded_progress.current_disk_index, 2);
-    assert_eq!(loaded_progress.last_scan_key, Some("test-object-key".to_string()));
-}
-
-#[tokio::test]
-async fn test_checkpoint_data_integrity() {
-    let temp_dir = TempDir::new().unwrap();
-    let node_id = "test-node-integrity";
-    let checkpoint_manager = CheckpointManager::new(node_id, temp_dir.path());
-
-    let progress = ScanProgress::default();
-
-    // create checkpoint data
-    let checkpoint_data = CheckpointData::new(progress.clone(), node_id.to_string());
-
-    // verify integrity
-    assert!(checkpoint_data.verify_integrity());
-
-    // save and load
-    checkpoint_manager
-        .force_save_checkpoint(&progress)
-        .await
-        .expect("Failed to save checkpoint");
-
-    let loaded = checkpoint_manager.load_checkpoint().await.expect("Failed to load checkpoint");
-
-    assert!(loaded.is_some());
-}
-
-#[tokio::test]
-async fn test_local_stats_manager() {
-    let temp_dir = TempDir::new().unwrap();
-    let node_id = "test-stats-node";
-    let stats_manager = LocalStatsManager::new(node_id, temp_dir.path());
-
-    // load stats
-    stats_manager.load_stats().await.expect("Failed to load stats");
-
-    // get stats summary
-    let summary = stats_manager.get_stats_summary().await;
-    assert_eq!(summary.node_id, node_id);
-    assert_eq!(summary.total_objects_scanned, 0);
-
-    // record heal triggered
-    stats_manager
-        .record_heal_triggered("test-object", "corruption detected")
-        .await;
-
-    let counters = stats_manager.get_counters();
-    assert_eq!(counters.total_heal_triggered.load(std::sync::atomic::Ordering::Relaxed), 1);
-}
-
-#[tokio::test]
-async fn test_io_monitor_load_level_calculation() {
-    let config = IOMonitorConfig {
-        enable_system_monitoring: false, // use mock data
-        ..Default::default()
-    };
-
-    let io_monitor = AdvancedIOMonitor::new(config);
-    io_monitor.start().await.expect("Failed to start IO monitor");
-
-    // update business metrics to affect load calculation
-    io_monitor.update_business_metrics(50, 100, 0, 10).await;
-
-    // wait for a monitoring cycle
-    tokio::time::sleep(Duration::from_millis(1500)).await;
-
-    let load_level = io_monitor.get_business_load_level().await;
-
-    // load level should be in a reasonable range
-    assert!(matches!(
-        load_level,
-        LoadLevel::Low | LoadLevel::Medium | LoadLevel::High | LoadLevel::Critical
-    ));
-
-    io_monitor.stop().await;
-}
-
-#[tokio::test]
-async fn test_io_throttler_load_adjustment() {
-    let config = IOThrottlerConfig::default();
-    let throttler = AdvancedIOThrottler::new(config);
-
-    // test adjust for load level
-    let low_delay = throttler.adjust_for_load_level(LoadLevel::Low).await;
-    let medium_delay = throttler.adjust_for_load_level(LoadLevel::Medium).await;
-    let high_delay = throttler.adjust_for_load_level(LoadLevel::High).await;
-    let critical_delay = throttler.adjust_for_load_level(LoadLevel::Critical).await;
-
-    // verify delay increment
-    assert!(low_delay < medium_delay);
-    assert!(medium_delay < high_delay);
-    assert!(high_delay < critical_delay);
-
-    // verify pause logic
-    assert!(!throttler.should_pause_scanning(LoadLevel::Low).await);
-    assert!(!throttler.should_pause_scanning(LoadLevel::Medium).await);
-    assert!(!throttler.should_pause_scanning(LoadLevel::High).await);
-    assert!(throttler.should_pause_scanning(LoadLevel::Critical).await);
-}
-
-#[tokio::test]
-async fn test_throttler_business_pressure_simulation() {
-    let throttler = AdvancedIOThrottler::default();
-
-    // run short time pressure test
-    let simulation_duration = Duration::from_millis(500);
-    let result = throttler.simulate_business_pressure(simulation_duration).await;
-
-    // verify simulation result
-    assert!(!result.simulation_records.is_empty());
-    assert!(result.total_duration >= simulation_duration);
-    assert!(result.final_stats.total_decisions > 0);
-
-    // verify all load levels are tested
-    let load_levels: std::collections::HashSet<_> = result.simulation_records.iter().map(|r| r.load_level).collect();
-
-    assert!(load_levels.contains(&LoadLevel::Low));
-    assert!(load_levels.contains(&LoadLevel::Critical));
-}
-
-#[tokio::test]
-async fn test_node_scanner_creation_and_config() {
-    let temp_dir = TempDir::new().unwrap();
-    let node_id = "test-scanner-node".to_string();
-
-    let config = NodeScannerConfig {
-        scan_interval: Duration::from_secs(30),
-        disk_scan_delay: Duration::from_secs(5),
-        enable_smart_scheduling: true,
-        enable_checkpoint: true,
-        data_dir: temp_dir.path().to_path_buf(),
-        ..Default::default()
-    };
-
-    let scanner = NodeScanner::new(node_id.clone(), config);
-
-    // verify node id
-    assert_eq!(scanner.node_id(), &node_id);
-
-    // initialize stats
-    scanner.initialize_stats().await.expect("Failed to initialize stats");
-
-    // get stats summary
-    let summary = scanner.get_stats_summary().await;
-    assert_eq!(summary.node_id, node_id);
-}
-
-#[tokio::test]
-async fn test_decentralized_stats_aggregator() {
-    let config = DecentralizedStatsAggregatorConfig {
-        cache_ttl: Duration::from_millis(100), // short cache ttl for testing
-        ..Default::default()
-    };
-
-    let aggregator = DecentralizedStatsAggregator::new(config);
-
-    // test cache mechanism
-    let _start_time = std::time::Instant::now();
-
-    // first get stats (should trigger aggregation)
-    let stats1 = aggregator
-        .get_aggregated_stats()
-        .await
-        .expect("Failed to get aggregated stats");
-
-    let first_call_duration = _start_time.elapsed();
-
-    // second get stats (should use cache)
-    let cache_start = std::time::Instant::now();
-    let stats2 = aggregator.get_aggregated_stats().await.expect("Failed to get cached stats");
-
-    let cache_call_duration = cache_start.elapsed();
-
-    // cache call should be faster
-    assert!(cache_call_duration < first_call_duration);
-
-    // data should be same
-    assert_eq!(stats1.aggregation_timestamp, stats2.aggregation_timestamp);
-
-    // wait for cache expiration
-    tokio::time::sleep(Duration::from_millis(150)).await;
-
-    // third get should refresh data
-    let stats3 = aggregator
-        .get_aggregated_stats()
-        .await
-        .expect("Failed to get refreshed stats");
-
-    // timestamp should be different
-    assert!(stats3.aggregation_timestamp > stats1.aggregation_timestamp);
-}
-
-#[tokio::test]
-async fn test_scanner_performance_impact() {
-    let temp_dir = TempDir::new().unwrap();
-    let node_id = "performance-test-node".to_string();
-
-    let config = NodeScannerConfig {
-        scan_interval: Duration::from_millis(100), // fast scan for testing
-        disk_scan_delay: Duration::from_millis(10),
-        data_dir: temp_dir.path().to_path_buf(),
-        ..Default::default()
-    };
-
-    let scanner = NodeScanner::new(node_id, config);
-
-    // simulate business workload
-    let _start_time = std::time::Instant::now();
-
-    // update business metrics for high load
-    scanner.update_business_metrics(1500, 3000, 500, 800).await;
-
-    // get io monitor and throttler
-    let io_monitor = scanner.get_io_monitor();
-    let throttler = scanner.get_io_throttler();
-
-    // start io monitor
-    io_monitor.start().await.expect("Failed to start IO monitor");
-
-    // wait for monitor system to stabilize and trigger throttling - increase wait time
-    tokio::time::sleep(Duration::from_millis(1000)).await;
-
-    // simulate some io operations to trigger throttling mechanism
-    for _ in 0..10 {
-        let _current_metrics = io_monitor.get_current_metrics().await;
-        let metrics_snapshot = rustfs_ahm::scanner::io_throttler::MetricsSnapshot {
-            iops: 1000,
-            latency: 100,
-            cpu_usage: 80,
-            memory_usage: 70,
-        };
-        let load_level = io_monitor.get_business_load_level().await;
-        let _decision = throttler.make_throttle_decision(load_level, Some(metrics_snapshot)).await;
-        tokio::time::sleep(Duration::from_millis(50)).await;
-    }
-
-    // check if load level is correctly responded
-    let load_level = io_monitor.get_business_load_level().await;
-
-    // in high load, scanner should automatically adjust
-    let throttle_stats = throttler.get_throttle_stats().await;
-
-    println!("Performance test results:");
-    println!("  Load level: {:?}", load_level);
-    println!("  Throttle decisions: {}", throttle_stats.total_decisions);
-    println!("  Average delay: {:?}", throttle_stats.average_delay);
-
-    // verify performance impact control - if load is high enough, there should be throttling delay
-    if load_level != LoadLevel::Low {
-        assert!(throttle_stats.average_delay > Duration::from_millis(0));
-    } else {
-        // in low load, there should be no throttling delay
-        assert!(throttle_stats.average_delay >= Duration::from_millis(0));
-    }
-
-    io_monitor.stop().await;
-}
-
-#[tokio::test]
-async fn test_checkpoint_recovery_resilience() {
-    let temp_dir = TempDir::new().unwrap();
-    let node_id = "resilience-test-node";
-    let checkpoint_manager = CheckpointManager::new(node_id, temp_dir.path());
-
-    // verify checkpoint manager
-    let result = checkpoint_manager.load_checkpoint().await.unwrap();
-    assert!(result.is_none());
-
-    // create and save checkpoint
-    let progress = ScanProgress {
-        current_cycle: 10,
-        current_disk_index: 3,
-        last_scan_key: Some("recovery-test-key".to_string()),
-        ..Default::default()
-    };
-
-    checkpoint_manager
-        .force_save_checkpoint(&progress)
-        .await
-        .expect("Failed to save checkpoint");
-
-    // verify recovery
-    let recovered = checkpoint_manager
-        .load_checkpoint()
-        .await
-        .expect("Failed to load checkpoint")
-        .expect("No checkpoint recovered");
-
-    assert_eq!(recovered.current_cycle, 10);
-    assert_eq!(recovered.current_disk_index, 3);
-
-    // cleanup checkpoint
-    checkpoint_manager
-        .cleanup_checkpoint()
-        .await
-        .expect("Failed to cleanup checkpoint");
-
-    // verify cleanup
-    let after_cleanup = checkpoint_manager.load_checkpoint().await.unwrap();
-    assert!(after_cleanup.is_none());
-}
-
-pub async fn create_test_scanner(temp_dir: &TempDir) -> NodeScanner {
-    let config = NodeScannerConfig {
-        scan_interval: Duration::from_millis(50),
-        disk_scan_delay: Duration::from_millis(10),
-        data_dir: temp_dir.path().to_path_buf(),
-        ..Default::default()
-    };
-
-    NodeScanner::new("integration-test-node".to_string(), config)
-}
-
-pub struct PerformanceBenchmark {
-    pub _scanner_overhead_ms: u64,
-    pub business_impact_percentage: f64,
-    pub _throttle_effectiveness: f64,
-}
-
-impl PerformanceBenchmark {
-    pub fn meets_optimization_goals(&self) -> bool {
-        self.business_impact_percentage < 10.0
-    }
-}

crates/appauth/Cargo.toml

@@ -1,34 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-[package]
-name = "rustfs-appauth"
-edition.workspace = true
-license.workspace = true
-repository.workspace = true
-rust-version.workspace = true
-version.workspace = true
-homepage.workspace = true
-description = "Application authentication and authorization for RustFS, providing secure access control and user management."
-keywords = ["authentication", "authorization", "security", "rustfs", "Minio"]
-categories = ["web-programming", "development-tools", "authentication"]
-
-[dependencies]
-base64-simd = { workspace = true }
-rsa = { workspace = true }
-serde.workspace = true
-serde_json.workspace = true
-
-[lints]
-workspace = true

crates/appauth/README.md

@@ -1,37 +0,0 @@
-[![RustFS](https://rustfs.com/images/rustfs-github.png)](https://rustfs.com)
-
-# RustFS AppAuth - Application Authentication
-
-<p align="center">
-  <strong>Application-level authentication and authorization module for RustFS distributed object storage</strong>
-</p>
-
-<p align="center">
-  <a href="https://github.com/rustfs/rustfs/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/rustfs/rustfs/actions/workflows/ci.yml/badge.svg" /></a>
-  <a href="https://docs.rustfs.com/en/">📖 Documentation</a>
-  · <a href="https://github.com/rustfs/rustfs/issues">🐛 Bug Reports</a>
-  · <a href="https://github.com/rustfs/rustfs/discussions">💬 Discussions</a>
-</p>
-
----
-
-## 📖 Overview
-
-**RustFS AppAuth** provides application-level authentication and authorization capabilities for the [RustFS](https://rustfs.com) distributed object storage system. For the complete RustFS experience, please visit the [main RustFS repository](https://github.com/rustfs/rustfs).
-
-## ✨ Features
-
-- JWT-based authentication with secure token management
-- RBAC (Role-Based Access Control) for fine-grained permissions
-- Multi-tenant application isolation and management
-- OAuth 2.0 and OpenID Connect integration
-- API key management and rotation
-- Session management with configurable expiration
-
-## 📚 Documentation
-
-For comprehensive documentation, examples, and usage guides, please visit the main [RustFS repository](https://github.com/rustfs/rustfs).
-
-## 📄 License
-
-This project is licensed under the Apache License 2.0 - see the [LICENSE](../../LICENSE) file for details.

crates/appauth/src/lib.rs

@@ -1,15 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-pub mod token;

crates/appauth/src/token.rs

@@ -1,127 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use rsa::Pkcs1v15Encrypt;
-use rsa::{
-    RsaPrivateKey, RsaPublicKey,
-    pkcs8::{DecodePrivateKey, DecodePublicKey},
-    rand_core::OsRng,
-};
-use serde::{Deserialize, Serialize};
-use std::io::{Error, Result};
-
-#[derive(Serialize, Deserialize, Debug, Default, Clone)]
-pub struct Token {
-    pub name: String, // Application ID
-    pub expired: u64, // Expiry time (UNIX timestamp)
-}
-
-/// Public key generation Token
-/// [token] Token object
-/// [key] Public key string
-/// Returns the encrypted string processed by base64
-pub fn gencode(token: &Token, key: &str) -> Result<String> {
-    let data = serde_json::to_vec(token)?;
-    let public_key = RsaPublicKey::from_public_key_pem(key).map_err(Error::other)?;
-    let encrypted_data = public_key.encrypt(&mut OsRng, Pkcs1v15Encrypt, &data).map_err(Error::other)?;
-    Ok(base64_simd::URL_SAFE_NO_PAD.encode_to_string(&encrypted_data))
-}
-
-/// Private key resolution Token
-/// [token] Encrypted string processed by base64
-/// [key] Private key string
-/// Return to the Token object
-pub fn parse(token: &str, key: &str) -> Result<Token> {
-    let encrypted_data = base64_simd::URL_SAFE_NO_PAD
-        .decode_to_vec(token.as_bytes())
-        .map_err(Error::other)?;
-    let private_key = RsaPrivateKey::from_pkcs8_pem(key).map_err(Error::other)?;
-    let decrypted_data = private_key.decrypt(Pkcs1v15Encrypt, &encrypted_data).map_err(Error::other)?;
-    let res: Token = serde_json::from_slice(&decrypted_data)?;
-    Ok(res)
-}
-
-pub fn parse_license(license: &str) -> Result<Token> {
-    parse(license, TEST_PRIVATE_KEY)
-    // match parse(license, TEST_PRIVATE_KEY) {
-    //     Ok(token) => {
-    //         if token.expired > SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs() {
-    //             Ok(token)
-    //         } else {
-    //             Err("Token expired".into())
-    //         }
-    //     }
-    //     Err(e) => Err(e),
-    // }
-}
-
-static TEST_PRIVATE_KEY: &str = "-----BEGIN PRIVATE KEY-----\nMIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCj86SrJIuxSxR6\nBJ/dlJEUIj6NeBRnhLQlCDdovuz61+7kJXVcxaR66w4m8W7SLEUP+IlPtnn6vmiG\n7XMhGNHIr7r1JsEVVLhZmL3tKI66DEZl786ZhG81BWqUlmcooIPS8UEPZNqJXLuz\nVGhxNyVGbj/tV7QC2pSISnKaixc+nrhxvo7w56p5qrm9tik0PjTgfZsUePkoBsSN\npoRkAauS14MAzK6HGB75CzG3dZqXUNWSWVocoWtQbZUwFGXyzU01ammsHQDvc2xu\nK1RQpd1qYH5bOWZ0N0aPFwT0r59HztFXg9sbjsnuhO1A7OiUOkc6iGVuJ0wm/9nA\nwZIBqzgjAgMBAAECggEAPMpeSEbotPhNw2BrllE76ec4omPfzPJbiU+em+wPGoNu\nRJHPDnMKJbl6Kd5jZPKdOOrCnxfd6qcnQsBQa/kz7+GYxMV12l7ra+1Cnujm4v0i\nLTHZvPpp8ZLsjeOmpF3AAzsJEJgon74OqtOlVjVIUPEYKvzV9ijt4gsYq0zfdYv0\nhrTMzyrGM4/UvKLsFIBROAfCeWfA7sXLGH8JhrRAyDrtCPzGtyyAmzoHKHtHafcB\nuyPFw/IP8otAgpDk5iiQPNkH0WwzAQIm12oHuNUa66NwUK4WEjXTnDg8KeWLHHNv\nIfN8vdbZchMUpMIvvkr7is315d8f2cHCB5gEO+GWAQKBgQDR/0xNll+FYaiUKCPZ\nvkOCAd3l5mRhsqnjPQ/6Ul1lAyYWpoJSFMrGGn/WKTa/FVFJRTGbBjwP+Mx10bfb\ngUg2GILDTISUh54fp4zngvTi9w4MWGKXrb7I1jPkM3vbJfC/v2fraQ/r7qHPpO2L\nf6ZbGxasIlSvr37KeGoelwcAQQKBgQDH3hmOTS2Hl6D4EXdq5meHKrfeoicGN7m8\noQK7u8iwn1R9zK5nh6IXxBhKYNXNwdCQtBZVRvFjjZ56SZJb7lKqa1BcTsgJfZCy\nnI3Uu4UykrECAH8AVCVqBXUDJmeA2yE+gDAtYEjvhSDHpUfWxoGHr0B/Oqk2Lxc/\npRy1qV5fYwKBgBWSL/hYVf+RhIuTg/s9/BlCr9SJ0g3nGGRrRVTlWQqjRCpXeFOO\nJzYqSq9pFGKUggEQxoOyJEFPwVDo9gXqRcyov+Xn2kaXl7qQr3yoixc1YZALFDWY\nd1ySBEqQr0xXnV9U/gvEgwotPRnjSzNlLWV2ZuHPtPtG/7M0o1H5GZMBAoGAKr3N\nW0gX53o+my4pCnxRQW+aOIsWq1a5aqRIEFudFGBOUkS2Oz+fI1P1GdrRfhnnfzpz\n2DK+plp/vIkFOpGhrf4bBlJ2psjqa7fdANRFLMaAAfyXLDvScHTQTCcnVUAHQPVq\n2BlSH56pnugyj7SNuLV6pnql+wdhAmRN2m9o1h8CgYAbX2juSr4ioXwnYjOUdrIY\n4+ERvHcXdjoJmmPcAm4y5NbSqLXyU0FQmplNMt2A5LlniWVJ9KNdjAQUt60FZw/+\nr76LdxXaHNZghyx0BOs7mtq5unSQXamZ8KixasfhE9uz3ij1jXjG6hafWkS8/68I\nuWbaZqgvy7a9oPHYlKH7Jg==\n-----END PRIVATE KEY-----\n";
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use rsa::{
-        RsaPrivateKey,
-        pkcs8::{EncodePrivateKey, EncodePublicKey, LineEnding},
-    };
-    use std::time::{SystemTime, UNIX_EPOCH};
-    #[test]
-    fn test_gencode_and_parse() {
-        let mut rng = OsRng;
-        let bits = 2048;
-        let private_key = RsaPrivateKey::new(&mut rng, bits).expect("Failed to generate private key");
-        let public_key = RsaPublicKey::from(&private_key);
-
-        let private_key_pem = private_key.to_pkcs8_pem(LineEnding::LF).unwrap();
-        let public_key_pem = public_key.to_public_key_pem(LineEnding::LF).unwrap();
-
-        let token = Token {
-            name: "test_app".to_string(),
-            expired: SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs() + 3600, // 1 hour from now
-        };
-
-        let encoded = gencode(&token, &public_key_pem).expect("Failed to encode token");
-
-        let decoded = parse(&encoded, &private_key_pem).expect("Failed to decode token");
-
-        assert_eq!(token.name, decoded.name);
-        assert_eq!(token.expired, decoded.expired);
-    }
-
-    #[test]
-    fn test_parse_invalid_token() {
-        let private_key_pem = RsaPrivateKey::new(&mut OsRng, 2048)
-            .expect("Failed to generate private key")
-            .to_pkcs8_pem(LineEnding::LF)
-            .unwrap();
-
-        let invalid_token = "invalid_base64_token";
-        let result = parse(invalid_token, &private_key_pem);
-
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn test_gencode_with_invalid_key() {
-        let token = Token {
-            name: "test_app".to_string(),
-            expired: SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs() + 3600, // 1 hour from now
-        };
-
-        let invalid_key = "invalid_public_key";
-        let result = gencode(&token, invalid_key);
-
-        assert!(result.is_err());
-    }
-}

crates/audit-logger/Cargo.toml

@@ -1,44 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-[package]
-name = "rustfs-audit-logger"
-edition.workspace = true
-license.workspace = true
-repository.workspace = true
-rust-version.workspace = true
-version.workspace = true
-homepage.workspace = true
-description = "Audit logging system for RustFS, providing detailed logging of file operations and system events."
-documentation = "https://docs.rs/audit-logger/latest/audit_logger/"
-keywords = ["audit", "logging", "file-operations", "system-events", "RustFS"]
-categories = ["web-programming", "development-tools::profiling", "asynchronous", "api-bindings", "development-tools::debugging"]
-
-[dependencies]
-rustfs-targets = { workspace = true }
-async-trait = { workspace = true }
-chrono = { workspace = true }
-reqwest = { workspace = true }
-serde = { workspace = true }
-serde_json = { workspace = true }
-tracing = { workspace = true, features = ["std", "attributes"] }
-tracing-core = { workspace = true }
-tokio = { workspace = true, features = ["sync", "fs", "rt-multi-thread", "rt", "time", "macros"] }
-url = { workspace = true }
-uuid = { workspace = true }
-thiserror = { workspace = true }
-figment = { version = "0.10", features = ["json", "env"] }
-
-[lints]
-workspace = true

crates/audit-logger/examples/config.json

@@ -1,34 +0,0 @@
-{
-  "console": {
-    "enabled": true
-  },
-  "logger_webhook": {
-    "default": {
-      "enabled": true,
-      "endpoint": "http://localhost:3000/logs",
-      "auth_token": "secret-token-for-logs",
-      "batch_size": 5,
-      "queue_size": 1000,
-      "max_retry": 3,
-      "retry_interval": "2s"
-    }
-  },
-  "audit_webhook": {
-    "splunk": {
-      "enabled": true,
-      "endpoint": "http://localhost:3000/audit",
-      "auth_token": "secret-token-for-audit",
-      "batch_size": 10
-    }
-  },
-  "audit_kafka": {
-    "default": {
-      "enabled": false,
-      "brokers": [
-        "kafka1:9092",
-        "kafka2:9092"
-      ],
-      "topic": "minio-audit-events"
-    }
-  }
-}

crates/audit-logger/examples/main.rs

@@ -1,17 +0,0 @@
-//  Copyright 2024 RustFS Team
-//
-//  Licensed under the Apache License, Version 2.0 (the "License");
-//  you may not use this file except in compliance with the License.
-//  You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-//  Unless required by applicable law or agreed to in writing, software
-//  distributed under the License is distributed on an "AS IS" BASIS,
-//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//  See the License for the specific language governing permissions and
-//  limitations under the License.
-
-fn main() {
-    println!("Audit Logger Example");
-}

crates/audit-logger/src/entry/args.rs

@@ -1,90 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#![allow(dead_code)]
-
-use crate::entry::ObjectVersion;
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-
-/// Args - defines the arguments for API operations
-/// Args is used to define the arguments for API operations.
-///
-/// # Example
-/// ```
-/// use rustfs_audit_logger::Args;
-/// use std::collections::HashMap;
-///
-/// let args = Args::new()
-///     .set_bucket(Some("my-bucket".to_string()))
-///     .set_object(Some("my-object".to_string()))
-///     .set_version_id(Some("123".to_string()))
-///     .set_metadata(Some(HashMap::new()));
-/// ```
-#[derive(Debug, Clone, Serialize, Deserialize, Default, Eq, PartialEq)]
-pub struct Args {
-    #[serde(rename = "bucket", skip_serializing_if = "Option::is_none")]
-    pub bucket: Option<String>,
-    #[serde(rename = "object", skip_serializing_if = "Option::is_none")]
-    pub object: Option<String>,
-    #[serde(rename = "versionId", skip_serializing_if = "Option::is_none")]
-    pub version_id: Option<String>,
-    #[serde(rename = "objects", skip_serializing_if = "Option::is_none")]
-    pub objects: Option<Vec<ObjectVersion>>,
-    #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")]
-    pub metadata: Option<HashMap<String, String>>,
-}
-
-impl Args {
-    /// Create a new Args object
-    pub fn new() -> Self {
-        Args {
-            bucket: None,
-            object: None,
-            version_id: None,
-            objects: None,
-            metadata: None,
-        }
-    }
-
-    /// Set the bucket
-    pub fn set_bucket(mut self, bucket: Option<String>) -> Self {
-        self.bucket = bucket;
-        self
-    }
-
-    /// Set the object
-    pub fn set_object(mut self, object: Option<String>) -> Self {
-        self.object = object;
-        self
-    }
-
-    /// Set the version ID
-    pub fn set_version_id(mut self, version_id: Option<String>) -> Self {
-        self.version_id = version_id;
-        self
-    }
-
-    /// Set the objects
-    pub fn set_objects(mut self, objects: Option<Vec<ObjectVersion>>) -> Self {
-        self.objects = objects;
-        self
-    }
-
-    /// Set the metadata
-    pub fn set_metadata(mut self, metadata: Option<HashMap<String, String>>) -> Self {
-        self.metadata = metadata;
-        self
-    }
-}

crates/audit-logger/src/entry/audit.rs

@@ -1,469 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#![allow(dead_code)]
-
-use crate::{BaseLogEntry, LogRecord, ObjectVersion};
-use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use std::collections::HashMap;
-
-/// API details structure
-/// ApiDetails is used to define the details of an API operation
-///
-/// The `ApiDetails` structure contains the following fields:
-/// - `name` - the name of the API operation
-/// - `bucket` - the bucket name
-/// - `object` - the object name
-/// - `objects` - the list of objects
-/// - `status` - the status of the API operation
-/// - `status_code` - the status code of the API operation
-/// - `input_bytes` - the input bytes
-/// - `output_bytes` - the output bytes
-/// - `header_bytes` - the header bytes
-/// - `time_to_first_byte` - the time to first byte
-/// - `time_to_first_byte_in_ns` - the time to first byte in nanoseconds
-/// - `time_to_response` - the time to response
-/// - `time_to_response_in_ns` - the time to response in nanoseconds
-///
-/// The `ApiDetails` structure contains the following methods:
-/// - `new` - create a new `ApiDetails` with default values
-/// - `set_name` - set the name
-/// - `set_bucket` - set the bucket
-/// - `set_object` - set the object
-/// - `set_objects` - set the objects
-/// - `set_status` - set the status
-/// - `set_status_code` - set the status code
-/// - `set_input_bytes` - set the input bytes
-/// - `set_output_bytes` - set the output bytes
-/// - `set_header_bytes` - set the header bytes
-/// - `set_time_to_first_byte` - set the time to first byte
-/// - `set_time_to_first_byte_in_ns` - set the time to first byte in nanoseconds
-/// - `set_time_to_response` - set the time to response
-/// - `set_time_to_response_in_ns` - set the time to response in nanoseconds
-///
-/// # Example
-/// ```
-/// use rustfs_audit_logger::ApiDetails;
-/// use rustfs_audit_logger::ObjectVersion;
-///
-/// let api = ApiDetails::new()
-///     .set_name(Some("GET".to_string()))
-///     .set_bucket(Some("my-bucket".to_string()))
-///     .set_object(Some("my-object".to_string()))
-///     .set_objects(vec![ObjectVersion::new_with_object_name("my-object".to_string())])
-///     .set_status(Some("OK".to_string()))
-///     .set_status_code(Some(200))
-///     .set_input_bytes(100)
-///     .set_output_bytes(200)
-///     .set_header_bytes(Some(50))
-///     .set_time_to_first_byte(Some("100ms".to_string()))
-///     .set_time_to_first_byte_in_ns(Some("100000000ns".to_string()))
-///     .set_time_to_response(Some("200ms".to_string()))
-///     .set_time_to_response_in_ns(Some("200000000ns".to_string()));
-/// ```
-#[derive(Debug, Serialize, Deserialize, Clone, Default, PartialEq, Eq)]
-pub struct ApiDetails {
-    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
-    pub name: Option<String>,
-    #[serde(rename = "bucket", skip_serializing_if = "Option::is_none")]
-    pub bucket: Option<String>,
-    #[serde(rename = "object", skip_serializing_if = "Option::is_none")]
-    pub object: Option<String>,
-    #[serde(rename = "objects", skip_serializing_if = "Vec::is_empty", default)]
-    pub objects: Vec<ObjectVersion>,
-    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
-    pub status: Option<String>,
-    #[serde(rename = "statusCode", skip_serializing_if = "Option::is_none")]
-    pub status_code: Option<i32>,
-    #[serde(rename = "rx")]
-    pub input_bytes: i64,
-    #[serde(rename = "tx")]
-    pub output_bytes: i64,
-    #[serde(rename = "txHeaders", skip_serializing_if = "Option::is_none")]
-    pub header_bytes: Option<i64>,
-    #[serde(rename = "timeToFirstByte", skip_serializing_if = "Option::is_none")]
-    pub time_to_first_byte: Option<String>,
-    #[serde(rename = "timeToFirstByteInNS", skip_serializing_if = "Option::is_none")]
-    pub time_to_first_byte_in_ns: Option<String>,
-    #[serde(rename = "timeToResponse", skip_serializing_if = "Option::is_none")]
-    pub time_to_response: Option<String>,
-    #[serde(rename = "timeToResponseInNS", skip_serializing_if = "Option::is_none")]
-    pub time_to_response_in_ns: Option<String>,
-}
-
-impl ApiDetails {
-    /// Create a new `ApiDetails` with default values
-    pub fn new() -> Self {
-        ApiDetails {
-            name: None,
-            bucket: None,
-            object: None,
-            objects: Vec::new(),
-            status: None,
-            status_code: None,
-            input_bytes: 0,
-            output_bytes: 0,
-            header_bytes: None,
-            time_to_first_byte: None,
-            time_to_first_byte_in_ns: None,
-            time_to_response: None,
-            time_to_response_in_ns: None,
-        }
-    }
-
-    /// Set the name
-    pub fn set_name(mut self, name: Option<String>) -> Self {
-        self.name = name;
-        self
-    }
-
-    /// Set the bucket
-    pub fn set_bucket(mut self, bucket: Option<String>) -> Self {
-        self.bucket = bucket;
-        self
-    }
-
-    /// Set the object
-    pub fn set_object(mut self, object: Option<String>) -> Self {
-        self.object = object;
-        self
-    }
-
-    /// Set the objects
-    pub fn set_objects(mut self, objects: Vec<ObjectVersion>) -> Self {
-        self.objects = objects;
-        self
-    }
-
-    /// Set the status
-    pub fn set_status(mut self, status: Option<String>) -> Self {
-        self.status = status;
-        self
-    }
-
-    /// Set the status code
-    pub fn set_status_code(mut self, status_code: Option<i32>) -> Self {
-        self.status_code = status_code;
-        self
-    }
-
-    /// Set the input bytes
-    pub fn set_input_bytes(mut self, input_bytes: i64) -> Self {
-        self.input_bytes = input_bytes;
-        self
-    }
-
-    /// Set the output bytes
-    pub fn set_output_bytes(mut self, output_bytes: i64) -> Self {
-        self.output_bytes = output_bytes;
-        self
-    }
-
-    /// Set the header bytes
-    pub fn set_header_bytes(mut self, header_bytes: Option<i64>) -> Self {
-        self.header_bytes = header_bytes;
-        self
-    }
-
-    /// Set the time to first byte
-    pub fn set_time_to_first_byte(mut self, time_to_first_byte: Option<String>) -> Self {
-        self.time_to_first_byte = time_to_first_byte;
-        self
-    }
-
-    /// Set the time to first byte in nanoseconds
-    pub fn set_time_to_first_byte_in_ns(mut self, time_to_first_byte_in_ns: Option<String>) -> Self {
-        self.time_to_first_byte_in_ns = time_to_first_byte_in_ns;
-        self
-    }
-
-    /// Set the time to response
-    pub fn set_time_to_response(mut self, time_to_response: Option<String>) -> Self {
-        self.time_to_response = time_to_response;
-        self
-    }
-
-    /// Set the time to response in nanoseconds
-    pub fn set_time_to_response_in_ns(mut self, time_to_response_in_ns: Option<String>) -> Self {
-        self.time_to_response_in_ns = time_to_response_in_ns;
-        self
-    }
-}
-
-/// Entry - audit entry logs
-/// AuditLogEntry is used to define the structure of an audit log entry
-///
-/// The `AuditLogEntry` structure contains the following fields:
-/// - `base` - the base log entry
-/// - `version` - the version of the audit log entry
-/// - `deployment_id` - the deployment ID
-/// - `event` - the event
-/// - `entry_type` - the type of audit message
-/// - `api` - the API details
-/// - `remote_host` - the remote host
-/// - `user_agent` - the user agent
-/// - `req_path` - the request path
-/// - `req_host` - the request host
-/// - `req_claims` - the request claims
-/// - `req_query` - the request query
-/// - `req_header` - the request header
-/// - `resp_header` - the response header
-/// - `access_key` - the access key
-/// - `parent_user` - the parent user
-/// - `error` - the error
-///
-/// The `AuditLogEntry` structure contains the following methods:
-/// - `new` - create a new `AuditEntry` with default values
-/// - `new_with_values` - create a new `AuditEntry` with version, time, event and api details
-/// - `with_base` - set the base log entry
-/// - `set_version` - set the version
-/// - `set_deployment_id` - set the deployment ID
-/// - `set_event` - set the event
-/// - `set_entry_type` - set the entry type
-/// - `set_api` - set the API details
-/// - `set_remote_host` - set the remote host
-/// - `set_user_agent` - set the user agent
-/// - `set_req_path` - set the request path
-/// - `set_req_host` - set the request host
-/// - `set_req_claims` - set the request claims
-/// - `set_req_query` - set the request query
-/// - `set_req_header` - set the request header
-/// - `set_resp_header` - set the response header
-/// - `set_access_key` - set the access key
-/// - `set_parent_user` - set the parent user
-/// - `set_error` - set the error
-///
-/// # Example
-/// ```
-/// use rustfs_audit_logger::AuditLogEntry;
-/// use rustfs_audit_logger::ApiDetails;
-/// use std::collections::HashMap;
-///
-/// let entry = AuditLogEntry::new()
-///     .set_version("1.0".to_string())
-///     .set_deployment_id(Some("123".to_string()))
-///     .set_event("event".to_string())
-///     .set_entry_type(Some("type".to_string()))
-///     .set_api(ApiDetails::new())
-///     .set_remote_host(Some("remote-host".to_string()))
-///     .set_user_agent(Some("user-agent".to_string()))
-///     .set_req_path(Some("req-path".to_string()))
-///     .set_req_host(Some("req-host".to_string()))
-///     .set_req_claims(Some(HashMap::new()))
-///     .set_req_query(Some(HashMap::new()))
-///     .set_req_header(Some(HashMap::new()))
-///     .set_resp_header(Some(HashMap::new()))
-///     .set_access_key(Some("access-key".to_string()))
-///     .set_parent_user(Some("parent-user".to_string()))
-///     .set_error(Some("error".to_string()));
-#[derive(Debug, Serialize, Deserialize, Clone, Default)]
-pub struct AuditLogEntry {
-    #[serde(flatten)]
-    pub base: BaseLogEntry,
-    pub version: String,
-    #[serde(rename = "deploymentid", skip_serializing_if = "Option::is_none")]
-    pub deployment_id: Option<String>,
-    pub event: String,
-    // Class of audit message - S3, admin ops, bucket management
-    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
-    pub entry_type: Option<String>,
-    pub api: ApiDetails,
-    #[serde(rename = "remotehost", skip_serializing_if = "Option::is_none")]
-    pub remote_host: Option<String>,
-    #[serde(rename = "userAgent", skip_serializing_if = "Option::is_none")]
-    pub user_agent: Option<String>,
-    #[serde(rename = "requestPath", skip_serializing_if = "Option::is_none")]
-    pub req_path: Option<String>,
-    #[serde(rename = "requestHost", skip_serializing_if = "Option::is_none")]
-    pub req_host: Option<String>,
-    #[serde(rename = "requestClaims", skip_serializing_if = "Option::is_none")]
-    pub req_claims: Option<HashMap<String, Value>>,
-    #[serde(rename = "requestQuery", skip_serializing_if = "Option::is_none")]
-    pub req_query: Option<HashMap<String, String>>,
-    #[serde(rename = "requestHeader", skip_serializing_if = "Option::is_none")]
-    pub req_header: Option<HashMap<String, String>>,
-    #[serde(rename = "responseHeader", skip_serializing_if = "Option::is_none")]
-    pub resp_header: Option<HashMap<String, String>>,
-    #[serde(rename = "accessKey", skip_serializing_if = "Option::is_none")]
-    pub access_key: Option<String>,
-    #[serde(rename = "parentUser", skip_serializing_if = "Option::is_none")]
-    pub parent_user: Option<String>,
-    #[serde(rename = "error", skip_serializing_if = "Option::is_none")]
-    pub error: Option<String>,
-}
-
-impl AuditLogEntry {
-    /// Create a new `AuditEntry` with default values
-    pub fn new() -> Self {
-        AuditLogEntry {
-            base: BaseLogEntry::new(),
-            version: String::new(),
-            deployment_id: None,
-            event: String::new(),
-            entry_type: None,
-            api: ApiDetails::new(),
-            remote_host: None,
-            user_agent: None,
-            req_path: None,
-            req_host: None,
-            req_claims: None,
-            req_query: None,
-            req_header: None,
-            resp_header: None,
-            access_key: None,
-            parent_user: None,
-            error: None,
-        }
-    }
-
-    /// Create a new `AuditEntry` with version, time, event and api details
-    pub fn new_with_values(version: String, time: DateTime<Utc>, event: String, api: ApiDetails) -> Self {
-        let mut base = BaseLogEntry::new();
-        base.timestamp = time;
-
-        AuditLogEntry {
-            base,
-            version,
-            deployment_id: None,
-            event,
-            entry_type: None,
-            api,
-            remote_host: None,
-            user_agent: None,
-            req_path: None,
-            req_host: None,
-            req_claims: None,
-            req_query: None,
-            req_header: None,
-            resp_header: None,
-            access_key: None,
-            parent_user: None,
-            error: None,
-        }
-    }
-
-    /// Set the base log entry
-    pub fn with_base(mut self, base: BaseLogEntry) -> Self {
-        self.base = base;
-        self
-    }
-
-    /// Set the version
-    pub fn set_version(mut self, version: String) -> Self {
-        self.version = version;
-        self
-    }
-
-    /// Set the deployment ID
-    pub fn set_deployment_id(mut self, deployment_id: Option<String>) -> Self {
-        self.deployment_id = deployment_id;
-        self
-    }
-
-    /// Set the event
-    pub fn set_event(mut self, event: String) -> Self {
-        self.event = event;
-        self
-    }
-
-    /// Set the entry type
-    pub fn set_entry_type(mut self, entry_type: Option<String>) -> Self {
-        self.entry_type = entry_type;
-        self
-    }
-
-    /// Set the API details
-    pub fn set_api(mut self, api: ApiDetails) -> Self {
-        self.api = api;
-        self
-    }
-
-    /// Set the remote host
-    pub fn set_remote_host(mut self, remote_host: Option<String>) -> Self {
-        self.remote_host = remote_host;
-        self
-    }
-
-    /// Set the user agent
-    pub fn set_user_agent(mut self, user_agent: Option<String>) -> Self {
-        self.user_agent = user_agent;
-        self
-    }
-
-    /// Set the request path
-    pub fn set_req_path(mut self, req_path: Option<String>) -> Self {
-        self.req_path = req_path;
-        self
-    }
-
-    /// Set the request host
-    pub fn set_req_host(mut self, req_host: Option<String>) -> Self {
-        self.req_host = req_host;
-        self
-    }
-
-    /// Set the request claims
-    pub fn set_req_claims(mut self, req_claims: Option<HashMap<String, Value>>) -> Self {
-        self.req_claims = req_claims;
-        self
-    }
-
-    /// Set the request query
-    pub fn set_req_query(mut self, req_query: Option<HashMap<String, String>>) -> Self {
-        self.req_query = req_query;
-        self
-    }
-
-    /// Set the request header
-    pub fn set_req_header(mut self, req_header: Option<HashMap<String, String>>) -> Self {
-        self.req_header = req_header;
-        self
-    }
-
-    /// Set the response header
-    pub fn set_resp_header(mut self, resp_header: Option<HashMap<String, String>>) -> Self {
-        self.resp_header = resp_header;
-        self
-    }
-
-    /// Set the access key
-    pub fn set_access_key(mut self, access_key: Option<String>) -> Self {
-        self.access_key = access_key;
-        self
-    }
-
-    /// Set the parent user
-    pub fn set_parent_user(mut self, parent_user: Option<String>) -> Self {
-        self.parent_user = parent_user;
-        self
-    }
-
-    /// Set the error
-    pub fn set_error(mut self, error: Option<String>) -> Self {
-        self.error = error;
-        self
-    }
-}
-
-impl LogRecord for AuditLogEntry {
-    fn to_json(&self) -> String {
-        serde_json::to_string(self).unwrap_or_else(|_| String::from("{}"))
-    }
-
-    fn get_timestamp(&self) -> DateTime<Utc> {
-        self.base.timestamp
-    }
-}

crates/audit-logger/src/entry/base.rs

@@ -1,108 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#![allow(dead_code)]
-
-use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use std::collections::HashMap;
-
-/// Base log entry structure shared by all log types
-/// This structure is used to serialize log entries to JSON
-/// and send them to the log sinks
-/// This structure is also used to deserialize log entries from JSON
-/// This structure is also used to store log entries in the database
-/// This structure is also used to query log entries from the database
-///
-/// The `BaseLogEntry` structure contains the following fields:
-/// - `timestamp` - the timestamp of the log entry
-/// - `request_id` - the request ID of the log entry
-/// - `message` - the message of the log entry
-/// - `tags` - the tags of the log entry
-///
-/// The `BaseLogEntry` structure contains the following methods:
-/// - `new` - create a new `BaseLogEntry` with default values
-/// - `message` - set the message
-/// - `request_id` - set the request ID
-/// - `tags` - set the tags
-/// - `timestamp` - set the timestamp
-///
-/// # Example
-/// ```
-/// use rustfs_audit_logger::BaseLogEntry;
-/// use chrono::{DateTime, Utc};
-/// use std::collections::HashMap;
-///
-/// let timestamp = Utc::now();
-/// let request = Some("req-123".to_string());
-/// let message = Some("This is a log message".to_string());
-/// let tags = Some(HashMap::new());
-///
-/// let entry = BaseLogEntry::new()
-///     .timestamp(timestamp)
-///     .request_id(request)
-///     .message(message)
-///     .tags(tags);
-/// ```
-#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, Default)]
-pub struct BaseLogEntry {
-    #[serde(rename = "time")]
-    pub timestamp: DateTime<Utc>,
-
-    #[serde(rename = "requestID", skip_serializing_if = "Option::is_none")]
-    pub request_id: Option<String>,
-
-    #[serde(rename = "message", skip_serializing_if = "Option::is_none")]
-    pub message: Option<String>,
-
-    #[serde(rename = "tags", skip_serializing_if = "Option::is_none")]
-    pub tags: Option<HashMap<String, Value>>,
-}
-
-impl BaseLogEntry {
-    /// Create a new BaseLogEntry with default values
-    pub fn new() -> Self {
-        BaseLogEntry {
-            timestamp: Utc::now(),
-            request_id: None,
-            message: None,
-            tags: None,
-        }
-    }
-
-    /// Set the message
-    pub fn message(mut self, message: Option<String>) -> Self {
-        self.message = message;
-        self
-    }
-
-    /// Set the request ID
-    pub fn request_id(mut self, request_id: Option<String>) -> Self {
-        self.request_id = request_id;
-        self
-    }
-
-    /// Set the tags
-    pub fn tags(mut self, tags: Option<HashMap<String, Value>>) -> Self {
-        self.tags = tags;
-        self
-    }
-
-    /// Set the timestamp
-    pub fn timestamp(mut self, timestamp: DateTime<Utc>) -> Self {
-        self.timestamp = timestamp;
-        self
-    }
-}

crates/audit-logger/src/entry/mod.rs

@@ -1,159 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#![allow(dead_code)]
-pub(crate) mod args;
-pub(crate) mod audit;
-pub(crate) mod base;
-pub(crate) mod unified;
-
-use serde::de::Error;
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use tracing_core::Level;
-
-/// ObjectVersion is used across multiple modules
-#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
-pub struct ObjectVersion {
-    #[serde(rename = "name")]
-    pub object_name: String,
-    #[serde(rename = "versionId", skip_serializing_if = "Option::is_none")]
-    pub version_id: Option<String>,
-}
-
-impl ObjectVersion {
-    /// Create a new ObjectVersion object
-    pub fn new() -> Self {
-        ObjectVersion {
-            object_name: String::new(),
-            version_id: None,
-        }
-    }
-
-    /// Create a new ObjectVersion with object name
-    pub fn new_with_object_name(object_name: String) -> Self {
-        ObjectVersion {
-            object_name,
-            version_id: None,
-        }
-    }
-
-    /// Set the object name
-    pub fn set_object_name(mut self, object_name: String) -> Self {
-        self.object_name = object_name;
-        self
-    }
-
-    /// Set the version ID
-    pub fn set_version_id(mut self, version_id: Option<String>) -> Self {
-        self.version_id = version_id;
-        self
-    }
-}
-
-impl Default for ObjectVersion {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-/// Log kind/level enum
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
-pub enum LogKind {
-    #[serde(rename = "INFO")]
-    #[default]
-    Info,
-    #[serde(rename = "WARNING")]
-    Warning,
-    #[serde(rename = "ERROR")]
-    Error,
-    #[serde(rename = "FATAL")]
-    Fatal,
-}
-
-/// Trait for types that can be serialized to JSON and have a timestamp
-/// This trait is used by `ServerLogEntry` to convert the log entry to JSON
-/// and get the timestamp of the log entry
-/// This trait is implemented by `ServerLogEntry`
-///
-/// # Example
-/// ```
-/// use rustfs_audit_logger::LogRecord;
-/// use chrono::{DateTime, Utc};
-/// use rustfs_audit_logger::ServerLogEntry;
-/// use tracing_core::Level;
-///
-/// let log_entry = ServerLogEntry::new(Level::INFO, "api_handler".to_string());
-/// let json = log_entry.to_json();
-/// let timestamp = log_entry.get_timestamp();
-/// ```
-pub trait LogRecord {
-    fn to_json(&self) -> String;
-    fn get_timestamp(&self) -> chrono::DateTime<chrono::Utc>;
-}
-
-/// Wrapper for `tracing_core::Level` to implement `Serialize` and `Deserialize`
-/// for `ServerLogEntry`
-/// This is necessary because `tracing_core::Level` does not implement `Serialize`
-/// and `Deserialize`
-/// This is a workaround to allow `ServerLogEntry` to be serialized and deserialized
-/// using `serde`
-///
-/// # Example
-/// ```
-/// use rustfs_audit_logger::SerializableLevel;
-/// use tracing_core::Level;
-///
-/// let level = Level::INFO;
-/// let serializable_level = SerializableLevel::from(level);
-/// ```
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SerializableLevel(pub Level);
-
-impl From<Level> for SerializableLevel {
-    fn from(level: Level) -> Self {
-        SerializableLevel(level)
-    }
-}
-
-impl From<SerializableLevel> for Level {
-    fn from(serializable_level: SerializableLevel) -> Self {
-        serializable_level.0
-    }
-}
-
-impl Serialize for SerializableLevel {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(self.0.as_str())
-    }
-}
-
-impl<'de> Deserialize<'de> for SerializableLevel {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s = String::deserialize(deserializer)?;
-        match s.as_str() {
-            "TRACE" => Ok(SerializableLevel(Level::TRACE)),
-            "DEBUG" => Ok(SerializableLevel(Level::DEBUG)),
-            "INFO" => Ok(SerializableLevel(Level::INFO)),
-            "WARN" => Ok(SerializableLevel(Level::WARN)),
-            "ERROR" => Ok(SerializableLevel(Level::ERROR)),
-            _ => Err(D::Error::custom("unknown log level")),
-        }
-    }
-}

crates/audit-logger/src/entry/unified.rs

@@ -1,266 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#![allow(dead_code)]
-
-use crate::{AuditLogEntry, BaseLogEntry, LogKind, LogRecord, SerializableLevel};
-use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
-use tracing_core::Level;
-
-/// Server log entry with structured fields
-/// ServerLogEntry is used to log structured log entries from the server
-///
-/// The `ServerLogEntry` structure contains the following fields:
-/// - `base` - the base log entry
-/// - `level` - the log level
-/// - `source` - the source of the log entry
-/// - `user_id` - the user ID
-/// - `fields` - the structured fields of the log entry
-///
-/// The `ServerLogEntry` structure contains the following methods:
-/// - `new` - create a new `ServerLogEntry` with specified level and source
-/// - `with_base` - set the base log entry
-/// - `user_id` - set the user ID
-/// - `fields` - set the fields
-/// - `add_field` - add a field
-///
-/// # Example
-/// ```
-/// use rustfs_audit_logger::ServerLogEntry;
-/// use tracing_core::Level;
-///
-/// let entry = ServerLogEntry::new(Level::INFO, "test_module".to_string())
-///    .user_id(Some("user-456".to_string()))
-///   .add_field("operation".to_string(), "login".to_string());
-/// ```
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct ServerLogEntry {
-    #[serde(flatten)]
-    pub base: BaseLogEntry,
-
-    pub level: SerializableLevel,
-    pub source: String,
-
-    #[serde(rename = "userId", skip_serializing_if = "Option::is_none")]
-    pub user_id: Option<String>,
-
-    #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    pub fields: Vec<(String, String)>,
-}
-
-impl ServerLogEntry {
-    /// Create a new ServerLogEntry with specified level and source
-    pub fn new(level: Level, source: String) -> Self {
-        ServerLogEntry {
-            base: BaseLogEntry::new(),
-            level: SerializableLevel(level),
-            source,
-            user_id: None,
-            fields: Vec::new(),
-        }
-    }
-
-    /// Set the base log entry
-    pub fn with_base(mut self, base: BaseLogEntry) -> Self {
-        self.base = base;
-        self
-    }
-
-    /// Set the user ID
-    pub fn user_id(mut self, user_id: Option<String>) -> Self {
-        self.user_id = user_id;
-        self
-    }
-
-    /// Set fields
-    pub fn fields(mut self, fields: Vec<(String, String)>) -> Self {
-        self.fields = fields;
-        self
-    }
-
-    /// Add a field
-    pub fn add_field(mut self, key: String, value: String) -> Self {
-        self.fields.push((key, value));
-        self
-    }
-}
-
-impl LogRecord for ServerLogEntry {
-    fn to_json(&self) -> String {
-        serde_json::to_string(self).unwrap_or_else(|_| String::from("{}"))
-    }
-
-    fn get_timestamp(&self) -> DateTime<Utc> {
-        self.base.timestamp
-    }
-}
-
-/// Console log entry structure
-/// ConsoleLogEntry is used to log console log entries
-/// The `ConsoleLogEntry` structure contains the following fields:
-/// - `base` - the base log entry
-/// - `level` - the log level
-/// - `console_msg` - the console message
-/// - `node_name` - the node name
-/// - `err` - the error message
-///
-/// The `ConsoleLogEntry` structure contains the following methods:
-/// - `new` - create a new `ConsoleLogEntry`
-/// - `new_with_console_msg` - create a new `ConsoleLogEntry` with console message and node name
-/// - `with_base` - set the base log entry
-/// - `set_level` - set the log level
-/// - `set_node_name` - set the node name
-/// - `set_console_msg` - set the console message
-/// - `set_err` - set the error message
-///
-/// # Example
-/// ```
-/// use rustfs_audit_logger::ConsoleLogEntry;
-///
-/// let entry = ConsoleLogEntry::new_with_console_msg("Test message".to_string(), "node-123".to_string());
-/// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ConsoleLogEntry {
-    #[serde(flatten)]
-    pub base: BaseLogEntry,
-
-    pub level: LogKind,
-    pub console_msg: String,
-    pub node_name: String,
-
-    #[serde(skip)]
-    pub err: Option<String>,
-}
-
-impl ConsoleLogEntry {
-    /// Create a new ConsoleLogEntry
-    pub fn new() -> Self {
-        ConsoleLogEntry {
-            base: BaseLogEntry::new(),
-            level: LogKind::Info,
-            console_msg: String::new(),
-            node_name: String::new(),
-            err: None,
-        }
-    }
-
-    /// Create a new ConsoleLogEntry with console message and node name
-    pub fn new_with_console_msg(console_msg: String, node_name: String) -> Self {
-        ConsoleLogEntry {
-            base: BaseLogEntry::new(),
-            level: LogKind::Info,
-            console_msg,
-            node_name,
-            err: None,
-        }
-    }
-
-    /// Set the base log entry
-    pub fn with_base(mut self, base: BaseLogEntry) -> Self {
-        self.base = base;
-        self
-    }
-
-    /// Set the log level
-    pub fn set_level(mut self, level: LogKind) -> Self {
-        self.level = level;
-        self
-    }
-
-    /// Set the node name
-    pub fn set_node_name(mut self, node_name: String) -> Self {
-        self.node_name = node_name;
-        self
-    }
-
-    /// Set the console message
-    pub fn set_console_msg(mut self, console_msg: String) -> Self {
-        self.console_msg = console_msg;
-        self
-    }
-
-    /// Set the error message
-    pub fn set_err(mut self, err: Option<String>) -> Self {
-        self.err = err;
-        self
-    }
-}
-
-impl Default for ConsoleLogEntry {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl LogRecord for ConsoleLogEntry {
-    fn to_json(&self) -> String {
-        serde_json::to_string(self).unwrap_or_else(|_| String::from("{}"))
-    }
-
-    fn get_timestamp(&self) -> DateTime<Utc> {
-        self.base.timestamp
-    }
-}
-
-/// Unified log entry type
-/// UnifiedLogEntry is used to log different types of log entries
-///
-/// The `UnifiedLogEntry` enum contains the following variants:
-/// - `Server` - a server log entry
-/// - `Audit` - an audit log entry
-/// - `Console` - a console log entry
-///
-/// The `UnifiedLogEntry` enum contains the following methods:
-/// - `to_json` - convert the log entry to JSON
-/// - `get_timestamp` - get the timestamp of the log entry
-///
-/// # Example
-/// ```
-/// use rustfs_audit_logger::{UnifiedLogEntry, ServerLogEntry};
-/// use tracing_core::Level;
-///
-/// let server_entry = ServerLogEntry::new(Level::INFO, "test_module".to_string());
-/// let unified = UnifiedLogEntry::Server(server_entry);
-/// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(tag = "type")]
-pub enum UnifiedLogEntry {
-    #[serde(rename = "server")]
-    Server(ServerLogEntry),
-
-    #[serde(rename = "audit")]
-    Audit(Box<AuditLogEntry>),
-
-    #[serde(rename = "console")]
-    Console(ConsoleLogEntry),
-}
-
-impl LogRecord for UnifiedLogEntry {
-    fn to_json(&self) -> String {
-        match self {
-            UnifiedLogEntry::Server(entry) => entry.to_json(),
-            UnifiedLogEntry::Audit(entry) => entry.to_json(),
-            UnifiedLogEntry::Console(entry) => entry.to_json(),
-        }
-    }
-
-    fn get_timestamp(&self) -> DateTime<Utc> {
-        match self {
-            UnifiedLogEntry::Server(entry) => entry.get_timestamp(),
-            UnifiedLogEntry::Audit(entry) => entry.get_timestamp(),
-            UnifiedLogEntry::Console(entry) => entry.get_timestamp(),
-        }
-    }
-}

crates/audit-logger/src/lib.rs

@@ -1,8 +0,0 @@
-mod entry;
-mod logger;
-
-pub use entry::args::Args;
-pub use entry::audit::{ApiDetails, AuditLogEntry};
-pub use entry::base::BaseLogEntry;
-pub use entry::unified::{ConsoleLogEntry, ServerLogEntry, UnifiedLogEntry};
-pub use entry::{LogKind, LogRecord, ObjectVersion, SerializableLevel};