Struct ConcurrentLimitLayer 

pub struct ConcurrentLimitLayer<S: ConcurrentLimitSemaphore = Arc<Semaphore>> { /* 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();

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();

Implementations

impl ConcurrentLimitLayer<Arc<Semaphore>>

pub fn new(permits: usize) -> Self

Create a new ConcurrentLimitLayer with the specified number of permits.

These permits will be applied to all operations.

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

Set a concurrent limit for HTTP requests.

This convenience helper constructs a new semaphore with the specified number of permits and calls ConcurrentLimitLayer::with_http_semaphore. Use ConcurrentLimitLayer::with_http_semaphore directly when reusing a shared semaphore.

impl<S: ConcurrentLimitSemaphore> ConcurrentLimitLayer<S>

pub fn with_semaphore(operation_semaphore: S) -> Self

Create a layer with any ConcurrentLimitSemaphore implementation.

let semaphore = Arc::new(Semaphore::new(1024));
let _layer = ConcurrentLimitLayer::with_semaphore(semaphore);

pub fn with_http_semaphore(self, semaphore: S) -> Self

Provide a custom HTTP concurrency semaphore instance.

Trait Implementations

impl<S: Clone + ConcurrentLimitSemaphore> Clone for ConcurrentLimitLayer<S>

fn clone(&self) -> ConcurrentLimitLayer<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Access, S: ConcurrentLimitSemaphore> Layer<A> for ConcurrentLimitLayer<S>

where S::Permit: Unpin,

type LayeredAccess = ConcurrentLimitAccessor<A, S>

The layered accessor that returned by this layer.

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

Intercept the operations on the underlying storage.