Struct HandleStore 

pub struct HandleStore { /* private fields */ }

Per-endpoint handle registry. Owns all body readers, writers, sessions, request-head rendezvous channels, and fetch-cancel tokens for a single IrohEndpoint.

When the endpoint is dropped, this store is dropped with it — all slot-maps are freed and any remaining handles become invalid.

Implementations

impl HandleStore

pub fn new(config: StoreConfig) -> Self

Create a new handle store with the given configuration.

pub fn drain_timeout(&self) -> Duration

The configured drain timeout.

pub fn max_chunk_size(&self) -> usize

The configured maximum chunk size.

pub fn count_handles(&self) -> (usize, usize, usize, usize)

Snapshot of handle counts for observability.

Returns (active_readers, active_writers, active_sessions, total_handles).

pub fn make_body_channel(&self) -> (BodyWriter, BodyReader)

Create a matched (writer, reader) pair using this store’s config.

pub fn insert_reader(&self, reader: BodyReader) -> Result<u64, CoreError>

Insert a BodyReader and return a handle.

pub fn insert_writer(&self, writer: BodyWriter) -> Result<u64, CoreError>

Insert a BodyWriter and return a handle.

pub fn alloc_body_writer(&self) -> Result<(u64, BodyReader), CoreError>

Allocate a (writer_handle, reader) pair for streaming request bodies.

The writer handle is returned to JS. The reader must be stashed via store_pending_reader so the fetch path can claim it.

pub fn store_pending_reader(&self, writer_handle: u64, reader: BodyReader)

Store the reader side of a newly allocated writer channel so that the fetch path can claim it with claim_pending_reader.

pub fn claim_pending_reader(&self, writer_handle: u64) -> Option<BodyReader>

Claim the reader that was paired with writer_handle. Returns None if already claimed or never stored.

pub async fn next_chunk(&self, handle: u64) -> Result<Option<Bytes>, CoreError>

Pull the next chunk from a reader handle.

Returns Ok(None) at EOF. After returning None the handle is cleaned up from the registry automatically.

pub fn try_next_chunk(&self, handle: u64) -> Result<Option<Bytes>, CoreError>

Non-blocking variant of next_chunk.

Returns:

• Ok(Some(bytes)) — a chunk was immediately available.
• Ok(None) — EOF; the reader is cleaned up.
• Err(_) — no data available yet (channel empty or lock contended), or invalid handle. Caller should retry after yielding.

#126: Used by the Deno adapter to avoid spawn_blocking overhead on the body-read hot path. When data is already buffered in the channel, this returns it synchronously on the JS thread.

pub async fn send_chunk( &self, handle: u64, chunk: Bytes, ) -> Result<(), CoreError>

Push a chunk into a writer handle.

Chunks larger than the configured max_chunk_size are split automatically so individual messages stay within the backpressure budget.

pub fn finish_body(&self, handle: u64) -> Result<(), CoreError>

Signal end-of-body by dropping the writer from the registry.

pub fn cancel_reader(&self, handle: u64)

Drop a body reader, signalling cancellation of any in-flight read.

pub fn insert_session(&self, entry: SessionEntry) -> Result<u64, CoreError>

Insert a SessionEntry and return a handle.

pub fn lookup_session(&self, handle: u64) -> Option<Arc<SessionEntry>>

Look up a session by handle without consuming it.

pub fn remove_session(&self, handle: u64) -> Option<Arc<SessionEntry>>

Remove a session entry by handle and return it.

pub fn allocate_req_handle( &self, sender: Sender<ResponseHeadEntry>, ) -> Result<u64, CoreError>

Insert a response-head oneshot sender and return a handle.

pub fn take_req_sender(&self, handle: u64) -> Option<Sender<ResponseHeadEntry>>

Remove and return the response-head sender for the given handle.

pub fn alloc_fetch_token(&self) -> Result<u64, CoreError>

Allocate a cancellation token for an upcoming fetch call.

pub fn cancel_in_flight(&self, token: u64)

Signal an in-flight fetch to abort.

pub fn get_fetch_cancel_notify(&self, token: u64) -> Option<Arc<Notify>>

Retrieve the Notify for a fetch token (clones the Arc for use in select!).

pub fn remove_fetch_token(&self, token: u64)

Remove a fetch cancel token after the fetch completes.

pub fn sweep(&self, ttl: Duration)

Sweep all registries, removing entries older than ttl. Also compacts any registry that is empty after sweeping to reclaim the backing memory from traffic bursts.