Struct BackendSelector 

pub struct BackendSelector { /* private fields */ }

Selects backend servers using round-robin with load tracking

Thread Safety

This struct is designed for concurrent access across multiple threads. The round-robin counter and pending counts use atomic operations for lock-free performance.

Load Balancing

• Strategy: Round-robin rotation through available backends
• Tracking: Atomic counters track pending commands per backend
• Monitoring: Load statistics available via backend_load()

Examples

let mut selector = BackendSelector::new();

selector.add_backend(
    BackendId::from_index(0),
    "backend-1".to_string(),
    provider,
);

// Route commands
let backend = selector.route_command_sync(ClientId::new(), "LIST")?;

Implementations

impl BackendSelector

pub fn new() -> Self

Create a new backend selector

pub fn add_backend( &mut self, backend_id: BackendId, name: String, provider: DeadpoolConnectionProvider, )

Add a backend server to the router

pub fn route_command_sync( &self, _client_id: ClientId, _command: &str, ) -> Result<BackendId>

Select a backend for the given command using round-robin Returns the backend ID to use for this command

pub fn complete_command_sync(&self, backend_id: BackendId)

Mark a command as complete, decrementing the pending count

pub fn get_backend_provider( &self, backend_id: BackendId, ) -> Option<&DeadpoolConnectionProvider>

Get the connection provider for a backend

pub fn backend_count(&self) -> usize

Get the number of backends

pub fn backend_load(&self, backend_id: BackendId) -> Option<usize>

Get backend load (pending requests) for monitoring

Trait Implementations

impl Debug for BackendSelector

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for BackendSelector

fn default() -> Self

Returns the “default value” for a type.