Struct Session 

pub struct Session { /* private fields */ }

A QUIC session to a single remote peer.

Cheap to clone — this is just an IrohEndpoint ref-clone plus a u64 handle into the endpoint’s session registry. Sessions are not pooled; closing one session has no effect on other sessions to the same peer.

Implementations

impl Session

pub fn from_handle(endpoint: IrohEndpoint, handle: u64) -> Self

Reconstruct a Session from a handle previously obtained via Session::connect or Session::accept.

FFI adapters use this to rehydrate a session from a u64 handle that crossed a language boundary.

pub fn handle(&self) -> u64

The opaque handle identifying this session inside the endpoint registry.

pub async fn connect( endpoint: IrohEndpoint, remote_node_id: &str, direct_addrs: Option<&[SocketAddr]>, ) -> Result<Self, CoreError>

Establish a session (QUIC connection) to a remote peer.

Each call creates a dedicated QUIC connection — sessions are not pooled. Closing one session handle cannot affect other sessions to the same peer. (Fetch operations continue to use the shared pool for efficiency; sessions opt out because Session::close closes the underlying connection.)

pub async fn accept(endpoint: IrohEndpoint) -> Result<Option<Self>, CoreError>

Accept an incoming session (QUIC connection) from a remote peer.

Blocks until a peer connects. Returns the new session, or None if the endpoint is shutting down.

pub fn remote_id(&self) -> Result<PublicKey, CoreError>

Return the remote peer’s public key.

pub async fn create_bidi_stream(&self) -> Result<FfiDuplexStream, CoreError>

Open a new bidirectional stream on this session.

Returns FfiDuplexStream with read_handle / write_handle backed by body channels — the same interface used by fetch and raw_connect.

pub async fn next_bidi_stream( &self, ) -> Result<Option<FfiDuplexStream>, CoreError>

Accept the next incoming bidirectional stream from the remote side.

Blocks until the remote opens a stream, or returns None when the connection is closed.

pub fn close(&self, close_code: u64, reason: &str) -> Result<(), CoreError>

Close this session and remove it from the registry.

close_code is an application-level error code (maps to QUIC VarInt). reason is a human-readable string sent to the peer.

pub async fn ready(&self) -> Result<(), CoreError>

Wait for the QUIC handshake to complete on this session.

Resolves immediately if the handshake has already completed.

pub async fn closed(&self) -> Result<CloseInfo, CoreError>

Wait for the session to close and return the close information.

Blocks until the connection is closed by either side. Removes the session from the registry so resources are freed.

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

Open a new unidirectional (send-only) stream on this session.

Returns a write handle backed by a body channel.

pub async fn next_uni_stream(&self) -> Result<Option<u64>, CoreError>

Accept the next incoming unidirectional (receive-only) stream.

Returns a read handle, or None when the connection is closed.

pub fn send_datagram(&self, data: &[u8]) -> Result<(), CoreError>

Send a datagram on this session.

Fails if data.len() exceeds Session::max_datagram_size.

pub async fn recv_datagram(&self) -> Result<Option<Vec<u8>>, CoreError>

Receive the next datagram from this session.

Blocks until a datagram arrives, or returns None when the connection closes.

pub fn max_datagram_size(&self) -> Result<Option<usize>, CoreError>

Return the current maximum datagram payload size for this session.

Returns None if datagrams are not supported on the current path.

Trait Implementations

impl Clone for Session

fn clone(&self) -> Session

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.