Module traffic_management

Expand description

This file is part of Ri. The Ri project belongs to the Dunimd 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.

§Traffic Management Module

This module provides traffic management functionality for the Ri service mesh. It allows configuring and managing traffic routes, traffic splits, circuit breakers, rate limits, and fault injection for services in the mesh.

§Key Components

RiTrafficRoute: Configuration for routing traffic between services
RiMatchCriteria: Criteria for matching requests to routes
RiRouteAction: Action to take for matched requests
RiWeightedDestination: Weighted destination for traffic splitting
RiRetryPolicy: Configuration for request retries
RiFaultInjection: Configuration for fault injection
RiTrafficSplit: Configuration for splitting traffic between service subsets
RiSubset: Service subset definition for traffic splitting
RiTrafficManager: Main traffic management service
RiCircuitBreakerConfig: Configuration for circuit breakers
RiRateLimitConfig: Configuration for rate limiting

§Design Principles

Declarative Configuration: Traffic rules are defined declaratively
Flexible Routing: Supports multiple routing actions (route, redirect, direct response)
Traffic Splitting: Weighted traffic splitting between service subsets
Resilience: Built-in retry policies and circuit breakers
Fault Injection: Support for fault injection for testing resilience
Rate Limiting: Protection against excessive traffic
Timeout Management: Configurable request timeouts
Thread-safe: Uses Arc and RwLock for safe concurrent access
Graceful Shutdown: Proper cleanup of background tasks
Extensible: Easy to add new traffic management features

§Usage

use ri::prelude::*;
use std::time::Duration;
 
async fn example() -> RiResult<()> {
    // Create a traffic manager
    let traffic_manager = RiTrafficManager::new(true);
     
    // Create a traffic route
    let route = RiTrafficRoute {
        name: "http-route".to_string(),
        source_service: "gateway".to_string(),
        destination_service: "backend".to_string(),
        match_criteria: RiMatchCriteria {
            path_prefix: Some("/api".to_string()),
            headers: HashMap::new(),
            method: Some("GET".to_string()),
            query_parameters: HashMap::new(),
        },
        route_action: RiRouteAction::Route(vec![RiWeightedDestination {
            service: "backend-v1".to_string(),
            weight: 80,
            subset: None,
        }, RiWeightedDestination {
            service: "backend-v2".to_string(),
            weight: 20,
            subset: None,
        }]),
        retry_policy: Some(RiRetryPolicy {
            attempts: 3,
            per_try_timeout: Duration::from_secs(1),
            retry_on: vec!["5xx".to_string()],
        }),
        timeout: Some(Duration::from_secs(5)),
        fault_injection: None,
    };
     
    // Add the route
    traffic_manager.add_traffic_route(route).await?;
     
    // Set a circuit breaker
    let cb_config = RiCircuitBreakerConfig {
        consecutive_errors: 5,
        interval: Duration::from_secs(10),
        base_ejection_time: Duration::from_secs(30),
        max_ejection_percent: 50.0,
    };
    traffic_manager.set_circuit_breaker_config("backend", cb_config).await?;
     
    Ok(())
}

Structs§

RiAbortFault
RiCircuitBreakerConfig
RiDelayFault
RiFaultInjection
RiMatchCriteria
RiRateLimitConfig
RiRetryPolicy
RiSubset
RiTrafficManager
RiTrafficRoute
RiTrafficSplit
RiWeightedDestination

Enums§

RiRouteAction