moonbitstack/moonquic/stream does not have a README file
Refused
pub(all) suberror Refused {
Illegal(String)
Exceeded(limit~ : UInt64, got~ : UInt64)
Conflict(String)
} derive(Eq)Why a stream operation was refused.
Illegal is a transition §3.1 or §3.2 does not allow — a bug on this side.
Exceeded is the peer sending past a limit we advertised, or this side being asked
to send past one the peer advertised (§4.1, §4.6). Conflict is a retransmission
that disagrees with what arrived before, or a final size contradicting one already
known (§2.2, §4.5) — which RFC 9000 makes a connection error.
Assembler
pub struct Assembler {
consumed : UInt64
runs : Array[(UInt64, Bytes)]
final_size : UInt64?
limit : UInt64
}A stream's reassembly buffer. consumed is the next offset the reader has not taken;
the runs beyond it are sorted, non-overlapping, and each starts at or after it.
Assembler::buffered
How many bytes are buffered ahead of the cursor.
Assembler::complete
Whether the whole stream has arrived and been read.
Assembler::consumed
The next contiguous offset the reader has taken.
Assembler::final_size
The stream's final size, once a fin has fixed it.
Assembler::insert
Take a fragment at offset, with fin marking it the last.
A fragment wholly behind the cursor is dropped; one that overlaps buffered bytes with
different values, or contradicts a known final size, is refused — §2.2 requires a
retransmission to carry the same bytes, so disagreement is the peer misbehaving.
Assembler::new
A fresh assembler at the start of a stream.
Budget
A connection's send windows: the connection-wide one and one per stream, each opened
at the peer's initial per-stream maximum when the stream is first written to.
Budget::available
How much may go out on stream id right now: the smaller of the connection's window
and the stream's (§4.1).
Budget::connection
What may still go out across all streams together.
Budget::new
A budget at the peer's initial connection-wide and per-stream maxima, which come from
its transport parameters (RFC 9000 §18.2).
Budget::on_max_data
Raise the connection-wide limit from a MAX_DATA frame.
Budget::on_max_stream_data
Raise stream id's limit from a MAX_STREAM_DATA frame.
Budget::spend
Account for n bytes on stream id, against both windows. Both are checked before
either is charged, so a refusal leaves neither half spent.
Chunk
Credit
pub struct Credit {
spent : UInt64
limit : UInt64
}The send side of one window: how much has gone out against the limit the peer gave.
Credit::available
How much more may go out right now — zero when blocked.
Credit::blocked
Whether the window is spent, which is the STREAM_DATA_BLOCKED and DATA_BLOCKED
condition.
Credit::grant
Adopt a limit from a MAX_DATA or MAX_STREAM_DATA frame. A limit only ever rises, so
an old frame arriving late is ignored rather than shrinking the window (§4.1).
Credit::new
A send window at the peer's initial maximum.
Direction
Incoming
type IncomingOne receiving stream: its assembler, its own window, and the highest offset seen,
which is what the connection-wide window is charged against.
Initiator
Out
Quota
pub struct Quota {
limit : UInt64
opened : UInt64
}How many streams of one kind the peer may still open (RFC 9000 §4.6), and how many it
has. A peer that opens past the limit is a connection error, and without this an
endpoint would let one hold open as many as it liked.
Quota::grant
Adopt a limit from a MAX_STREAMS frame; as with data, a limit only rises.
Receiving
The receiving part's state (§3.2).
Receiving::next
The state after event (§3.2). A stream may be reset from any state short of a
terminal one; the read events apply only once the data or the reset has arrived.
RecvEvent
What reached the receiving part: a STREAM frame, with fin fixing the final size;
all the data up to that size; the application reading it all; a RESET_STREAM; the
application being told of that reset.
Scheduler
A round-robin scheduler over a connection's sending streams, bounded by the send
budget and by how much one frame carries.
Scheduler::new
A scheduler over budget, with frames capped at frame bytes.
Scheduler::next
The next decision, or None when no stream can send — all drained, or every one of
them blocked by flow control.
Streams take turns: whichever sent last goes to the back, so one stream with a great
deal queued cannot starve the rest.
Scheduler::on_max_data
Raise the connection-wide send limit from a MAX_DATA frame.
Scheduler::on_max_stream_data
Raise stream id's send limit from a MAX_STREAM_DATA frame.
Scheduler::queue
Queue n more bytes to send on stream id.
SendEvent
What the sending part did: wrote a STREAM frame, with fin on the last one; had all
its data acknowledged; sent a RESET_STREAM; had that reset acknowledged.
Sending
The sending part's state (§3.1).
Sending::next
The state after event (§3.1). A stream may be reset from any state short of a
terminal one; writing after a terminal or reset state is refused.
Streams
A connection's receiving streams and its connection-wide window.
Streams::max_data
The new MAX_DATA to advertise, or None when the gain would not be worth the frame
(RFC 9000 §4.1).
Streams::max_stream_data
The new MAX_STREAM_DATA to advertise on id, or None.
Streams::new
Streams advertising data of connection-wide credit and stream_data per stream,
admitting bidi and uni peer-opened streams of each kind (RFC 9000 §4.6).
server says which side this is, so a peer's stream is told from our own. The stream
quotas default to a hundred each, which is what quic-go and quiche both start at;
leave them out and they apply, or pass a Quota to set them from the transport
parameters that were actually negotiated.
Streams::on_stream
Take a STREAM frame for id carrying data at offset, fin on the last fragment.
Enforces the stream quota, then both flow-control windows, then reassembles, and
answers with the bytes now readable — charged against both windows as they go out,
because from the connection's point of view delivered is consumed.
Streams::read
Any further contiguous bytes readable on id, empty when the stream is unknown or
nothing new is contiguous.
Window
pub struct Window {
received : UInt64
consumed : UInt64
limit : UInt64
size : UInt64
ratio : Double
}The receive side of one window: the peer may send up to the limit we advertised, and
the limit moves up as the application consumes what arrived.
Window::arrived
Record that data up to absolute offset offset has arrived. Refused when the peer
passed the limit we advertised, which §4.1 makes a connection error.
Window::consume
Account for the application taking n more bytes, which frees window space.
Window::consumed
How much the application has taken.
Window::grant
Issue a new limit — what has been consumed plus a window — and answer with it: the
MAX_DATA or MAX_STREAM_DATA value to send. The mirror of Credit::grant, which is
how the other end takes it.
Window::new
A receive window of size bytes, which is also the initial advertised limit.
frame
let frame : UInt64How many bytes of stream data one frame carries at most.
A QUIC packet must fit the path, and 1200 is the datagram every path is required to
carry (RFC 9000 §14); the rest of that goes to the header and the AEAD tag, so a
kilobyte of payload leaves room without needing to know the header's exact shape.
id_of
The ID of the seq-th stream of that kind, counting from zero.
is_local
fn is_local(id : UInt64, server~ : Bool) -> BoolWhether this endpoint opened stream id.
is_writable
fn is_writable(id : UInt64, server~ : Bool) -> BoolWhether this endpoint may send on stream id: one it opened, or a bidirectional one
the peer opened. A peer's unidirectional stream is receive-only (§2.1, §3).
limit
let limit : UInt64How many bytes an assembler will hold ahead of the read cursor before refusing more.
A connection's receive window already bounds this, and a megabyte is what quiche
advertises per stream by default; the limit is here so an assembler used on its own
is bounded too.
ratio
let ratio : DoubleHow much of a window must become reclaimable before advertising a new limit is worth
a frame. Half a window is what quiche uses; RFC 9000 §4.1 leaves it open, saying only
that an endpoint should avoid a frame per byte.
sequence
fn sequence(id : UInt64) -> UInt64The stream's sequence number within its kind — the ID with its low two bits dropped.
Source Files
Install
Download zipmoonquic — the QUIC transport for MoonBit (RFC 9000/9001/9002): packets, frames, loss recovery, congestion control, streams and flow control, bytes in and events out. No sockets; the handshake is moontls' and HTTP/3 is moonhttp's.
quicrfc9000rfc9001transportmoonbit
Apache-2.0
Updated 2 hours ago
75 downloadsDependencies