Module http_error 

HTTP client error types with comprehensive retry detection.

This module provides error types for HTTP operations with built-in support for retry detection, error categorization, and detailed error information.

Overview

The HttpError enum covers all possible failure modes for HTTP requests:

• Network errors (connection failures, DNS issues)
• HTTP errors (4xx client errors, 5xx server errors)
• Serialization/deserialization errors
• Authentication errors
• Timeouts
• Configuration errors

Retry Detection

The error type includes built-in retry detection via HttpError::is_retryable():

• Network errors → retryable
• Timeouts → retryable
• 429 (rate limit) → retryable
• 500, 502, 503, 504 (server errors) → retryable
• All other errors → not retryable

When using the generated HTTP client with retry middleware (reqwest-retry), retryable errors are automatically retried with exponential backoff.

Examples

Basic Error Handling

fn handle_api_error(error: HttpError) {
    match error {
        HttpError::Network(e) => {
            eprintln!("Network error: {}", e);
            // Will be retried automatically if retry is configured
        }
        HttpError::Http { status, message, .. } => {
            match status {
                400 => eprintln!("Bad request: {}", message),
                401 => eprintln!("Unauthorized - check API key"),
                404 => eprintln!("Not found"),
                429 => eprintln!("Rate limited - will retry"),
                500..=599 => eprintln!("Server error: {}", message),
                _ => eprintln!("HTTP error {}: {}", status, message),
            }
        }
        HttpError::Timeout => {
            eprintln!("Request timeout - will retry");
        }
        e => {
            eprintln!("Other error: {}", e);
        }
    }
}

Retry Detection

fn classify_error(error: &HttpError) {
    if error.is_retryable() {
        println!("Retryable error: {}", error);
        // If retry middleware is configured, this will be retried automatically
    } else if error.is_client_error() {
        println!("Client error (4xx): fix the request");
    } else if error.is_server_error() {
        println!("Server error (5xx): may be transient");
    } else {
        println!("Non-retryable error: {}", error);
    }
}

Creating Errors

use openapi_to_rust::http_error::HttpError;

// Create HTTP error from status code
let error = HttpError::from_status(404, "Resource not found", None);

// Create serialization error
let error = HttpError::serialization_error("invalid JSON");

// Create deserialization error
let error = HttpError::deserialization_error("unexpected field");

Integration with reqwest-retry

When the generated HTTP client is configured with retry middleware, the retry logic automatically handles retryable errors:

[http_client.retry]
max_retries = 3
initial_delay_ms = 500
max_delay_ms = 16000

The retry middleware uses exponential backoff and will retry:

• Network errors (connection failures)
• Timeouts
• HTTP 429 (rate limit)
• HTTP 500, 502, 503, 504 (server errors)

Error Categories

Errors can be categorized using helper methods:

• HttpError::is_retryable() - Should this error be retried?
• HttpError::is_client_error() - Is this a 4xx error?
• HttpError::is_server_error() - Is this a 5xx error?

Enums

HttpError

HTTP client errors that can occur during API requests

Type Aliases

HttpResult

Result type for HTTP operations