Struct Shared 

struct Shared {
    control: Sender<Frame>,
    data: Sender<QueuedData>,
    streams: Mutex<HashMap<u32, StreamState>>,
    budget: Budget,
    resets: Mutex<Vec<u32>>,
    resets_ready: Notify,
    closing: CancellationToken,
    done: CancellationToken,
    activity: Activity,
    written: Activity,
    last_stream_id: AtomicU32,
    live_streams: AtomicUsize,
}

What the reader, the writer and the streams of a connection share.

Fields

control: Sender<Frame>

data: Sender<QueuedData>

streams: Mutex<HashMap<u32, StreamState>>

budget: Budget

The bytes of the client all streams hold, see DATA_BUFFER.

resets: Mutex<Vec<u32>>

The streams the server reset without queued data, which the writer sends next. Unlike the control queue it cannot be full, a stream gets reset only once.

resets_ready: Notify

closing: CancellationToken

Cancelled once the server closes the connection after the frames queued until then.

done: CancellationToken

Cancelled once the connection ended.

activity: Activity

When the last frame got read or written, for the idle timeout.

written: Activity

When a part of the frames of the server went out the last time, see ConnectionHandle::written.

last_stream_id: AtomicU32

The last stream the client opened, for the GOAWAY.

live_streams: AtomicUsize

The streams the server holds, see Live.

Implementations

impl Shared

fn lock_streams(&self) -> MutexGuard<'_, HashMap<u32, StreamState>>

fn queue_reset(&self, id: u32)

Queue the reset of a stream for the writer.

fn take_resets(&self) -> Vec<u32>

fn remote_closed(&self, id: u32)

The client closed its side of the stream.

fn local_closed(&self, id: u32)

The server closed its side of the stream.

async fn deliver(&self, stream_id: u32, data: Bytes)

Hand the data of the client to its stream. Waits while the stream does not take it or the streams hold all of the budget, which stops reading the connection.

async fn send_control(&self, frame: Frame) -> Result<()>

fn go_away(&self, status: u32)

End the connection with a GOAWAY, which the writer sends on its way out unless the client does not read anymore.

fn remove(&self, id: u32)

Forget a stream which got reset by either side.

fn has_room(&self) -> bool

Whether the client may open another stream, see MAX_STREAMS.