242 lines
7.2 KiB
Go
242 lines
7.2 KiB
Go
// Copyright 2014 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package http2
|
|
|
|
import "fmt"
|
|
|
|
// WriteScheduler is the interface implemented by HTTP/2 write schedulers.
|
|
// Methods are never called concurrently.
|
|
type WriteScheduler interface {
|
|
// OpenStream opens a new stream in the write scheduler.
|
|
// It is illegal to call this with streamID=0 or with a streamID that is
|
|
// already open -- the call may panic.
|
|
OpenStream(streamID uint32, options OpenStreamOptions)
|
|
|
|
// CloseStream closes a stream in the write scheduler. Any frames queued on
|
|
// this stream should be discarded. It is illegal to call this on a stream
|
|
// that is not open -- the call may panic.
|
|
CloseStream(streamID uint32)
|
|
|
|
// AdjustStream adjusts the priority of the given stream. This may be called
|
|
// on a stream that has not yet been opened or has been closed. Note that
|
|
// RFC 7540 allows PRIORITY frames to be sent on streams in any state. See:
|
|
// https://tools.ietf.org/html/rfc7540#section-5.1
|
|
AdjustStream(streamID uint32, priority PriorityParam)
|
|
|
|
// Push queues a frame in the scheduler. In most cases, this will not be
|
|
// called with wr.StreamID()!=0 unless that stream is currently open. The one
|
|
// exception is RST_STREAM frames, which may be sent on idle or closed streams.
|
|
Push(wr FrameWriteRequest)
|
|
|
|
// Pop dequeues the next frame to write. Returns false if no frames can
|
|
// be written. Frames with a given wr.StreamID() are Pop'd in the same
|
|
// order they are Push'd.
|
|
Pop() (wr FrameWriteRequest, ok bool)
|
|
}
|
|
|
|
// OpenStreamOptions specifies extra options for WriteScheduler.OpenStream.
|
|
type OpenStreamOptions struct {
|
|
// PusherID is zero if the stream was initiated by the client. Otherwise,
|
|
// PusherID names the stream that pushed the newly opened stream.
|
|
PusherID uint32
|
|
}
|
|
|
|
// FrameWriteRequest is a request to write a frame.
|
|
type FrameWriteRequest struct {
|
|
// write is the interface value that does the writing, once the
|
|
// WriteScheduler has selected this frame to write. The write
|
|
// functions are all defined in write.go.
|
|
write writeFramer
|
|
|
|
// stream is the stream on which this frame will be written.
|
|
// nil for non-stream frames like PING and SETTINGS.
|
|
stream *stream
|
|
|
|
// done, if non-nil, must be a buffered channel with space for
|
|
// 1 message and is sent the return value from write (or an
|
|
// earlier error) when the frame has been written.
|
|
done chan error
|
|
}
|
|
|
|
// StreamID returns the id of the stream this frame will be written to.
|
|
// 0 is used for non-stream frames such as PING and SETTINGS.
|
|
func (wr FrameWriteRequest) StreamID() uint32 {
|
|
if wr.stream == nil {
|
|
if se, ok := wr.write.(StreamError); ok {
|
|
// (*serverConn).resetStream doesn't set
|
|
// stream because it doesn't necessarily have
|
|
// one. So special case this type of write
|
|
// message.
|
|
return se.StreamID
|
|
}
|
|
return 0
|
|
}
|
|
return wr.stream.id
|
|
}
|
|
|
|
// DataSize returns the number of flow control bytes that must be consumed
|
|
// to write this entire frame. This is 0 for non-DATA frames.
|
|
func (wr FrameWriteRequest) DataSize() int {
|
|
if wd, ok := wr.write.(*writeData); ok {
|
|
return len(wd.p)
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// Consume consumes min(n, available) bytes from this frame, where available
|
|
// is the number of flow control bytes available on the stream. Consume returns
|
|
// 0, 1, or 2 frames, where the integer return value gives the number of frames
|
|
// returned.
|
|
//
|
|
// If flow control prevents consuming any bytes, this returns (_, _, 0). If
|
|
// the entire frame was consumed, this returns (wr, _, 1). Otherwise, this
|
|
// returns (consumed, rest, 2), where 'consumed' contains the consumed bytes and
|
|
// 'rest' contains the remaining bytes. The consumed bytes are deducted from the
|
|
// underlying stream's flow control budget.
|
|
func (wr FrameWriteRequest) Consume(n int32) (FrameWriteRequest, FrameWriteRequest, int) {
|
|
var empty FrameWriteRequest
|
|
|
|
// Non-DATA frames are always consumed whole.
|
|
wd, ok := wr.write.(*writeData)
|
|
if !ok || len(wd.p) == 0 {
|
|
return wr, empty, 1
|
|
}
|
|
|
|
// Might need to split after applying limits.
|
|
allowed := wr.stream.flow.available()
|
|
if n < allowed {
|
|
allowed = n
|
|
}
|
|
if wr.stream.sc.maxFrameSize < allowed {
|
|
allowed = wr.stream.sc.maxFrameSize
|
|
}
|
|
if allowed <= 0 {
|
|
return empty, empty, 0
|
|
}
|
|
if len(wd.p) > int(allowed) {
|
|
wr.stream.flow.take(allowed)
|
|
consumed := FrameWriteRequest{
|
|
stream: wr.stream,
|
|
write: &writeData{
|
|
streamID: wd.streamID,
|
|
p: wd.p[:allowed],
|
|
// Even if the original had endStream set, there
|
|
// are bytes remaining because len(wd.p) > allowed,
|
|
// so we know endStream is false.
|
|
endStream: false,
|
|
},
|
|
// Our caller is blocking on the final DATA frame, not
|
|
// this intermediate frame, so no need to wait.
|
|
done: nil,
|
|
}
|
|
rest := FrameWriteRequest{
|
|
stream: wr.stream,
|
|
write: &writeData{
|
|
streamID: wd.streamID,
|
|
p: wd.p[allowed:],
|
|
endStream: wd.endStream,
|
|
},
|
|
done: wr.done,
|
|
}
|
|
return consumed, rest, 2
|
|
}
|
|
|
|
// The frame is consumed whole.
|
|
// NB: This cast cannot overflow because allowed is <= math.MaxInt32.
|
|
wr.stream.flow.take(int32(len(wd.p)))
|
|
return wr, empty, 1
|
|
}
|
|
|
|
// String is for debugging only.
|
|
func (wr FrameWriteRequest) String() string {
|
|
var des string
|
|
if s, ok := wr.write.(fmt.Stringer); ok {
|
|
des = s.String()
|
|
} else {
|
|
des = fmt.Sprintf("%T", wr.write)
|
|
}
|
|
return fmt.Sprintf("[FrameWriteRequest stream=%d, ch=%v, writer=%v]", wr.StreamID(), wr.done != nil, des)
|
|
}
|
|
|
|
// replyToWriter sends err to wr.done and panics if the send must block
|
|
// This does nothing if wr.done is nil.
|
|
func (wr *FrameWriteRequest) replyToWriter(err error) {
|
|
if wr.done == nil {
|
|
return
|
|
}
|
|
select {
|
|
case wr.done <- err:
|
|
default:
|
|
panic(fmt.Sprintf("unbuffered done channel passed in for type %T", wr.write))
|
|
}
|
|
wr.write = nil // prevent use (assume it's tainted after wr.done send)
|
|
}
|
|
|
|
// writeQueue is used by implementations of WriteScheduler.
|
|
type writeQueue struct {
|
|
s []FrameWriteRequest
|
|
}
|
|
|
|
func (q *writeQueue) empty() bool { return len(q.s) == 0 }
|
|
|
|
func (q *writeQueue) push(wr FrameWriteRequest) {
|
|
q.s = append(q.s, wr)
|
|
}
|
|
|
|
func (q *writeQueue) shift() FrameWriteRequest {
|
|
if len(q.s) == 0 {
|
|
panic("invalid use of queue")
|
|
}
|
|
wr := q.s[0]
|
|
// TODO: less copy-happy queue.
|
|
copy(q.s, q.s[1:])
|
|
q.s[len(q.s)-1] = FrameWriteRequest{}
|
|
q.s = q.s[:len(q.s)-1]
|
|
return wr
|
|
}
|
|
|
|
// consume consumes up to n bytes from q.s[0]. If the frame is
|
|
// entirely consumed, it is removed from the queue. If the frame
|
|
// is partially consumed, the frame is kept with the consumed
|
|
// bytes removed. Returns true iff any bytes were consumed.
|
|
func (q *writeQueue) consume(n int32) (FrameWriteRequest, bool) {
|
|
if len(q.s) == 0 {
|
|
return FrameWriteRequest{}, false
|
|
}
|
|
consumed, rest, numresult := q.s[0].Consume(n)
|
|
switch numresult {
|
|
case 0:
|
|
return FrameWriteRequest{}, false
|
|
case 1:
|
|
q.shift()
|
|
case 2:
|
|
q.s[0] = rest
|
|
}
|
|
return consumed, true
|
|
}
|
|
|
|
type writeQueuePool []*writeQueue
|
|
|
|
// put inserts an unused writeQueue into the pool.
|
|
func (p *writeQueuePool) put(q *writeQueue) {
|
|
for i := range q.s {
|
|
q.s[i] = FrameWriteRequest{}
|
|
}
|
|
q.s = q.s[:0]
|
|
*p = append(*p, q)
|
|
}
|
|
|
|
// get returns an empty writeQueue.
|
|
func (p *writeQueuePool) get() *writeQueue {
|
|
ln := len(*p)
|
|
if ln == 0 {
|
|
return new(writeQueue)
|
|
}
|
|
x := ln - 1
|
|
q := (*p)[x]
|
|
(*p)[x] = nil
|
|
*p = (*p)[:x]
|
|
return q
|
|
}
|