pub enum H2WritableStateTarget {
Done(MuxResult),
Flush,
WriteStreams,
}Expand description
What ConnectionH2::dispatch_writable_state wants its caller to do with
the (H2State, Position) arm it just took.
The connection-level write pass’s own protocol, built the way
H2FinalizeTarget builds the stream-level one: the core answers a step,
the shell performs the socket work, and the core is told what the socket
then said. Self::Flush carries NO answer with it — the post-flush query
can only enter the core through
ConnectionH2::dispatch_writable_state_after_flush’s own parameter,
which is what stops “does rustls hold records” and “did the kernel take
them” from ever being read off one binding. h2_close::TlsFlushPhase
states why those are two questions and what conflating them costs.
Not H2FinalizeTarget reused. That enum’s SkipFlush answers a question
no close arm asks: nothing writes to the socket between this dispatch and
its flush, so no vectored write can have attempted it as a side effect, and
sharing the enum would force a named-impossible arm into the shell’s match.
It is the argument h2_close already makes against widening CloseAction
with FinalizeAction’s readiness answers, applied the other way round.
Variants§
Done(MuxResult)
The arm ended the pass by itself: this is the pass’s result. Every arm
but the two below answers this, the H2State::GoAway arm’s
departed-peer and nothing-pending answers included.
Flush
The H2State::GoAway arm asks for the second flush of this pass:
perform H2Shell::flush_tls_records, read
H2Shell::tls_wants_write again, and answer with
ConnectionH2::dispatch_writable_state_after_flush.
The preamble already attempted one flush this pass; this one re-checks
because a close is about to be decided on the answer. Both are
deliberate — see h2_close’s module doc.
WriteStreams
A proxying state: run H2Shell::write_streams, whose result is
the pass’s. It is the caller’s to run for the same reason the flush is,
and it is why the dispatch takes neither Context nor Endpoint.