Struct ConcurrentLimitLayer 

pub struct ConcurrentLimitLayer<S = Arc<Semaphore>>
where
    S: ConcurrentLimitSemaphore,
{ /* private fields */ }

Available on crate feature layers-concurrent-limit only.

ConcurrentLimitLayer controls how many concurrent requests OpenDAL can send to a storage service.

Operators that reuse the same ConcurrentLimitLayer instance share a semaphore. This lets an application enforce one total concurrent-request limit across multiple operators.

Examples

The following example adds a concurrent limit layer to an operator:

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

Share a concurrent limit layer between the operators:

let limit = ConcurrentLimitLayer::new(1024);

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

Implementations

impl ConcurrentLimitLayer

pub fn new(permits: usize) -> ConcurrentLimitLayer

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) -> ConcurrentLimitLayer

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> ConcurrentLimitLayer<S>

where S: ConcurrentLimitSemaphore,

pub fn with_semaphore(operation_semaphore: S) -> ConcurrentLimitLayer<S>

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) -> ConcurrentLimitLayer<S>

Provide a custom HTTP concurrency semaphore instance.

Trait Implementations

impl<S> Clone for ConcurrentLimitLayer<S>

where S: Clone + ConcurrentLimitSemaphore,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Debug for ConcurrentLimitLayer<S>

where S: ConcurrentLimitSemaphore,

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

Formats the value using the given formatter.

impl<S> Layer for ConcurrentLimitLayer<S>

where S: ConcurrentLimitSemaphore, <S as ConcurrentLimitSemaphore>::Permit: Send + Sync + 'static + Unpin,

fn apply_service(&self, inner: Arc<dyn ServiceDyn>) -> Arc<dyn ServiceDyn>

Intercept the operation service stack.

fn apply_context( &self, _srv: Arc<dyn ServiceDyn>, inner: OperationContext, ) -> OperationContext

Intercept the operation context (HTTP transport and executor).