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 execute<E>( self, context: ObjectContext, operations: impl Stream<Item = (usize, Result<Operation, E>)> + Send + 'static, access_time: Timestamp, ) -> 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 AtCapacity. Results are yielded in completion order (not submission order).

All operations use the supplied access_time, including operations parsed or admitted later. Use the same timestamp when resolving insert metadata so creation, expiry checks, and TTI calculations share an anchor.

Trait Implementations

impl Debug for StreamExecutor

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

Formats the value using the given formatter.