Struct Bulkhead 

pub struct Bulkhead { /* private fields */ }

Bulkhead pattern: limits concurrent operations to prevent resource exhaustion.

Uses a semaphore to limit how many operations can run simultaneously. When the bulkhead is “full”, new operations either wait or fail fast.

Use Cases

• Limit concurrent peer connections
• Limit concurrent sync-engine calls
• Prevent thread/connection pool exhaustion

Example

use replication_engine::resilience::Bulkhead;
let bulkhead = Bulkhead::new(10); // Max 10 concurrent

// Blocking acquire
let permit = bulkhead.acquire().await?;
// do_work().await;
drop(permit); // Release slot

// Non-blocking (fail fast)
if let Some(permit) = bulkhead.try_acquire() {
    // do_work().await;
    drop(permit);
} else {
    // return Err("service overloaded");
}

Implementations

impl Bulkhead

pub fn new(max_concurrent: usize) -> Self

Create a new bulkhead with the given concurrency limit.

pub fn for_peers() -> Self

Create a bulkhead for limiting peer connections.

Default: 50 concurrent connections.

pub fn for_sync_engine() -> Self

Create a bulkhead for limiting sync-engine operations.

Default: 100 concurrent operations.

pub async fn acquire(&self) -> Result<OwnedSemaphorePermit, BulkheadFull>

Acquire a permit, waiting if necessary.

Returns a permit that releases the slot when dropped.

pub fn try_acquire(&self) -> Option<OwnedSemaphorePermit>

Try to acquire a permit without waiting.

Returns None if the bulkhead is full.

pub fn available(&self) -> usize

Get the number of available permits.

pub fn max_concurrent(&self) -> usize

Get the maximum concurrent operations allowed.

pub fn is_full(&self) -> bool

Check if the bulkhead is full (no permits available).

Trait Implementations

impl Debug for Bulkhead

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

Formats the value using the given formatter.