🌐 avx-http - AVL Platform HTTP Client/Server

Native HTTP library optimized for Brazilian infrastructure and AVL Platform services.

🚀 Features

• 🇧🇷 Brazilian Infrastructure Optimized

  • Regional routing (São Paulo DC preference)
  • Smart retries for Brazilian ISP flakiness
  • < 500µs request overhead
  • Native connection multiplexing

• ⚡ High Performance

  • 100k+ requests/sec on single core
  • Zero-copy body parsing
  • Automatic compression with avila-compress
  • Connection pooling

• 🔧 AVL Platform Native

  • Built-in AVL authentication (JWT, API keys)
  • AvilaDB connection integration
  • Automatic telemetry and tracing
  • Cost tracking per request

• 🛠️ Developer Friendly

  • Simple async/await API
  • Type-safe route handlers
  • Built-in OpenAPI generation
  • Comprehensive error handling

📦 Installation

[dependencies]
avx-http = "0.1"
tokio = { version = "1", features = ["full"] }

🎯 Quick Start

HTTP Client

use avx_http::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create client with AVL Platform auth
    let client = Client::builder()
        .avl_auth("your-api-key")
        .region("br-saopaulo-1")
        .compression(true)
        .build()?;

    // Make request
    let response = client
        .get("https://api.avila.cloud/data")
        .header("Accept", "application/json")
        .send()
        .await?;

    println!("Status: {}", response.status());
    println!("Body: {}", response.text().await?);

    Ok(())
}

HTTP Server

use avx_http::{Server, Router, Response};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let router = Router::new()
        .get("/", || async { Response::text("Hello, AVL Platform!") })
        .get("/health", health_check)
        .post("/data", upload_data);

    Server::bind("0.0.0.0:3000")
        .router(router)
        .compression(true)
        .telemetry(true)
        .run()
        .await?;

    Ok(())
}

async fn health_check() -> Response {
    Response::json(serde_json::json!({
        "status": "healthy",
        "timestamp": chrono::Utc::now()
    }))
}

async fn upload_data(body: String) -> Response {
    Response::text(format!("Received {} bytes", body.len()))
}

🎨 Advanced Features

Connection Pooling

let client = Client::builder()
    .pool_max_connections(100)
    .pool_idle_timeout(Duration::from_secs(60))
    .build()?;

Request Retries

let response = client
    .get("https://api.avila.cloud/data")
    .retry(3) // Retry up to 3 times
    .timeout(Duration::from_secs(30))
    .send()
    .await?;

Automatic Compression

let response = client
    .post("https://api.avila.cloud/upload")
    .body(large_data)
    .compress(true) // Automatically compress with avila-compress
    .send()
    .await?;

Regional Routing

// Prefer Brazilian data centers
let client = Client::builder()
    .region("br-saopaulo-1")
    .fallback_region("br-riodejaneiro-1")
    .build()?;

📊 Performance

Benchmarks on AWS c6i.xlarge (São Paulo region):

🧪 Testing

# Run all tests
cargo test -p avx-http

# Run benchmarks
cargo bench -p avx-http

# Test with real HTTP requests
cargo test -p avx-http --features integration-tests

🗺️ Roadmap

• HTTP/1.1 client
• Basic server with routing
• HTTP/2 support
• HTTP/3 / QUIC support
• WebSocket support
• Server-Sent Events (SSE)
• Built-in rate limiting
• Circuit breaker pattern
• OpenAPI generation
• Native AvilaDB integration

🎯 Use Cases

API Gateway

// High-performance gateway for AVL Platform services
let gateway = Server::bind("0.0.0.0:8080")
    .router(api_routes())
    .rate_limit(1000, Duration::from_secs(1))
    .compression(true)
    .cors(CorsConfig::permissive())
    .run()
    .await?;

Microservice Communication

// Fast inter-service calls
let auth_client = Client::builder()
    .base_url("http://auth-service:3000")
    .timeout(Duration::from_millis(100))
    .build()?;

Data Ingestion

// Stream large datasets to AvilaDB
let response = client
    .post("https://aviladb.avila.cloud/ingest")
    .stream(data_stream)
    .compress(true)
    .send()
    .await?;

🤝 Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

📄 License

Licensed under either of:

• Apache License, Version 2.0 (LICENSE-APACHE)
• MIT license (LICENSE-MIT)

at your option.

Built with ❤️ for the AVL Platform and Brazilian research infrastructure 🇧🇷