Re: Design Issue: Life-cycle of a Stream

[William Chan (陈智昌) <[e-mail]>]

Thanks for sending this email. This is great. I'll chime in with my
personal interpretations.

On Wed, May 1, 2013 at 2:03 PM, James M Snell <[e-mail]> wrote:

> The current spec is rather vague on the complete life-cycle of a
> stream within a session. Aside from discussing how the Mommy Endpoint
> and the Daddy Endpoint get together, we ought to take just a bit of
> time to make sure we're all on the same page...
>
> In a separate thread, several of us discussed stream creation...
> specifically, how is a stream initiated. Let's see if we can formalize
> the process and the language. I've written the following out as
> statements, if you disagree with the statement or see it a different
> way, lemme know! Some of this is obvious and well established, I'm
> documenting it here just to make sure we have the complete picture
> captured. I've marked the items that appear to me to be the most
> controversial with an asterisk.
>
> 1. Streams are initialized or opened by sending a HEADERS or
> HEADERS+PRIORITY frame that uses a previously unused stream
> identifier.
>
> 2. Only HEADERS and HEADERS+PRIORITY frames are used to open a stream.
>
> 3. PUSH_PROMISE frames reserve a stream identifier but do not open the
> stream.
>
> 4. Promised streams are only opened by sending a subsequent HEADERS or
> HEADERS+PRIORITY frame that uses the reserved stream identifier.
>
> 5. All streams are either fully open, half-closed by the client,
> half-closed by the server, or fully closed.
>
> 6. All promised streams are associated with an originating "parent" stream.
>

For HTTP/2 I think this totally makes sense and this is the right
interpretation. Again, if we assume the framing layer is separate from
HTTP/2 usage, then this might not be good to require.


> 7. A stream is half-closed by sending a frame with the FINAL bit set.
>
> 8. A stream becomes fully-closed when either: a) both endpoints send
> frames with the FINAL bit set or b) either endpoint sends an RST_FRAME
> with that streams identifier.
>
> 9*. Promised streams are automatically half-closed for the recipient.
> That is, when the server sends a PUSH_PROMISE to a client, that
> streams becomes automatically half-closed for the client. The only
> frame the client can send back to the server for that stream are
> RST_STREAM frames.
>

I think we agreed on this interpretation in the last email thread you
raised on PUSH_PROMISE.


>
>   -- or --
>
> 9*. Promised streams are handled just like regular streams. The server
> opens the stream and half-closes. The stream does not fully close
> until either the client half-closes it or a RST_STREAM frame is sent
> for that stream.
>
> 10*. Sending an RST_FRAME for a parent stream fully closes that stream
> as well as all associated promised streams.


>   -- or --
>
> 10*. Sending an RST_FRAME for a parent stream only closes that stream
> and has no affect on associated promised streams.
>

I forget if we settled this issue or not. But I'm inclined to prefer your
second interpretation here. I'd rather explicitly reset streams.


>
> 11*. Fully closing a parent stream using symmetric half-closes will
> fully close all associated promised streams.
>
>   -- or --
>
> 11*. Fully closing a parent stream using symmetric half-closes has no
> affect on associated promised streams.
>

The latter. I believe the spec only says we have to promise the streams
before the parent stream closes. We don't have to even open the streams
yet. This is probably ideal since the parent stream is likely the main
document, and the main document is likely to contain the most important
data. One might say just send all the data and delay the sending of a
0-byte DATA frame with the FINAL flag set, but I see no reason to require
that. Speaking as an implementer, it's easier for the browser to receive
the FINAL flag ASAP (there are some implementation complications with
multiple readers and single writer, where multiple "readers" are requesting
a resource at the same URL, and are sharing the same response...we stream
the response to a single reader and only when we know it to be complete do
we stream to all other readers. don't ask me why, it's complicated and
relates to our cache implementation).


>
> 12. Half or fully closing a promised stream has no impact on the
> parent stream or any associated sibling promised streams.


> Ok, so that covers the lifecycle.. let's talk about processing.. this
> is largely a reiteration of my previous note on this but I want to
> make sure I've hit all the major points in how this is categorized.
>

I don't really want to start calling this Tier Number. I call things by the
relevant layer. Everyone else at the in person meetings has done the same.
I know jpinner@ has organized his code accordingly to his view of the
layers. I'd like us to standardize terminology on that.


>
> Tier 1: Includes the following...
>
> A. Reception and basic parsing of frames. "Basic parsing" here means
> looking at the header bytes to determine the frame type, making note
> of the flags, frame size and stream identifier, and performing any
> necessary header block decompression and state management.
>
> B. Handling of all session frames (stream id #0). This means that
> upgrade negotiation, SETTINGS, PING, flow control and session level
> error handling are all Tier 1 processes.
>
> C. Basic lifecycle handling of stream frames. This includes
> determination of whether a stream is open or closed, whether or not
> additional frames are allowed for a stream, validation of proper
> stream id use, reservation of stream id's with push_promise, and
> handling of the FINAL flag.
>
> Tier 2: Includes the following...
>
> A. Frame-type specific processing. Validation and handling of frame
> payloads and frame-specific flags, not including header block
> processing (which is tier 1)
>
> B. Additional stream-level error handling not related to stream-lifecycle
>
> Tier 3: Includes all application-level handling (HTTP Semantics)
>
> So, when we say things like "an endpoint must be prepared to continue
> receiving frames on a closed stream", we mean to say that "an endpoint
> must be prepared to do tier 1 processing on all frames, even those
> sent for closed streams."
>
> Please weigh in on whatever items y'all feel are controversial. I'll
> work up proposed spec edits based on whatever feedback is received.
>
> - James
>
>