Struct BlobStream 

struct BlobStream {
    chunks: Receiver<Result<Bytes, Error>>,
}

A blob on its way out, a chunk at a time.

The store hands back a plain std::io::Read, and this turns it into the stream axum::body::Body wants. The read is blocking, which is the same posture the rest of this server takes towards its disk — the write-ahead log is written from inside async handlers too — and it is what keeps the store’s interface one trait rather than one per runtime. BLOB_READ_CONCURRENCY is what bounds how many of those reads run at once.

Fields

chunks: Receiver<Result<Bytes, Error>>

Implementations

impl BlobStream

fn new(reader: Box<dyn Read + Send>, permit: SemaphorePermit<'static>) -> Self

Reads reader on the blocking pool, handing chunks over a bounded channel.

std::io::Read on a file blocks the thread that calls it, and before this that thread was an async worker: a deployment with two of them (the t3.small infra/pds deploys onto) had every route, the firehose included, waiting behind two blob reads. The read happens on a blocking thread now, and the channel is what keeps it from running ahead of the socket.

permit is the caller’s BLOB_READ_CONCURRENCY permit, held for as long as the reading task holds its thread and given back the moment that task ends — whether the blob ran out, the read failed, or the client went away.

Trait Implementations

impl Stream for BlobStream

type Item = Result<Bytes, Error>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.