Struct RiLoadBalancer 

pub struct RiLoadBalancer { /* private fields */ }

Main load balancer implementation.

This struct provides a comprehensive load balancing solution with support for multiple strategies, health checking, connection management, and detailed statistics.

Implementations

impl RiLoadBalancer

pub fn new(strategy: RiLoadBalancerStrategy) -> Self

Creates a new load balancer with the specified strategy.

Parameters

• strategy: The load balancing strategy to use

Returns

A new RiLoadBalancer instance with the specified strategy

pub async fn add_server(&self, server: RiBackendServer) -> RiResult<()>

Adds a backend server to the load balancer.

Parameters

• server: The backend server to add

Security

This method validates the server URL to prevent SSRF (Server-Side Request Forgery) attacks. Only HTTP and HTTPS URLs are allowed. File://, gopher://, and other schemes are blocked. Private IP addresses (127.0.0.0/8, 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, 169.254.0.0/16) are logged as warnings but still allowed for internal deployments.

pub async fn remove_server(&self, server_id: &str) -> bool

Removes a backend server from the load balancer.

Parameters

• server_id: The ID of the server to remove

Returns

true if the server was removed, false otherwise

pub async fn get_healthy_servers(&self) -> Vec<RiBackendServer>

Gets a list of all healthy backend servers.

Returns

A vector of healthy RiBackendServer instances

pub async fn select_server( &self, client_ip: Option<&str>, ) -> RiResult<RiBackendServer>

Selects the most appropriate backend server for a client request.

This method applies the configured load balancing strategy to select a server, considering only healthy servers with available connections.

Parameters

• client_ip: Optional client IP address for IP Hash strategy

Returns

A RiResult<RiBackendServer> with the selected server, or an error if no servers are available

pub async fn release_server(&self, server_id: &str)

Releases a server after a request is completed.

This method decrements the active connection count for the specified server.

Parameters

• server_id: ID of the server to release

pub async fn record_server_failure(&self, server_id: &str)

Records a failed request to a server.

This method increments the failed request count and may mark the server as unhealthy if the failure rate exceeds a threshold.

Parameters

• server_id: ID of the server that failed

pub async fn record_response_time(&self, server_id: &str, response_time_ms: u64)

Records the response time for a successful request.

Parameters

• server_id: ID of the server that handled the request
• response_time_ms: Response time in milliseconds

pub async fn get_server_stats( &self, server_id: &str, ) -> Option<RiLoadBalancerServerStats>

Gets statistics for a specific server.

Parameters

• server_id: ID of the server to get statistics for

Returns

An Option<RiLoadBalancerServerStats> with the server statistics, or None if the server doesn’t exist

pub async fn get_all_stats( &self, ) -> FxHashMap<String, RiLoadBalancerServerStats>

Gets statistics for all servers.

Returns

A FxHashMap<String, RiLoadBalancerServerStats> with statistics for all servers

pub async fn mark_server_healthy(&self, server_id: &str, healthy: bool)

Marks a server as healthy or unhealthy.

Parameters

• server_id: ID of the server to update
• healthy: New health status (true = healthy, false = unhealthy)

pub async fn perform_health_check(&self, server_id: &str) -> bool

Performs an HTTP health check on a server.

This method sends an HTTP GET request to the server’s health check path and considers the server healthy if it returns a 2xx status code.

Parameters

• server_id: ID of the server to check

Returns

true if the server is healthy, false otherwise

pub async fn start_health_checks( self: Arc<Self>, interval_secs: u64, ) -> JoinHandle<()>

Starts periodic health checks for all servers.

This method spawns a background task that performs health checks on all servers at the specified interval.

Parameters

• interval_secs: Interval between health checks in seconds

Returns

A tokio::task::JoinHandle for the background health check task

pub fn get_strategy(&self) -> &RiLoadBalancerStrategy

Gets the current load balancing strategy.

Returns

A reference to the current RiLoadBalancerStrategy

pub async fn set_strategy(&mut self, strategy: RiLoadBalancerStrategy)

Sets the load balancing strategy.

Parameters

• strategy: The new load balancing strategy to use

pub async fn get_server_count(&self) -> usize

Gets the total number of servers.

Returns

The total number of servers in the load balancer

pub async fn get_healthy_server_count(&self) -> usize

Gets the number of healthy servers.

Returns

The number of healthy servers in the load balancer

Trait Implementations

impl Clone for RiLoadBalancer

fn clone(&self) -> Self

Creates a clone of the load balancer.

Note: The clone will have the same strategy and counter, but empty servers and stats since we can’t await in the Clone trait.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'py> IntoPyObject<'py> for RiLoadBalancer

type Target = RiLoadBalancer

The Python output type

type Output = Bound<'py, <RiLoadBalancer as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PyClass for RiLoadBalancer

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for RiLoadBalancer

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = c"Main load balancer implementation.\n\nThis struct provides a comprehensive load balancing solution with support for multiple\nstrategies, health checking, connection management, and detailed statistics.\x00"

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<RiLoadBalancer>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyTypeInfo for RiLoadBalancer

const NAME: &'static str = "RiLoadBalancer"

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl DerefToPyAny for RiLoadBalancer

impl ExtractPyClassWithClone for RiLoadBalancer