README

This is a work-in-progress HTTP/2 implementation for Go.

It will eventually live in the Go standard library and won't require
any changes to your code to use.  It will just be automatic.

Status:

* The server support is pretty good. A few things are missing
  but are being worked on.
* The client work has just started but shares a lot of code
  is coming along much quicker.

Docs are at https://godoc.org/golang.org/x/net/http2

Demo test server at https://http2.golang.org/

Help & bug reports welcome!

Contributing: https://golang.org/doc/contribute.html
Bugs:         https://golang.org/issue/new?title=x/net/http2:+
Expand ▾ Collapse ▴

Documentation

Overview

    Package http2 implements the HTTP/2 protocol.

    This package is low-level and intended to be used directly by very few people. Most users will use it indirectly through the automatic use by the net/http package (from Go 1.6 and later). For use in earlier Go versions see ConfigureServer. (Transport support requires Go 1.6 or later)

    See https://http2.github.io/ for more information on HTTP/2.

    See https://http2.golang.org/ for a test server running this code.

    Index

    Constants

    View Source
    const (
    	// ClientPreface is the string that must be sent by new
    	// connections from clients.
    	ClientPreface = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
    
    	// NextProtoTLS is the NPN/ALPN protocol negotiated during
    	// HTTP/2's TLS setup.
    	NextProtoTLS = "h2"
    )
    View Source
    const TrailerPrefix = "Trailer:"

      TrailerPrefix is a magic prefix for ResponseWriter.Header map keys that, if present, signals that the map entry is actually for the response trailers, and not the response headers. The prefix is stripped after the ServeHTTP call finishes and the values are sent in the trailers.

      This mechanism is intended only for trailers that are not known prior to the headers being written. If the set of trailers is fixed or known before the header is written, the normal Go trailers mechanism is preferred:

      https://golang.org/pkg/net/http/#ResponseWriter
      https://golang.org/pkg/net/http/#example_ResponseWriter_trailers
      

      Variables

      View Source
      var (
      	ErrRecursivePush    = errors.New("http2: recursive push not allowed")
      	ErrPushLimitReached = errors.New("http2: push would exceed peer's SETTINGS_MAX_CONCURRENT_STREAMS")
      )

        Push errors.

        View Source
        var DebugGoroutines = os.Getenv("DEBUG_HTTP2_GOROUTINES") == "1"
        View Source
        var ErrFrameTooLarge = errors.New("http2: frame too large")

          ErrFrameTooLarge is returned from Framer.ReadFrame when the peer sends a frame that is larger than declared with SetMaxReadFrameSize.

          View Source
          var ErrNoCachedConn error = noCachedConnError{}
          View Source
          var (
          	VerboseLogs bool
          )

          Functions

          func ConfigureServer

          func ConfigureServer(s *http.Server, conf *Server) error

            ConfigureServer adds HTTP/2 support to a net/http Server.

            The configuration conf may be nil.

            ConfigureServer must be called before s begins serving.

            func ConfigureTransport

            func ConfigureTransport(t1 *http.Transport) error

              ConfigureTransport configures a net/http HTTP/1 Transport to use HTTP/2. It returns an error if t1 has already been HTTP/2-enabled.

              Use ConfigureTransports instead to configure the HTTP/2 Transport.

              Types

              type ClientConn

              type ClientConn struct {
              	// contains filtered or unexported fields
              }

                ClientConn is the state of a single HTTP/2 client connection to an HTTP/2 server.

                func (*ClientConn) CanTakeNewRequest

                func (cc *ClientConn) CanTakeNewRequest() bool

                  CanTakeNewRequest reports whether the connection can take a new request, meaning it has not been closed or received or sent a GOAWAY.

                  func (*ClientConn) Close

                  func (cc *ClientConn) Close() error

                    Close closes the client connection immediately.

                    In-flight requests are interrupted. For a graceful shutdown, use Shutdown instead.

                    func (*ClientConn) Ping

                    func (cc *ClientConn) Ping(ctx context.Context) error

                      Ping sends a PING frame to the server and waits for the ack.

                      func (*ClientConn) RoundTrip

                      func (cc *ClientConn) RoundTrip(req *http.Request) (*http.Response, error)

                      func (*ClientConn) Shutdown

                      func (cc *ClientConn) Shutdown(ctx context.Context) error

                        Shutdown gracefully close the client connection, waiting for running streams to complete.

                        type ClientConnPool

                        type ClientConnPool interface {
                        	GetClientConn(req *http.Request, addr string) (*ClientConn, error)
                        	MarkDead(*ClientConn)
                        }

                          ClientConnPool manages a pool of HTTP/2 client connections.

                          type ConnectionError

                          type ConnectionError ErrCode

                            ConnectionError is an error that results in the termination of the entire connection.

                            func (ConnectionError) Error

                            func (e ConnectionError) Error() string

                            type ContinuationFrame

                            type ContinuationFrame struct {
                            	FrameHeader
                            	// contains filtered or unexported fields
                            }

                              A ContinuationFrame is used to continue a sequence of header block fragments. See http://http2.github.io/http2-spec/#rfc.section.6.10

                              func (*ContinuationFrame) HeaderBlockFragment

                              func (f *ContinuationFrame) HeaderBlockFragment() []byte

                              func (*ContinuationFrame) HeadersEnded

                              func (f *ContinuationFrame) HeadersEnded() bool

                              type DataFrame

                              type DataFrame struct {
                              	FrameHeader
                              	// contains filtered or unexported fields
                              }

                                A DataFrame conveys arbitrary, variable-length sequences of octets associated with a stream. See http://http2.github.io/http2-spec/#rfc.section.6.1

                                func (*DataFrame) Data

                                func (f *DataFrame) Data() []byte

                                  Data returns the frame's data octets, not including any padding size byte or padding suffix bytes. The caller must not retain the returned memory past the next call to ReadFrame.

                                  func (*DataFrame) StreamEnded

                                  func (f *DataFrame) StreamEnded() bool

                                  type ErrCode

                                  type ErrCode uint32

                                    An ErrCode is an unsigned 32-bit error code as defined in the HTTP/2 spec.

                                    const (
                                    	ErrCodeNo                 ErrCode = 0x0
                                    	ErrCodeProtocol           ErrCode = 0x1
                                    	ErrCodeInternal           ErrCode = 0x2
                                    	ErrCodeFlowControl        ErrCode = 0x3
                                    	ErrCodeSettingsTimeout    ErrCode = 0x4
                                    	ErrCodeStreamClosed       ErrCode = 0x5
                                    	ErrCodeFrameSize          ErrCode = 0x6
                                    	ErrCodeRefusedStream      ErrCode = 0x7
                                    	ErrCodeCancel             ErrCode = 0x8
                                    	ErrCodeCompression        ErrCode = 0x9
                                    	ErrCodeConnect            ErrCode = 0xa
                                    	ErrCodeEnhanceYourCalm    ErrCode = 0xb
                                    	ErrCodeInadequateSecurity ErrCode = 0xc
                                    	ErrCodeHTTP11Required     ErrCode = 0xd
                                    )

                                    func (ErrCode) String

                                    func (e ErrCode) String() string

                                    type Flags

                                    type Flags uint8

                                      Flags is a bitmask of HTTP/2 flags. The meaning of flags varies depending on the frame type.

                                      const (
                                      	// Data Frame
                                      	FlagDataEndStream Flags = 0x1
                                      	FlagDataPadded    Flags = 0x8
                                      
                                      	// Headers Frame
                                      	FlagHeadersEndStream  Flags = 0x1
                                      	FlagHeadersEndHeaders Flags = 0x4
                                      	FlagHeadersPadded     Flags = 0x8
                                      	FlagHeadersPriority   Flags = 0x20
                                      
                                      	// Settings Frame
                                      	FlagSettingsAck Flags = 0x1
                                      
                                      	// Ping Frame
                                      	FlagPingAck Flags = 0x1
                                      
                                      	// Continuation Frame
                                      	FlagContinuationEndHeaders Flags = 0x4
                                      
                                      	FlagPushPromiseEndHeaders Flags = 0x4
                                      	FlagPushPromisePadded     Flags = 0x8
                                      )

                                        Frame-specific FrameHeader flag bits.

                                        func (Flags) Has

                                        func (f Flags) Has(v Flags) bool

                                          Has reports whether f contains all (0 or more) flags in v.

                                          type Frame

                                          type Frame interface {
                                          	Header() FrameHeader
                                          	// contains filtered or unexported methods
                                          }

                                            A Frame is the base interface implemented by all frame types. Callers will generally type-assert the specific frame type: *HeadersFrame, *SettingsFrame, *WindowUpdateFrame, etc.

                                            Frames are only valid until the next call to Framer.ReadFrame.

                                            type FrameHeader

                                            type FrameHeader struct {
                                            
                                            	// Type is the 1 byte frame type. There are ten standard frame
                                            	// types, but extension frame types may be written by WriteRawFrame
                                            	// and will be returned by ReadFrame (as UnknownFrame).
                                            	Type FrameType
                                            
                                            	// Flags are the 1 byte of 8 potential bit flags per frame.
                                            	// They are specific to the frame type.
                                            	Flags Flags
                                            
                                            	// Length is the length of the frame, not including the 9 byte header.
                                            	// The maximum size is one byte less than 16MB (uint24), but only
                                            	// frames up to 16KB are allowed without peer agreement.
                                            	Length uint32
                                            
                                            	// StreamID is which stream this frame is for. Certain frames
                                            	// are not stream-specific, in which case this field is 0.
                                            	StreamID uint32
                                            	// contains filtered or unexported fields
                                            }

                                              A FrameHeader is the 9 byte header of all HTTP/2 frames.

                                              See http://http2.github.io/http2-spec/#FrameHeader

                                              func ReadFrameHeader

                                              func ReadFrameHeader(r io.Reader) (FrameHeader, error)

                                                ReadFrameHeader reads 9 bytes from r and returns a FrameHeader. Most users should use Framer.ReadFrame instead.

                                                func (FrameHeader) Header

                                                func (h FrameHeader) Header() FrameHeader

                                                  Header returns h. It exists so FrameHeaders can be embedded in other specific frame types and implement the Frame interface.

                                                  func (FrameHeader) String

                                                  func (h FrameHeader) String() string

                                                  type FrameType

                                                  type FrameType uint8

                                                    A FrameType is a registered frame type as defined in http://http2.github.io/http2-spec/#rfc.section.11.2

                                                    const (
                                                    	FrameData         FrameType = 0x0
                                                    	FrameHeaders      FrameType = 0x1
                                                    	FramePriority     FrameType = 0x2
                                                    	FrameRSTStream    FrameType = 0x3
                                                    	FrameSettings     FrameType = 0x4
                                                    	FramePushPromise  FrameType = 0x5
                                                    	FramePing         FrameType = 0x6
                                                    	FrameGoAway       FrameType = 0x7
                                                    	FrameWindowUpdate FrameType = 0x8
                                                    	FrameContinuation FrameType = 0x9
                                                    )

                                                    func (FrameType) String

                                                    func (t FrameType) String() string

                                                    type FrameWriteRequest

                                                    type FrameWriteRequest struct {
                                                    	// contains filtered or unexported fields
                                                    }

                                                      FrameWriteRequest is a request to write a frame.

                                                      func (FrameWriteRequest) Consume

                                                        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 (FrameWriteRequest) DataSize

                                                        func (wr FrameWriteRequest) DataSize() int

                                                          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 (FrameWriteRequest) StreamID

                                                          func (wr FrameWriteRequest) StreamID() uint32

                                                            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 (FrameWriteRequest) String

                                                            func (wr FrameWriteRequest) String() string

                                                              String is for debugging only.

                                                              type Framer

                                                              type Framer struct {
                                                              
                                                              	// AllowIllegalWrites permits the Framer's Write methods to
                                                              	// write frames that do not conform to the HTTP/2 spec. This
                                                              	// permits using the Framer to test other HTTP/2
                                                              	// implementations' conformance to the spec.
                                                              	// If false, the Write methods will prefer to return an error
                                                              	// rather than comply.
                                                              	AllowIllegalWrites bool
                                                              
                                                              	// AllowIllegalReads permits the Framer's ReadFrame method
                                                              	// to return non-compliant frames or frame orders.
                                                              	// This is for testing and permits using the Framer to test
                                                              	// other HTTP/2 implementations' conformance to the spec.
                                                              	// It is not compatible with ReadMetaHeaders.
                                                              	AllowIllegalReads bool
                                                              
                                                              	// ReadMetaHeaders if non-nil causes ReadFrame to merge
                                                              	// HEADERS and CONTINUATION frames together and return
                                                              	// MetaHeadersFrame instead.
                                                              	ReadMetaHeaders *hpack.Decoder
                                                              
                                                              	// MaxHeaderListSize is the http2 MAX_HEADER_LIST_SIZE.
                                                              	// It's used only if ReadMetaHeaders is set; 0 means a sane default
                                                              	// (currently 16MB)
                                                              	// If the limit is hit, MetaHeadersFrame.Truncated is set true.
                                                              	MaxHeaderListSize uint32
                                                              	// contains filtered or unexported fields
                                                              }

                                                                A Framer reads and writes Frames.

                                                                func NewFramer

                                                                func NewFramer(w io.Writer, r io.Reader) *Framer

                                                                  NewFramer returns a Framer that writes frames to w and reads them from r.

                                                                  func (*Framer) ErrorDetail

                                                                  func (fr *Framer) ErrorDetail() error

                                                                    ErrorDetail returns a more detailed error of the last error returned by Framer.ReadFrame. For instance, if ReadFrame returns a StreamError with code PROTOCOL_ERROR, ErrorDetail will say exactly what was invalid. ErrorDetail is not guaranteed to return a non-nil value and like the rest of the http2 package, its return value is not protected by an API compatibility promise. ErrorDetail is reset after the next call to ReadFrame.

                                                                    func (*Framer) ReadFrame

                                                                    func (fr *Framer) ReadFrame() (Frame, error)

                                                                      ReadFrame reads a single frame. The returned Frame is only valid until the next call to ReadFrame.

                                                                      If the frame is larger than previously set with SetMaxReadFrameSize, the returned error is ErrFrameTooLarge. Other errors may be of type ConnectionError, StreamError, or anything else from the underlying reader.

                                                                      func (*Framer) SetMaxReadFrameSize

                                                                      func (fr *Framer) SetMaxReadFrameSize(v uint32)

                                                                        SetMaxReadFrameSize sets the maximum size of a frame that will be read by a subsequent call to ReadFrame. It is the caller's responsibility to advertise this limit with a SETTINGS frame.

                                                                        func (*Framer) SetReuseFrames

                                                                        func (fr *Framer) SetReuseFrames()

                                                                          SetReuseFrames allows the Framer to reuse Frames. If called on a Framer, Frames returned by calls to ReadFrame are only valid until the next call to ReadFrame.

                                                                          func (*Framer) WriteContinuation

                                                                          func (f *Framer) WriteContinuation(streamID uint32, endHeaders bool, headerBlockFragment []byte) error

                                                                            WriteContinuation writes a CONTINUATION frame.

                                                                            It will perform exactly one Write to the underlying Writer. It is the caller's responsibility to not call other Write methods concurrently.

                                                                            func (*Framer) WriteData

                                                                            func (f *Framer) WriteData(streamID uint32, endStream bool, data []byte) error

                                                                              WriteData writes a DATA frame.

                                                                              It will perform exactly one Write to the underlying Writer. It is the caller's responsibility not to violate the maximum frame size and to not call other Write methods concurrently.

                                                                              func (*Framer) WriteDataPadded

                                                                              func (f *Framer) WriteDataPadded(streamID uint32, endStream bool, data, pad []byte) error

                                                                                WriteDataPadded writes a DATA frame with optional padding.

                                                                                If pad is nil, the padding bit is not sent. The length of pad must not exceed 255 bytes. The bytes of pad must all be zero, unless f.AllowIllegalWrites is set.

                                                                                It will perform exactly one Write to the underlying Writer. It is the caller's responsibility not to violate the maximum frame size and to not call other Write methods concurrently.

                                                                                func (*Framer) WriteGoAway

                                                                                func (f *Framer) WriteGoAway(maxStreamID uint32, code ErrCode, debugData []byte) error

                                                                                func (*Framer) WriteHeaders

                                                                                func (f *Framer) WriteHeaders(p HeadersFrameParam) error

                                                                                  WriteHeaders writes a single HEADERS frame.

                                                                                  This is a low-level header writing method. Encoding headers and splitting them into any necessary CONTINUATION frames is handled elsewhere.

                                                                                  It will perform exactly one Write to the underlying Writer. It is the caller's responsibility to not call other Write methods concurrently.

                                                                                  func (*Framer) WritePing

                                                                                  func (f *Framer) WritePing(ack bool, data [8]byte) error

                                                                                  func (*Framer) WritePriority

                                                                                  func (f *Framer) WritePriority(streamID uint32, p PriorityParam) error

                                                                                    WritePriority writes a PRIORITY frame.

                                                                                    It will perform exactly one Write to the underlying Writer. It is the caller's responsibility to not call other Write methods concurrently.

                                                                                    func (*Framer) WritePushPromise

                                                                                    func (f *Framer) WritePushPromise(p PushPromiseParam) error

                                                                                      WritePushPromise writes a single PushPromise Frame.

                                                                                      As with Header Frames, This is the low level call for writing individual frames. Continuation frames are handled elsewhere.

                                                                                      It will perform exactly one Write to the underlying Writer. It is the caller's responsibility to not call other Write methods concurrently.

                                                                                      func (*Framer) WriteRSTStream

                                                                                      func (f *Framer) WriteRSTStream(streamID uint32, code ErrCode) error

                                                                                        WriteRSTStream writes a RST_STREAM frame.

                                                                                        It will perform exactly one Write to the underlying Writer. It is the caller's responsibility to not call other Write methods concurrently.

                                                                                        func (*Framer) WriteRawFrame

                                                                                        func (f *Framer) WriteRawFrame(t FrameType, flags Flags, streamID uint32, payload []byte) error

                                                                                          WriteRawFrame writes a raw frame. This can be used to write extension frames unknown to this package.

                                                                                          func (*Framer) WriteSettings

                                                                                          func (f *Framer) WriteSettings(settings ...Setting) error

                                                                                            WriteSettings writes a SETTINGS frame with zero or more settings specified and the ACK bit not set.

                                                                                            It will perform exactly one Write to the underlying Writer. It is the caller's responsibility to not call other Write methods concurrently.

                                                                                            func (*Framer) WriteSettingsAck

                                                                                            func (f *Framer) WriteSettingsAck() error

                                                                                              WriteSettingsAck writes an empty SETTINGS frame with the ACK bit set.

                                                                                              It will perform exactly one Write to the underlying Writer. It is the caller's responsibility to not call other Write methods concurrently.

                                                                                              func (*Framer) WriteWindowUpdate

                                                                                              func (f *Framer) WriteWindowUpdate(streamID, incr uint32) error

                                                                                                WriteWindowUpdate writes a WINDOW_UPDATE frame. The increment value must be between 1 and 2,147,483,647, inclusive. If the Stream ID is zero, the window update applies to the connection as a whole.

                                                                                                type GoAwayError

                                                                                                type GoAwayError struct {
                                                                                                	LastStreamID uint32
                                                                                                	ErrCode      ErrCode
                                                                                                	DebugData    string
                                                                                                }

                                                                                                  GoAwayError is returned by the Transport when the server closes the TCP connection after sending a GOAWAY frame.

                                                                                                  func (GoAwayError) Error

                                                                                                  func (e GoAwayError) Error() string

                                                                                                  type GoAwayFrame

                                                                                                  type GoAwayFrame struct {
                                                                                                  	FrameHeader
                                                                                                  	LastStreamID uint32
                                                                                                  	ErrCode      ErrCode
                                                                                                  	// contains filtered or unexported fields
                                                                                                  }

                                                                                                    A GoAwayFrame informs the remote peer to stop creating streams on this connection. See http://http2.github.io/http2-spec/#rfc.section.6.8

                                                                                                    func (*GoAwayFrame) DebugData

                                                                                                    func (f *GoAwayFrame) DebugData() []byte

                                                                                                      DebugData returns any debug data in the GOAWAY frame. Its contents are not defined. The caller must not retain the returned memory past the next call to ReadFrame.

                                                                                                      type HeadersFrame

                                                                                                      type HeadersFrame struct {
                                                                                                      	FrameHeader
                                                                                                      
                                                                                                      	// Priority is set if FlagHeadersPriority is set in the FrameHeader.
                                                                                                      	Priority PriorityParam
                                                                                                      	// contains filtered or unexported fields
                                                                                                      }

                                                                                                        A HeadersFrame is used to open a stream and additionally carries a header block fragment.

                                                                                                        func (*HeadersFrame) HasPriority

                                                                                                        func (f *HeadersFrame) HasPriority() bool

                                                                                                        func (*HeadersFrame) HeaderBlockFragment

                                                                                                        func (f *HeadersFrame) HeaderBlockFragment() []byte

                                                                                                        func (*HeadersFrame) HeadersEnded

                                                                                                        func (f *HeadersFrame) HeadersEnded() bool

                                                                                                        func (*HeadersFrame) StreamEnded

                                                                                                        func (f *HeadersFrame) StreamEnded() bool

                                                                                                        type HeadersFrameParam

                                                                                                        type HeadersFrameParam struct {
                                                                                                        	// StreamID is the required Stream ID to initiate.
                                                                                                        	StreamID uint32
                                                                                                        	// BlockFragment is part (or all) of a Header Block.
                                                                                                        	BlockFragment []byte
                                                                                                        
                                                                                                        	// EndStream indicates that the header block is the last that
                                                                                                        	// the endpoint will send for the identified stream. Setting
                                                                                                        	// this flag causes the stream to enter one of "half closed"
                                                                                                        	// states.
                                                                                                        	EndStream bool
                                                                                                        
                                                                                                        	// EndHeaders indicates that this frame contains an entire
                                                                                                        	// header block and is not followed by any
                                                                                                        	// CONTINUATION frames.
                                                                                                        	EndHeaders bool
                                                                                                        
                                                                                                        	// PadLength is the optional number of bytes of zeros to add
                                                                                                        	// to this frame.
                                                                                                        	PadLength uint8
                                                                                                        
                                                                                                        	// Priority, if non-zero, includes stream priority information
                                                                                                        	// in the HEADER frame.
                                                                                                        	Priority PriorityParam
                                                                                                        }

                                                                                                          HeadersFrameParam are the parameters for writing a HEADERS frame.

                                                                                                          type MetaHeadersFrame

                                                                                                          type MetaHeadersFrame struct {
                                                                                                          	*HeadersFrame
                                                                                                          
                                                                                                          	// Fields are the fields contained in the HEADERS and
                                                                                                          	// CONTINUATION frames. The underlying slice is owned by the
                                                                                                          	// Framer and must not be retained after the next call to
                                                                                                          	// ReadFrame.
                                                                                                          	//
                                                                                                          	// Fields are guaranteed to be in the correct http2 order and
                                                                                                          	// not have unknown pseudo header fields or invalid header
                                                                                                          	// field names or values. Required pseudo header fields may be
                                                                                                          	// missing, however. Use the MetaHeadersFrame.Pseudo accessor
                                                                                                          	// method access pseudo headers.
                                                                                                          	Fields []hpack.HeaderField
                                                                                                          
                                                                                                          	// Truncated is whether the max header list size limit was hit
                                                                                                          	// and Fields is incomplete. The hpack decoder state is still
                                                                                                          	// valid, however.
                                                                                                          	Truncated bool
                                                                                                          }

                                                                                                            A MetaHeadersFrame is the representation of one HEADERS frame and zero or more contiguous CONTINUATION frames and the decoding of their HPACK-encoded contents.

                                                                                                            This type of frame does not appear on the wire and is only returned by the Framer when Framer.ReadMetaHeaders is set.

                                                                                                            func (*MetaHeadersFrame) PseudoFields

                                                                                                            func (mh *MetaHeadersFrame) PseudoFields() []hpack.HeaderField

                                                                                                              PseudoFields returns the pseudo header fields of mh. The caller does not own the returned slice.

                                                                                                              func (*MetaHeadersFrame) PseudoValue

                                                                                                              func (mh *MetaHeadersFrame) PseudoValue(pseudo string) string

                                                                                                                PseudoValue returns the given pseudo header field's value. The provided pseudo field should not contain the leading colon.

                                                                                                                func (*MetaHeadersFrame) RegularFields

                                                                                                                func (mh *MetaHeadersFrame) RegularFields() []hpack.HeaderField

                                                                                                                  RegularFields returns the regular (non-pseudo) header fields of mh. The caller does not own the returned slice.

                                                                                                                  type OpenStreamOptions

                                                                                                                  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
                                                                                                                  }

                                                                                                                    OpenStreamOptions specifies extra options for WriteScheduler.OpenStream.

                                                                                                                    type PingFrame

                                                                                                                    type PingFrame struct {
                                                                                                                    	FrameHeader
                                                                                                                    	Data [8]byte
                                                                                                                    }

                                                                                                                      A PingFrame is a mechanism for measuring a minimal round trip time from the sender, as well as determining whether an idle connection is still functional. See http://http2.github.io/http2-spec/#rfc.section.6.7

                                                                                                                      func (*PingFrame) IsAck

                                                                                                                      func (f *PingFrame) IsAck() bool

                                                                                                                      type PriorityFrame

                                                                                                                      type PriorityFrame struct {
                                                                                                                      	FrameHeader
                                                                                                                      	PriorityParam
                                                                                                                      }

                                                                                                                        A PriorityFrame specifies the sender-advised priority of a stream. See http://http2.github.io/http2-spec/#rfc.section.6.3

                                                                                                                        type PriorityParam

                                                                                                                        type PriorityParam struct {
                                                                                                                        	// StreamDep is a 31-bit stream identifier for the
                                                                                                                        	// stream that this stream depends on. Zero means no
                                                                                                                        	// dependency.
                                                                                                                        	StreamDep uint32
                                                                                                                        
                                                                                                                        	// Exclusive is whether the dependency is exclusive.
                                                                                                                        	Exclusive bool
                                                                                                                        
                                                                                                                        	// Weight is the stream's zero-indexed weight. It should be
                                                                                                                        	// set together with StreamDep, or neither should be set. Per
                                                                                                                        	// the spec, "Add one to the value to obtain a weight between
                                                                                                                        	// 1 and 256."
                                                                                                                        	Weight uint8
                                                                                                                        }

                                                                                                                          PriorityParam are the stream prioritzation parameters.

                                                                                                                          func (PriorityParam) IsZero

                                                                                                                          func (p PriorityParam) IsZero() bool

                                                                                                                          type PriorityWriteSchedulerConfig

                                                                                                                          type PriorityWriteSchedulerConfig struct {
                                                                                                                          	// MaxClosedNodesInTree controls the maximum number of closed streams to
                                                                                                                          	// retain in the priority tree. Setting this to zero saves a small amount
                                                                                                                          	// of memory at the cost of performance.
                                                                                                                          	//
                                                                                                                          	// See RFC 7540, Section 5.3.4:
                                                                                                                          	//   "It is possible for a stream to become closed while prioritization
                                                                                                                          	//   information ... is in transit. ... This potentially creates suboptimal
                                                                                                                          	//   prioritization, since the stream could be given a priority that is
                                                                                                                          	//   different from what is intended. To avoid these problems, an endpoint
                                                                                                                          	//   SHOULD retain stream prioritization state for a period after streams
                                                                                                                          	//   become closed. The longer state is retained, the lower the chance that
                                                                                                                          	//   streams are assigned incorrect or default priority values."
                                                                                                                          	MaxClosedNodesInTree int
                                                                                                                          
                                                                                                                          	// MaxIdleNodesInTree controls the maximum number of idle streams to
                                                                                                                          	// retain in the priority tree. Setting this to zero saves a small amount
                                                                                                                          	// of memory at the cost of performance.
                                                                                                                          	//
                                                                                                                          	// See RFC 7540, Section 5.3.4:
                                                                                                                          	//   Similarly, streams that are in the "idle" state can be assigned
                                                                                                                          	//   priority or become a parent of other streams. This allows for the
                                                                                                                          	//   creation of a grouping node in the dependency tree, which enables
                                                                                                                          	//   more flexible expressions of priority. Idle streams begin with a
                                                                                                                          	//   default priority (Section 5.3.5).
                                                                                                                          	MaxIdleNodesInTree int
                                                                                                                          
                                                                                                                          	// ThrottleOutOfOrderWrites enables write throttling to help ensure that
                                                                                                                          	// data is delivered in priority order. This works around a race where
                                                                                                                          	// stream B depends on stream A and both streams are about to call Write
                                                                                                                          	// to queue DATA frames. If B wins the race, a naive scheduler would eagerly
                                                                                                                          	// write as much data from B as possible, but this is suboptimal because A
                                                                                                                          	// is a higher-priority stream. With throttling enabled, we write a small
                                                                                                                          	// amount of data from B to minimize the amount of bandwidth that B can
                                                                                                                          	// steal from A.
                                                                                                                          	ThrottleOutOfOrderWrites bool
                                                                                                                          }

                                                                                                                            PriorityWriteSchedulerConfig configures a priorityWriteScheduler.

                                                                                                                            type PushPromiseFrame

                                                                                                                            type PushPromiseFrame struct {
                                                                                                                            	FrameHeader
                                                                                                                            	PromiseID uint32
                                                                                                                            	// contains filtered or unexported fields
                                                                                                                            }

                                                                                                                              A PushPromiseFrame is used to initiate a server stream. See http://http2.github.io/http2-spec/#rfc.section.6.6

                                                                                                                              func (*PushPromiseFrame) HeaderBlockFragment

                                                                                                                              func (f *PushPromiseFrame) HeaderBlockFragment() []byte

                                                                                                                              func (*PushPromiseFrame) HeadersEnded

                                                                                                                              func (f *PushPromiseFrame) HeadersEnded() bool

                                                                                                                              type PushPromiseParam

                                                                                                                              type PushPromiseParam struct {
                                                                                                                              	// StreamID is the required Stream ID to initiate.
                                                                                                                              	StreamID uint32
                                                                                                                              
                                                                                                                              	// PromiseID is the required Stream ID which this
                                                                                                                              	// Push Promises
                                                                                                                              	PromiseID uint32
                                                                                                                              
                                                                                                                              	// BlockFragment is part (or all) of a Header Block.
                                                                                                                              	BlockFragment []byte
                                                                                                                              
                                                                                                                              	// EndHeaders indicates that this frame contains an entire
                                                                                                                              	// header block and is not followed by any
                                                                                                                              	// CONTINUATION frames.
                                                                                                                              	EndHeaders bool
                                                                                                                              
                                                                                                                              	// PadLength is the optional number of bytes of zeros to add
                                                                                                                              	// to this frame.
                                                                                                                              	PadLength uint8
                                                                                                                              }

                                                                                                                                PushPromiseParam are the parameters for writing a PUSH_PROMISE frame.

                                                                                                                                type RSTStreamFrame

                                                                                                                                type RSTStreamFrame struct {
                                                                                                                                	FrameHeader
                                                                                                                                	ErrCode ErrCode
                                                                                                                                }

                                                                                                                                  A RSTStreamFrame allows for abnormal termination of a stream. See http://http2.github.io/http2-spec/#rfc.section.6.4

                                                                                                                                  type RoundTripOpt

                                                                                                                                  type RoundTripOpt struct {
                                                                                                                                  	// OnlyCachedConn controls whether RoundTripOpt may
                                                                                                                                  	// create a new TCP connection. If set true and
                                                                                                                                  	// no cached connection is available, RoundTripOpt
                                                                                                                                  	// will return ErrNoCachedConn.
                                                                                                                                  	OnlyCachedConn bool
                                                                                                                                  }

                                                                                                                                    RoundTripOpt are options for the Transport.RoundTripOpt method.

                                                                                                                                    type ServeConnOpts

                                                                                                                                    type ServeConnOpts struct {
                                                                                                                                    	// Context is the base context to use.
                                                                                                                                    	// If nil, context.Background is used.
                                                                                                                                    	Context context.Context
                                                                                                                                    
                                                                                                                                    	// BaseConfig optionally sets the base configuration
                                                                                                                                    	// for values. If nil, defaults are used.
                                                                                                                                    	BaseConfig *http.Server
                                                                                                                                    
                                                                                                                                    	// Handler specifies which handler to use for processing
                                                                                                                                    	// requests. If nil, BaseConfig.Handler is used. If BaseConfig
                                                                                                                                    	// or BaseConfig.Handler is nil, http.DefaultServeMux is used.
                                                                                                                                    	Handler http.Handler
                                                                                                                                    }

                                                                                                                                      ServeConnOpts are options for the Server.ServeConn method.

                                                                                                                                      type Server

                                                                                                                                      type Server struct {
                                                                                                                                      	// MaxHandlers limits the number of http.Handler ServeHTTP goroutines
                                                                                                                                      	// which may run at a time over all connections.
                                                                                                                                      	// Negative or zero no limit.
                                                                                                                                      	// TODO: implement
                                                                                                                                      	MaxHandlers int
                                                                                                                                      
                                                                                                                                      	// MaxConcurrentStreams optionally specifies the number of
                                                                                                                                      	// concurrent streams that each client may have open at a
                                                                                                                                      	// time. This is unrelated to the number of http.Handler goroutines
                                                                                                                                      	// which may be active globally, which is MaxHandlers.
                                                                                                                                      	// If zero, MaxConcurrentStreams defaults to at least 100, per
                                                                                                                                      	// the HTTP/2 spec's recommendations.
                                                                                                                                      	MaxConcurrentStreams uint32
                                                                                                                                      
                                                                                                                                      	// MaxReadFrameSize optionally specifies the largest frame
                                                                                                                                      	// this server is willing to read. A valid value is between
                                                                                                                                      	// 16k and 16M, inclusive. If zero or otherwise invalid, a
                                                                                                                                      	// default value is used.
                                                                                                                                      	MaxReadFrameSize uint32
                                                                                                                                      
                                                                                                                                      	// PermitProhibitedCipherSuites, if true, permits the use of
                                                                                                                                      	// cipher suites prohibited by the HTTP/2 spec.
                                                                                                                                      	PermitProhibitedCipherSuites bool
                                                                                                                                      
                                                                                                                                      	// IdleTimeout specifies how long until idle clients should be
                                                                                                                                      	// closed with a GOAWAY frame. PING frames are not considered
                                                                                                                                      	// activity for the purposes of IdleTimeout.
                                                                                                                                      	IdleTimeout time.Duration
                                                                                                                                      
                                                                                                                                      	// MaxUploadBufferPerConnection is the size of the initial flow
                                                                                                                                      	// control window for each connections. The HTTP/2 spec does not
                                                                                                                                      	// allow this to be smaller than 65535 or larger than 2^32-1.
                                                                                                                                      	// If the value is outside this range, a default value will be
                                                                                                                                      	// used instead.
                                                                                                                                      	MaxUploadBufferPerConnection int32
                                                                                                                                      
                                                                                                                                      	// MaxUploadBufferPerStream is the size of the initial flow control
                                                                                                                                      	// window for each stream. The HTTP/2 spec does not allow this to
                                                                                                                                      	// be larger than 2^32-1. If the value is zero or larger than the
                                                                                                                                      	// maximum, a default value will be used instead.
                                                                                                                                      	MaxUploadBufferPerStream int32
                                                                                                                                      
                                                                                                                                      	// NewWriteScheduler constructs a write scheduler for a connection.
                                                                                                                                      	// If nil, a default scheduler is chosen.
                                                                                                                                      	NewWriteScheduler func() WriteScheduler
                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                      }

                                                                                                                                        Server is an HTTP/2 server.

                                                                                                                                        func (*Server) ServeConn

                                                                                                                                        func (s *Server) ServeConn(c net.Conn, opts *ServeConnOpts)

                                                                                                                                          ServeConn serves HTTP/2 requests on the provided connection and blocks until the connection is no longer readable.

                                                                                                                                          ServeConn starts speaking HTTP/2 assuming that c has not had any reads or writes. It writes its initial settings frame and expects to be able to read the preface and settings frame from the client. If c has a ConnectionState method like a *tls.Conn, the ConnectionState is used to verify the TLS ciphersuite and to set the Request.TLS field in Handlers.

                                                                                                                                          ServeConn does not support h2c by itself. Any h2c support must be implemented in terms of providing a suitably-behaving net.Conn.

                                                                                                                                          The opts parameter is optional. If nil, default values are used.

                                                                                                                                          type Setting

                                                                                                                                          type Setting struct {
                                                                                                                                          	// ID is which setting is being set.
                                                                                                                                          	// See http://http2.github.io/http2-spec/#SettingValues
                                                                                                                                          	ID SettingID
                                                                                                                                          
                                                                                                                                          	// Val is the value.
                                                                                                                                          	Val uint32
                                                                                                                                          }

                                                                                                                                            Setting is a setting parameter: which setting it is, and its value.

                                                                                                                                            func (Setting) String

                                                                                                                                            func (s Setting) String() string

                                                                                                                                            func (Setting) Valid

                                                                                                                                            func (s Setting) Valid() error

                                                                                                                                              Valid reports whether the setting is valid.

                                                                                                                                              type SettingID

                                                                                                                                              type SettingID uint16

                                                                                                                                                A SettingID is an HTTP/2 setting as defined in http://http2.github.io/http2-spec/#iana-settings

                                                                                                                                                const (
                                                                                                                                                	SettingHeaderTableSize      SettingID = 0x1
                                                                                                                                                	SettingEnablePush           SettingID = 0x2
                                                                                                                                                	SettingMaxConcurrentStreams SettingID = 0x3
                                                                                                                                                	SettingInitialWindowSize    SettingID = 0x4
                                                                                                                                                	SettingMaxFrameSize         SettingID = 0x5
                                                                                                                                                	SettingMaxHeaderListSize    SettingID = 0x6
                                                                                                                                                )

                                                                                                                                                func (SettingID) String

                                                                                                                                                func (s SettingID) String() string

                                                                                                                                                type SettingsFrame

                                                                                                                                                type SettingsFrame struct {
                                                                                                                                                	FrameHeader
                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                }

                                                                                                                                                  A SettingsFrame conveys configuration parameters that affect how endpoints communicate, such as preferences and constraints on peer behavior.

                                                                                                                                                  See http://http2.github.io/http2-spec/#SETTINGS

                                                                                                                                                  func (*SettingsFrame) ForeachSetting

                                                                                                                                                  func (f *SettingsFrame) ForeachSetting(fn func(Setting) error) error

                                                                                                                                                    ForeachSetting runs fn for each setting. It stops and returns the first error.

                                                                                                                                                    func (*SettingsFrame) HasDuplicates

                                                                                                                                                    func (f *SettingsFrame) HasDuplicates() bool

                                                                                                                                                      HasDuplicates reports whether f contains any duplicate setting IDs.

                                                                                                                                                      func (*SettingsFrame) IsAck

                                                                                                                                                      func (f *SettingsFrame) IsAck() bool

                                                                                                                                                      func (*SettingsFrame) NumSettings

                                                                                                                                                      func (f *SettingsFrame) NumSettings() int

                                                                                                                                                      func (*SettingsFrame) Setting

                                                                                                                                                      func (f *SettingsFrame) Setting(i int) Setting

                                                                                                                                                        Setting returns the setting from the frame at the given 0-based index. The index must be >= 0 and less than f.NumSettings().

                                                                                                                                                        func (*SettingsFrame) Value

                                                                                                                                                        func (f *SettingsFrame) Value(id SettingID) (v uint32, ok bool)

                                                                                                                                                        type StreamError

                                                                                                                                                        type StreamError struct {
                                                                                                                                                        	StreamID uint32
                                                                                                                                                        	Code     ErrCode
                                                                                                                                                        	Cause    error // optional additional detail
                                                                                                                                                        }

                                                                                                                                                          StreamError is an error that only affects one stream within an HTTP/2 connection.

                                                                                                                                                          func (StreamError) Error

                                                                                                                                                          func (e StreamError) Error() string

                                                                                                                                                          type Transport

                                                                                                                                                          type Transport struct {
                                                                                                                                                          	// DialTLS specifies an optional dial function for creating
                                                                                                                                                          	// TLS connections for requests.
                                                                                                                                                          	//
                                                                                                                                                          	// If DialTLS is nil, tls.Dial is used.
                                                                                                                                                          	//
                                                                                                                                                          	// If the returned net.Conn has a ConnectionState method like tls.Conn,
                                                                                                                                                          	// it will be used to set http.Response.TLS.
                                                                                                                                                          	DialTLS func(network, addr string, cfg *tls.Config) (net.Conn, error)
                                                                                                                                                          
                                                                                                                                                          	// TLSClientConfig specifies the TLS configuration to use with
                                                                                                                                                          	// tls.Client. If nil, the default configuration is used.
                                                                                                                                                          	TLSClientConfig *tls.Config
                                                                                                                                                          
                                                                                                                                                          	// ConnPool optionally specifies an alternate connection pool to use.
                                                                                                                                                          	// If nil, the default is used.
                                                                                                                                                          	ConnPool ClientConnPool
                                                                                                                                                          
                                                                                                                                                          	// DisableCompression, if true, prevents the Transport from
                                                                                                                                                          	// requesting compression with an "Accept-Encoding: gzip"
                                                                                                                                                          	// request header when the Request contains no existing
                                                                                                                                                          	// Accept-Encoding value. If the Transport requests gzip on
                                                                                                                                                          	// its own and gets a gzipped response, it's transparently
                                                                                                                                                          	// decoded in the Response.Body. However, if the user
                                                                                                                                                          	// explicitly requested gzip it is not automatically
                                                                                                                                                          	// uncompressed.
                                                                                                                                                          	DisableCompression bool
                                                                                                                                                          
                                                                                                                                                          	// AllowHTTP, if true, permits HTTP/2 requests using the insecure,
                                                                                                                                                          	// plain-text "http" scheme. Note that this does not enable h2c support.
                                                                                                                                                          	AllowHTTP bool
                                                                                                                                                          
                                                                                                                                                          	// MaxHeaderListSize is the http2 SETTINGS_MAX_HEADER_LIST_SIZE to
                                                                                                                                                          	// send in the initial settings frame. It is how many bytes
                                                                                                                                                          	// of response headers are allowed. Unlike the http2 spec, zero here
                                                                                                                                                          	// means to use a default limit (currently 10MB). If you actually
                                                                                                                                                          	// want to advertise an unlimited value to the peer, Transport
                                                                                                                                                          	// interprets the highest possible value here (0xffffffff or 1<<32-1)
                                                                                                                                                          	// to mean no limit.
                                                                                                                                                          	MaxHeaderListSize uint32
                                                                                                                                                          
                                                                                                                                                          	// StrictMaxConcurrentStreams controls whether the server's
                                                                                                                                                          	// SETTINGS_MAX_CONCURRENT_STREAMS should be respected
                                                                                                                                                          	// globally. If false, new TCP connections are created to the
                                                                                                                                                          	// server as needed to keep each under the per-connection
                                                                                                                                                          	// SETTINGS_MAX_CONCURRENT_STREAMS limit. If true, the
                                                                                                                                                          	// server's SETTINGS_MAX_CONCURRENT_STREAMS is interpreted as
                                                                                                                                                          	// a global limit and callers of RoundTrip block when needed,
                                                                                                                                                          	// waiting for their turn.
                                                                                                                                                          	StrictMaxConcurrentStreams bool
                                                                                                                                                          
                                                                                                                                                          	// ReadIdleTimeout is the timeout after which a health check using ping
                                                                                                                                                          	// frame will be carried out if no frame is received on the connection.
                                                                                                                                                          	// Note that a ping response will is considered a received frame, so if
                                                                                                                                                          	// there is no other traffic on the connection, the health check will
                                                                                                                                                          	// be performed every ReadIdleTimeout interval.
                                                                                                                                                          	// If zero, no health check is performed.
                                                                                                                                                          	ReadIdleTimeout time.Duration
                                                                                                                                                          
                                                                                                                                                          	// PingTimeout is the timeout after which the connection will be closed
                                                                                                                                                          	// if a response to Ping is not received.
                                                                                                                                                          	// Defaults to 15s.
                                                                                                                                                          	PingTimeout time.Duration
                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                          }

                                                                                                                                                            Transport is an HTTP/2 Transport.

                                                                                                                                                            A Transport internally caches connections to servers. It is safe for concurrent use by multiple goroutines.

                                                                                                                                                            func ConfigureTransports

                                                                                                                                                            func ConfigureTransports(t1 *http.Transport) (*Transport, error)

                                                                                                                                                              ConfigureTransports configures a net/http HTTP/1 Transport to use HTTP/2. It returns a new HTTP/2 Transport for further configuration. It returns an error if t1 has already been HTTP/2-enabled.

                                                                                                                                                              func (*Transport) CloseIdleConnections

                                                                                                                                                              func (t *Transport) CloseIdleConnections()

                                                                                                                                                                CloseIdleConnections closes any connections which were previously connected from previous requests but are now sitting idle. It does not interrupt any connections currently in use.

                                                                                                                                                                func (*Transport) NewClientConn

                                                                                                                                                                func (t *Transport) NewClientConn(c net.Conn) (*ClientConn, error)

                                                                                                                                                                func (*Transport) RoundTrip

                                                                                                                                                                func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error)

                                                                                                                                                                func (*Transport) RoundTripOpt

                                                                                                                                                                func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Response, error)

                                                                                                                                                                  RoundTripOpt is like RoundTrip, but takes options.

                                                                                                                                                                  type UnknownFrame

                                                                                                                                                                  type UnknownFrame struct {
                                                                                                                                                                  	FrameHeader
                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                  }

                                                                                                                                                                    An UnknownFrame is the frame type returned when the frame type is unknown or no specific frame type parser exists.

                                                                                                                                                                    func (*UnknownFrame) Payload

                                                                                                                                                                    func (f *UnknownFrame) Payload() []byte

                                                                                                                                                                      Payload returns the frame's payload (after the header). It is not valid to call this method after a subsequent call to Framer.ReadFrame, nor is it valid to retain the returned slice. The memory is owned by the Framer and is invalidated when the next frame is read.

                                                                                                                                                                      type WindowUpdateFrame

                                                                                                                                                                      type WindowUpdateFrame struct {
                                                                                                                                                                      	FrameHeader
                                                                                                                                                                      	Increment uint32 // never read with high bit set
                                                                                                                                                                      }

                                                                                                                                                                        A WindowUpdateFrame is used to implement flow control. See http://http2.github.io/http2-spec/#rfc.section.6.9

                                                                                                                                                                        type WriteScheduler

                                                                                                                                                                        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. No frames should be discarded except by CloseStream.
                                                                                                                                                                        	Pop() (wr FrameWriteRequest, ok bool)
                                                                                                                                                                        }

                                                                                                                                                                          WriteScheduler is the interface implemented by HTTP/2 write schedulers. Methods are never called concurrently.

                                                                                                                                                                          func NewPriorityWriteScheduler

                                                                                                                                                                          func NewPriorityWriteScheduler(cfg *PriorityWriteSchedulerConfig) WriteScheduler

                                                                                                                                                                            NewPriorityWriteScheduler constructs a WriteScheduler that schedules frames by following HTTP/2 priorities as described in RFC 7540 Section 5.3. If cfg is nil, default options are used.

                                                                                                                                                                            func NewRandomWriteScheduler

                                                                                                                                                                            func NewRandomWriteScheduler() WriteScheduler

                                                                                                                                                                              NewRandomWriteScheduler constructs a WriteScheduler that ignores HTTP/2 priorities. Control frames like SETTINGS and PING are written before DATA frames, but if no control frames are queued and multiple streams have queued HEADERS or DATA frames, Pop selects a ready stream arbitrarily.

                                                                                                                                                                              Directories

                                                                                                                                                                              Path Synopsis
                                                                                                                                                                              Package h2c implements the unencrypted "h2c" form of HTTP/2.
                                                                                                                                                                              Package h2c implements the unencrypted "h2c" form of HTTP/2.
                                                                                                                                                                              h2demo module
                                                                                                                                                                              The h2i command is an interactive HTTP/2 console.
                                                                                                                                                                              The h2i command is an interactive HTTP/2 console.
                                                                                                                                                                              Package hpack implements HPACK, a compression format for efficiently representing HTTP header fields in the context of HTTP/2.
                                                                                                                                                                              Package hpack implements HPACK, a compression format for efficiently representing HTTP header fields in the context of HTTP/2.