Struct ConnectionPool 

pub struct ConnectionPool {
    MaxConnections: usize,
    ConnectionTimeout: Duration,
    Semaphore: Arc<Semaphore>,
    ActiveConnections: Arc<Mutex<HashMap<String, ConnectionHandle>>>,
    HealthChecker: Arc<Mutex<HealthChecker>>,
}

Connection pool for IPC operations

This structure manages a pool of connections, preventing connection exhaustion by reusing connections and providing health monitoring.

Pool Architecture

ConnectionPool
    |
    | Semaphore (limits max connections)
    v
Active Connections (HashMap<id, ConnectionHandle>)
    |
    | Health Checker (background task)
    v
Monitor health and update scores

Connection Lifecycle

1. Acquisition: Get a connection from the pool (or create new)
2. Usage: Use the connection for operations
3. Release: Return the connection to the pool
4. Cleanup: Automatically remove stale/unhealthy connections

Health Monitoring

Each connection has:

• Health score (0.0 to 100.0)
• Error count
• Last used timestamp
• Background health checks every 30 seconds

Example Usage

let pool = Arc::new(ConnectionPool::new(10, Duration::from_secs(30)));

// Get a connection
let handle = pool.GetConnection().await?;

// Use the connection...

// Release the connection
pool.ReleaseConnection(handle).await;

// Get statistics
let stats = pool.GetStats().await;

Fields

MaxConnections: usize

Maximum number of concurrent connections allowed

ConnectionTimeout: Duration

Timeout for acquiring a connection from the pool

Semaphore: Arc<Semaphore>

Semaphore to limit concurrent connections

ActiveConnections: Arc<Mutex<HashMap<String, ConnectionHandle>>>

Map of active connections by ID

HealthChecker: Arc<Mutex<HealthChecker>>

Health checker for monitoring connection health

Implementations

impl ConnectionPool

pub fn new(MaxConnections: usize, ConnectionTimeout: Duration) -> Self

Create a new connection pool with specified parameters

Parameters

• MaxConnections: Maximum number of concurrent connections
• ConnectionTimeout: Timeout for acquiring a connection

Example

let pool = ConnectionPool::new(10, Duration::from_secs(30));

pub fn default() -> Self

Create a connection pool with default settings

Default settings: 10 max connections, 30s timeout

pub async fn GetConnection(&self) -> Result<ConnectionHandle, String>

Get a connection handle from the pool with timeout

This method acquires a semaphore permit and creates a new connection handle. If the pool is at capacity, it will wait until a connection becomes available or the timeout is reached.

Returns

• Ok(ConnectionHandle): New connection handle
• Err(String): Error message if timeout or failure occurs

Example

let handle = pool.GetConnection().await?;

pub async fn ReleaseConnection(&self, handle: ConnectionHandle)

Release a connection handle back to the pool

This method removes the connection from the active connections map, allowing the semaphore permit to be reused.

Parameters

• handle: The connection handle to release

Example

pool.ReleaseConnection(handle).await;

pub async fn GetStats(&self) -> ConnectionStats

Get connection statistics for monitoring

This method returns aggregate statistics about the connection pool, useful for monitoring and debugging.

Returns

Connection statistics including total connections, healthy connections, utilization, etc.

Example

let stats = pool.GetStats().await;
println!("Pool stats: {:?}", stats.summary());

pub async fn CleanUpStaleConnections(&self) -> usize

Clean up stale connections

This method removes connections that have not been used recently or are unhealthy, preventing memory leaks and resource exhaustion.

Stale connection criteria:

• Unused for 5 minutes (300 seconds)
• Not healthy (health score <= 50 or error count >= 5)

Returns

The number of stale connections removed

Example

let cleaned = pool.CleanUpStaleConnections().await;
println!("Cleaned up {} stale connections", cleaned);

async fn StartHealthMonitoring(&self, connection_id: &str)

Start health monitoring for a connection

This method spawns a background task that periodically checks the health of the connection and updates its health score.

Parameters

• connection_id: The ID of the connection to monitor

pub fn max_connections(&self) -> usize

Get the maximum number of connections

pub fn connection_timeout(&self) -> Duration

Get the connection timeout

pub fn available_permits(&self) -> usize

Get the number of available permits

pub async fn active_connections(&self) -> usize

Get the number of active connections