limiteron

• ✨ Features
• 🎯 Use Cases
• 🚀 Quick Start
  • Installation
  • Basic Usage
• 📚 Documentation
• 🎨 Examples
• 🏗️ Architecture
• ⚙️ Configuration
• 🧪 Testing
• 📊 Performance
• 🔒 Security
• 🗺️ Roadmap
• 🤝 Contributing
• 📄 License
• 🙏 Acknowledgments

use limiteron::limiters::{Limiter, TokenBucketLimiter};

async fn enterprise_api() -> Result<(), Box<dyn std::error::Error>> {
    let limiter = TokenBucketLimiter::new(100, 10); // 100 tokens, refill 10 per second

    // Rate limiting check
    match limiter.allow(1).await {
        Ok(true) => {
            // Process request
            process_request().await;
        }
        Ok(false) => {
            eprintln!("Rate limit exceeded");
        }
        Err(e) => {
            eprintln!("Error: {:?}", e);
        }
    }

    Ok(())
}

async fn process_request() {
    println!("Processing request...");
}

Suitable for enterprise applications requiring high concurrency and reliability.

use limiteron::flow_control;

#[flow_control(rate = "100/s", quota = "10000/m", concurrency = 50)]
async fn api_handler(user_id: &str) -> Result<String, limiteron::error::FlowGuardError> {
    // API business logic
    Ok("Success".to_string())
}

Suitable for protecting API services from abuse and DDoS attacks.

use limiteron::ban_manager::{BanManager, BanTarget};
use limiteron::storage::MockBanStorage;
use std::sync::Arc;

async fn web_app() -> Result<(), Box<dyn std::error::Error>> {
    // Create storage and ban manager
    let storage = Arc::new(MockBanStorage::default());
    let ban_manager = BanManager::new(storage, None).await?;

    // Check if user is banned
    let user_target = BanTarget::UserId("user123".to_string());
    if let Some(ban_record) = ban_manager.is_banned(&user_target).await? {
        println!("User is banned: {:?}", ban_record);
        return Err("User is banned".into());
    }

    // Process request
    println!("Processing request for user123");
    Ok(())
}

Suitable for web applications that need to prevent malicious users and crawlers.

use limiteron::limiters::{Limiter, TokenBucketLimiter};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Step 1: Create limiter
    let limiter = TokenBucketLimiter::new(10, 1); // 10 tokens, refill 1 per second

    // Step 2: Check rate limit
    match limiter.allow(1).await {
        Ok(true) => println!("✅ Request allowed"),
        Ok(false) => println!("❌ Request rate limited"),
        Err(e) => println!("❌ Error: {:?}", e),
    }

    // Step 3: Use with cost
    match limiter.allow(2).await {
        Ok(true) => println!("✅ Request with cost 2 allowed"),
        Ok(false) => println!("❌ Request with cost 2 rate limited"),
        Err(e) => println!("❌ Error: {:?}", e),
    }

    Ok(())
}

# Run performance tests
cd temp/comprehensive_test
./target/release/functional_test    # Functional tests
./target/release/performance_test   # Performance tests
./target/release/concurrency_test   # Concurrency tests

Sample output:

功能测试: 7/7 Pass (100%)
TokenBucket: 12,088,759 ops/s
FixedWindow: 19,920,188 ops/s
ConcurrencyLimiter: 11,891,237 ops/s
并发测试: 100% 数据一致性

Security Measures

• ✅ Memory Protection - Rust memory safety guarantees
• ✅ Input Validation - IP address, User ID, MAC address validation
• ✅ SQL Injection Protection - Using parameterized queries
• ✅ Password Protection - Using secrecy library for sensitive data
• ✅ Audit Logging - Complete operation tracking

Reporting Security Issues

Please report security vulnerabilities through GitHub Issues.

How to Contribute

1. Fork the repository
2. Clone your fork: git clone https://github.com/yourusername/limiteron.git
3. Create a branch: git checkout -b feature/amazing-feature
4. Make your changes
5. Test your changes: cargo test --all-features
6. Commit your changes: git commit -m 'Add amazing feature'
7. Push to branch: git push origin feature/amazing-feature
8. Create a Pull Request

Code Style

• Follow Rust standard coding conventions
• Write comprehensive tests
• Update documentation
• Add examples for new features