Struct PeerSession 

pub struct PeerSession { /* private fields */ }

A multiplexed session over one peer connection: open many concurrent logical PeerStreams.

yamux 0.13 exposes a poll-based yamux::Connection (no Control handle), so a background driver task owns the connection and serves open-stream requests over a command channel; inbound streams are surfaced on Self::inbound_rx for a serving node. Dropping the session closes the command channel, which ends the driver and tears down the underlying byte stream.

Implementations

impl PeerSession

pub fn client<S>(io: S) -> Self

where S: AsyncRead + AsyncWrite + Send + Unpin + 'static,

Wrap an established mTLS byte stream in yamux as the client (outbound-stream opener) and spawn the driver. io is any tokio duplex stream (the mTLS tokio_rustls::client::TlsStream or, in tests, a loopback stream). Returns the session; open streams with Self::open_stream / Self::open_range_stream.

pub fn server<S>(io: S) -> Self

where S: AsyncRead + AsyncWrite + Send + Unpin + 'static,

Wrap an established byte stream in yamux as the server (accepts inbound streams). Inbound streams the peer opens are delivered via Self::accept_stream. Provided for symmetry + the serving side of tests.

pub async fn open_stream(&mut self) -> Result<PeerStream>

Open a new outbound logical stream to the peer. Cheap — open as many as you need to run concurrent transfers without head-of-line blocking.

pub async fn accept_stream(&mut self) -> Option<PeerStream>

Accept the next inbound logical stream the peer opened (server side). Returns None when the connection has closed. A pure client never calls this.

pub async fn open_range_stream( &mut self, req: &RangeRequest, ) -> Result<PeerStream>

Open a dig.fetchRange stream for req: opens a fresh logical stream, writes the RangeRequest preamble, and returns the stream for the caller to read RangeFrames from (via RangeFrame::decode) as they arrive. The building block for multi-source parallel range downloads — open one of these per (peer, range) and read them concurrently.

pub async fn query_availability( &mut self, items: Vec<AvailabilityItem>, ) -> Result<AvailabilityResponse>

Availability pre-check (dig.getAvailability) — ask the peer which of items it holds, BEFORE opening any range streams. Opens a short-lived control stream, writes the batched AvailabilityRequest, reads the AvailabilityResponse. A multi-source downloader runs this against candidate peers and only range-fetches from holders — the normative flow is: discover peers → query_availability (batch) → fan byte-ranges across holders → verify each vs the chain-anchored root → retry a bad range from another holder → reassemble.

Trait Implementations

impl Debug for PeerSession

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

Formats the value using the given formatter.