Struct StreamExecutor 

pub struct StreamExecutor { /* private fields */ }

Executes streaming operations with bounded concurrency.

Construct via StorageService::stream. Each operation acquires a bulk permit individually; aggregate bulk concurrency is bounded by the bulk semaphore on the limiter.

See the module documentation for the concurrency model.

Implementations

impl StreamExecutor

pub fn new(backend: Arc<dyn Backend>, concurrency: ConcurrencyLimiter) -> Self

Creates a new StreamExecutor with the given backend and limiter.

pub fn execute<E>( self, context: ObjectContext, operations: impl Stream<Item = (usize, Result<Operation, E>)> + Send + 'static, ) -> impl Stream<Item = (usize, Result<OpResponse, E>)> + Send + 'static

where E: From<Error> + Send + 'static,

Executes the operations stream with bounded concurrency.

Each item is a (index, Result<Operation, E>) tuple where index is the 0-based position of the operation in the original request. Error items pass through immediately; successful items acquire a bulk permit and execute in an isolated [tokio::spawn].

Permit acquisition is sequential — only one acquire is in flight at a time, ensuring fairness with other streams and preventing a large batch from racing for all permits at once. Execution of operations that already hold a permit proceeds concurrently.

Operations that cannot acquire a permit within the configured queue timeout fail with Error::AtCapacity. Results are yielded in completion order (not submission order).

Trait Implementations

impl Debug for StreamExecutor

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

Formats the value using the given formatter.