Struct Balancer 

pub struct Balancer {
    targets: Vec<Target>,
    strategy: Strategy,
    counter: AtomicUsize,
    in_flight: Vec<AtomicUsize>,
}

A pool of backend targets plus the state driving target selection.

Fields

targets: Vec<Target>

strategy: Strategy

counter: AtomicUsize

Monotonic pick counter driving round-robin selection.

in_flight: Vec<AtomicUsize>

Per-target in-flight counts (parallel to targets), used by least-connections selection and kept current via the guards.

Implementations

impl Balancer

pub fn new(targets: Vec<Target>, strategy: Strategy) -> Result<Self, String>

Builds a balancer over targets. Errors if the pool is empty.

pub fn select(&self, remote_addr: &str) -> usize

Picks the index of the target to use; remote_addr (client ip:port) is only consulted for ip_hash.

pub fn target(&self, idx: usize) -> &Target

The target at idx (from a prior select).

pub fn len(&self) -> usize

Number of targets in the pool.

pub fn is_empty(&self) -> bool

Whether the pool is empty (always false for a constructed Balancer).

pub fn in_flight_count(&self, idx: usize) -> usize

Current in-flight count for a target (for tests and future metrics).

pub fn strategy(&self) -> Strategy

The configured strategy.

pub fn acquire(&self, idx: usize) -> ConnGuard<'_>

Increments the in-flight count for idx, returning a borrowed guard that decrements it on drop. For a request/connection whose lifetime is a single stack scope (HTTP request, TCP connection).

pub fn owned_acquire(self: &Arc<Self>, idx: usize) -> OwnedConnGuard

Like acquire but owns an Arc<Balancer>, so the guard can be stored past the borrowing scope (e.g. a UDP session in a map).