[quicwg/base-drafts] Unidirectional Streams (#643)

[Martin Thomson <[e-mail]>]

This is a fairly fundamental change.  Let me try to describe what this does, and what it doesn't do.

## Transport Changes

Streams are unidirectional.  Each has three states: idle, open, and closed.  I separated the transitions for sending and receiving because that turned out to be easier to explain.  The reordering thing makes them different in subtle ways.

That's all.  The changes in transport are relatively small and they simplify streams a lot.  That it also makes the transport more generic is a nice bonus.

## HTTP Changes

This is where the bulk of the changes are.

### Stream Correlation

Previously request and response were implicitly correlated, as was the data correlated with the request or response headers.  With this change, that correlation each stream has a header that explicitly correlates these.

There are 5 types of stream: connection control, request, response, data, and push.  The first two have a simple header that has a type.  The next two reference another stream in their header, which ties request to response and data to request or response.  Push references a response stream and a PUSH_PROMISE on that stream.

I chose backward references rather than forward references for two reasons.  First, request and response correlation can't use forward references because that would mean the client would be exerting (uncoordinated) control over server streams.  Second, that gives the server the most flexibility in terms of how it answers requests (see #281).  The cost of using backward references is that endpoints have to check that the backward references aren't bad, either referencing the wrong type of stream, or with multiple references to the same stream.

The presence or absence of a message body is signaled after the initial header block using a HAS_BODY frame.  This empty frame indicates that another stream will include the body of the message - or a promise for a body.  I would like to eliminate this stream split.  See #245 and #557 for more details on that, though we need to fix #176 first, which brings us back to QPACK/QCRAM again.

### Prioritization

This changes prioritization so that it identifies requests.  I only made the minimal changes here, which means that this doesn't fix #441 at the same time, I've left that for later (see below).

### Cancelling Pushes

Because server push doesn't create streams with PUSH_PROMISE, I had to create a way to cancel them between the time that the PUSH_PROMISE is sent and when the push stream is created.  That's called RST_PUSH.

## Things That Need Improvement

I haven't based this on #171.  I think that functionality is good, but the last time I looked at the PR I didn't like some of the changes Mike made there.  (That's a taste thing.)  This really assumes that we accept something very much like #171.

This really needs QPACK/QCRAM.  Right now, it is impossible to cancel some types of request using RST_STREAM because not all messages will have a body (#176 again).  On balance, given that bodies are what you really want to kill, it's not disastrous, but it's a problem nonetheless.  I think that we all agree that this is something that we need to fix, but we haven't reached the point where we agree on the details of the fix.

## Things That Want Improvement

This also really wants headers and data on the same stream .  It doesn't exactly need that, but merging the streams would make things a lot easy, both conceptually and structurally.

I chose the simplest possible encoding for all of the fields that I touched.  That means that stream IDs are all 32 bits in size and the HAS_BODY frame takes an entire 9 octets.  For things that are that common, there are many ways in which byte efficiency could be improved.

I chose to use stream ID (and PUSH_PROMISE indexes) to correlate things rather than mint a new identifier.  It's tempting to move to an explicit identifier for correlation, which might contribute to fixing other issues (see discussion on priority and #441 above).  This would simplify RST_PUSH as well.

# Fixes

Closes #515, #240, #281, #175.
You can view, comment on, or merge this pull request online at:

  https://github.com/quicwg/base-drafts/pull/643

-- Commit Summary --

  * WIP
  * Initial cut at unidirectional streams
  * Fix PRIORITY to refer to requests
  * RST_PUSH frame for early cancellation of pushes
  * This was a common misunderstanding with h2
  * Lazy

-- File Changes --

    M draft-ietf-quic-http.md (493)
    M draft-ietf-quic-transport.md (290)

-- Patch Links --

https://github.com/quicwg/base-drafts/pull/643.patch
https://github.com/quicwg/base-drafts/pull/643.diff

-- 
You are receiving this because you are subscribed to this thread.
Reply to this email directly or view it on GitHub:
https://github.com/quicwg/base-drafts/pull/643