Struct BlockingRateLimiter 

pub struct BlockingRateLimiter { /* private fields */ }

A synchronous token-bucket rate limiter for the store-to-store sync path.

This is the blocking sibling of RateLimiter. The StreamStore methods are synchronous and drive their backends’ async SDK calls on an internal runtime via block_on, so the store-to-store sync orchestrator parallelizes them across a rayon thread pool of plain OS threads — it cannot use the async RateLimiter (awaiting inside a block_on-ing rayon worker would nest tokio runtimes). acquire_blocking therefore parks the calling OS thread with std::thread::sleep instead of .await.

When max_bytes_per_sec is None (or Some(0)), the limiter is unlimited and acquire_blocking returns immediately. Otherwise tokens refill at max_bytes_per_sec per second, allowing a burst of up to ~1 second’s worth of budget. The token math mirrors RateLimiter::acquire exactly.

The limiter is Arc-shareable and Clone (cloning shares the same underlying bucket), so every rayon worker throttles against one aggregate budget.

Implementations

impl BlockingRateLimiter

pub fn new(max_bytes_per_sec: Option<u64>) -> Self

Builds a synchronous limiter. None (or Some(0)) yields an unlimited, no-op limiter whose acquire_blocking never waits.

pub fn set_rate(&self, bytes_per_sec: Option<u64>)

Retunes the limiter’s aggregate byte-rate cap live (the synchronous sibling of RateLimiter::set_rate). Same semantics: None/Some(0) switches to unlimited and empties the bucket; Some(r > 0) installs a bucket refilling at r bytes/sec (priming a full burst when switching from unlimited).

pub fn acquire_blocking(&self, n: u64)

Blocks the calling OS thread until n bytes of budget are available, refilling the bucket at the configured rate. Unlimited limiters return immediately.

A single request larger than the bucket capacity is still satisfied: the bucket is allowed to go negative and the caller waits out the deficit, so throttling is correct even for objects bigger than one second’s worth of budget. Mirrors RateLimiter::acquire, but parks the thread with std::thread::sleep instead of awaiting.

Trait Implementations

impl Clone for BlockingRateLimiter

fn clone(&self) -> BlockingRateLimiter

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BlockingRateLimiter

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

Formats the value using the given formatter.