Struct ConcurrentLimitLayer

pub struct ConcurrentLimitLayer { /* private fields */ }

Add concurrent request limit.

Notes

Users can control how many concurrent connections could be established between OpenDAL and underlying storage services.

All operators wrapped by this layer will share a common semaphore. This allows you to reuse the same layer across multiple operators, ensuring that the total number of concurrent requests across the entire application does not exceed the limit.

Examples

Add a concurrent limit layer to the operator:

let _ = Operator::new(services::Memory::default())?
    .layer(ConcurrentLimitLayer::new(1024))
    .finish();
Ok(())

Share a concurrent limit layer between the operators:

let limit = ConcurrentLimitLayer::new(1024);

let _operator_a = Operator::new(services::Memory::default())?
    .layer(limit.clone())
    .finish();
let _operator_b = Operator::new(services::Memory::default())?
    .layer(limit.clone())
    .finish();

Ok(())

Implementations

impl ConcurrentLimitLayer

pub fn new(permits: usize) -> Self

Create a new ConcurrentLimitLayer will specify permits.

This permits will applied to all operations.

pub fn with_http_concurrent_limit(self, permits: usize) -> Self

Set a concurrent limit for HTTP requests.

This will limit the number of concurrent HTTP requests made by the operator.

Trait Implementations

impl Clone for ConcurrentLimitLayer

fn clone(&self) -> ConcurrentLimitLayer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Access> Layer<A> for ConcurrentLimitLayer

type LayeredAccess = ConcurrentLimitAccessor<A>

The layered accessor that returned by this layer.

fn layer(&self, inner: A) -> Self::LayeredAccess

Intercept the operations on the underlying storage.