mirror of
https://github.com/letic/terraform-provider-google.git
synced 2024-09-07 01:26:43 +00:00
![Paddy](/assets/img/avatar_default.png)
Switch to using Go modules. This migrates our vendor.json to use Go 1.11's modules system, and replaces the vendor folder with the output of go mod vendor. The vendored code should remain basically the same; I believe some tree shaking of packages and support scripts/licenses/READMEs/etc. happened. This also fixes Travis and our Makefile to no longer use govendor.
366 lines
10 KiB
Go
366 lines
10 KiB
Go
// Copyright 2014 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package http2
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"net/url"
|
|
|
|
"golang.org/x/net/http/httpguts"
|
|
"golang.org/x/net/http2/hpack"
|
|
)
|
|
|
|
// writeFramer is implemented by any type that is used to write frames.
|
|
type writeFramer interface {
|
|
writeFrame(writeContext) error
|
|
|
|
// staysWithinBuffer reports whether this writer promises that
|
|
// it will only write less than or equal to size bytes, and it
|
|
// won't Flush the write context.
|
|
staysWithinBuffer(size int) bool
|
|
}
|
|
|
|
// writeContext is the interface needed by the various frame writer
|
|
// types below. All the writeFrame methods below are scheduled via the
|
|
// frame writing scheduler (see writeScheduler in writesched.go).
|
|
//
|
|
// This interface is implemented by *serverConn.
|
|
//
|
|
// TODO: decide whether to a) use this in the client code (which didn't
|
|
// end up using this yet, because it has a simpler design, not
|
|
// currently implementing priorities), or b) delete this and
|
|
// make the server code a bit more concrete.
|
|
type writeContext interface {
|
|
Framer() *Framer
|
|
Flush() error
|
|
CloseConn() error
|
|
// HeaderEncoder returns an HPACK encoder that writes to the
|
|
// returned buffer.
|
|
HeaderEncoder() (*hpack.Encoder, *bytes.Buffer)
|
|
}
|
|
|
|
// writeEndsStream reports whether w writes a frame that will transition
|
|
// the stream to a half-closed local state. This returns false for RST_STREAM,
|
|
// which closes the entire stream (not just the local half).
|
|
func writeEndsStream(w writeFramer) bool {
|
|
switch v := w.(type) {
|
|
case *writeData:
|
|
return v.endStream
|
|
case *writeResHeaders:
|
|
return v.endStream
|
|
case nil:
|
|
// This can only happen if the caller reuses w after it's
|
|
// been intentionally nil'ed out to prevent use. Keep this
|
|
// here to catch future refactoring breaking it.
|
|
panic("writeEndsStream called on nil writeFramer")
|
|
}
|
|
return false
|
|
}
|
|
|
|
type flushFrameWriter struct{}
|
|
|
|
func (flushFrameWriter) writeFrame(ctx writeContext) error {
|
|
return ctx.Flush()
|
|
}
|
|
|
|
func (flushFrameWriter) staysWithinBuffer(max int) bool { return false }
|
|
|
|
type writeSettings []Setting
|
|
|
|
func (s writeSettings) staysWithinBuffer(max int) bool {
|
|
const settingSize = 6 // uint16 + uint32
|
|
return frameHeaderLen+settingSize*len(s) <= max
|
|
|
|
}
|
|
|
|
func (s writeSettings) writeFrame(ctx writeContext) error {
|
|
return ctx.Framer().WriteSettings([]Setting(s)...)
|
|
}
|
|
|
|
type writeGoAway struct {
|
|
maxStreamID uint32
|
|
code ErrCode
|
|
}
|
|
|
|
func (p *writeGoAway) writeFrame(ctx writeContext) error {
|
|
err := ctx.Framer().WriteGoAway(p.maxStreamID, p.code, nil)
|
|
ctx.Flush() // ignore error: we're hanging up on them anyway
|
|
return err
|
|
}
|
|
|
|
func (*writeGoAway) staysWithinBuffer(max int) bool { return false } // flushes
|
|
|
|
type writeData struct {
|
|
streamID uint32
|
|
p []byte
|
|
endStream bool
|
|
}
|
|
|
|
func (w *writeData) String() string {
|
|
return fmt.Sprintf("writeData(stream=%d, p=%d, endStream=%v)", w.streamID, len(w.p), w.endStream)
|
|
}
|
|
|
|
func (w *writeData) writeFrame(ctx writeContext) error {
|
|
return ctx.Framer().WriteData(w.streamID, w.endStream, w.p)
|
|
}
|
|
|
|
func (w *writeData) staysWithinBuffer(max int) bool {
|
|
return frameHeaderLen+len(w.p) <= max
|
|
}
|
|
|
|
// handlerPanicRST is the message sent from handler goroutines when
|
|
// the handler panics.
|
|
type handlerPanicRST struct {
|
|
StreamID uint32
|
|
}
|
|
|
|
func (hp handlerPanicRST) writeFrame(ctx writeContext) error {
|
|
return ctx.Framer().WriteRSTStream(hp.StreamID, ErrCodeInternal)
|
|
}
|
|
|
|
func (hp handlerPanicRST) staysWithinBuffer(max int) bool { return frameHeaderLen+4 <= max }
|
|
|
|
func (se StreamError) writeFrame(ctx writeContext) error {
|
|
return ctx.Framer().WriteRSTStream(se.StreamID, se.Code)
|
|
}
|
|
|
|
func (se StreamError) staysWithinBuffer(max int) bool { return frameHeaderLen+4 <= max }
|
|
|
|
type writePingAck struct{ pf *PingFrame }
|
|
|
|
func (w writePingAck) writeFrame(ctx writeContext) error {
|
|
return ctx.Framer().WritePing(true, w.pf.Data)
|
|
}
|
|
|
|
func (w writePingAck) staysWithinBuffer(max int) bool { return frameHeaderLen+len(w.pf.Data) <= max }
|
|
|
|
type writeSettingsAck struct{}
|
|
|
|
func (writeSettingsAck) writeFrame(ctx writeContext) error {
|
|
return ctx.Framer().WriteSettingsAck()
|
|
}
|
|
|
|
func (writeSettingsAck) staysWithinBuffer(max int) bool { return frameHeaderLen <= max }
|
|
|
|
// splitHeaderBlock splits headerBlock into fragments so that each fragment fits
|
|
// in a single frame, then calls fn for each fragment. firstFrag/lastFrag are true
|
|
// for the first/last fragment, respectively.
|
|
func splitHeaderBlock(ctx writeContext, headerBlock []byte, fn func(ctx writeContext, frag []byte, firstFrag, lastFrag bool) error) error {
|
|
// For now we're lazy and just pick the minimum MAX_FRAME_SIZE
|
|
// that all peers must support (16KB). Later we could care
|
|
// more and send larger frames if the peer advertised it, but
|
|
// there's little point. Most headers are small anyway (so we
|
|
// generally won't have CONTINUATION frames), and extra frames
|
|
// only waste 9 bytes anyway.
|
|
const maxFrameSize = 16384
|
|
|
|
first := true
|
|
for len(headerBlock) > 0 {
|
|
frag := headerBlock
|
|
if len(frag) > maxFrameSize {
|
|
frag = frag[:maxFrameSize]
|
|
}
|
|
headerBlock = headerBlock[len(frag):]
|
|
if err := fn(ctx, frag, first, len(headerBlock) == 0); err != nil {
|
|
return err
|
|
}
|
|
first = false
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// writeResHeaders is a request to write a HEADERS and 0+ CONTINUATION frames
|
|
// for HTTP response headers or trailers from a server handler.
|
|
type writeResHeaders struct {
|
|
streamID uint32
|
|
httpResCode int // 0 means no ":status" line
|
|
h http.Header // may be nil
|
|
trailers []string // if non-nil, which keys of h to write. nil means all.
|
|
endStream bool
|
|
|
|
date string
|
|
contentType string
|
|
contentLength string
|
|
}
|
|
|
|
func encKV(enc *hpack.Encoder, k, v string) {
|
|
if VerboseLogs {
|
|
log.Printf("http2: server encoding header %q = %q", k, v)
|
|
}
|
|
enc.WriteField(hpack.HeaderField{Name: k, Value: v})
|
|
}
|
|
|
|
func (w *writeResHeaders) staysWithinBuffer(max int) bool {
|
|
// TODO: this is a common one. It'd be nice to return true
|
|
// here and get into the fast path if we could be clever and
|
|
// calculate the size fast enough, or at least a conservative
|
|
// upper bound that usually fires. (Maybe if w.h and
|
|
// w.trailers are nil, so we don't need to enumerate it.)
|
|
// Otherwise I'm afraid that just calculating the length to
|
|
// answer this question would be slower than the ~2µs benefit.
|
|
return false
|
|
}
|
|
|
|
func (w *writeResHeaders) writeFrame(ctx writeContext) error {
|
|
enc, buf := ctx.HeaderEncoder()
|
|
buf.Reset()
|
|
|
|
if w.httpResCode != 0 {
|
|
encKV(enc, ":status", httpCodeString(w.httpResCode))
|
|
}
|
|
|
|
encodeHeaders(enc, w.h, w.trailers)
|
|
|
|
if w.contentType != "" {
|
|
encKV(enc, "content-type", w.contentType)
|
|
}
|
|
if w.contentLength != "" {
|
|
encKV(enc, "content-length", w.contentLength)
|
|
}
|
|
if w.date != "" {
|
|
encKV(enc, "date", w.date)
|
|
}
|
|
|
|
headerBlock := buf.Bytes()
|
|
if len(headerBlock) == 0 && w.trailers == nil {
|
|
panic("unexpected empty hpack")
|
|
}
|
|
|
|
return splitHeaderBlock(ctx, headerBlock, w.writeHeaderBlock)
|
|
}
|
|
|
|
func (w *writeResHeaders) writeHeaderBlock(ctx writeContext, frag []byte, firstFrag, lastFrag bool) error {
|
|
if firstFrag {
|
|
return ctx.Framer().WriteHeaders(HeadersFrameParam{
|
|
StreamID: w.streamID,
|
|
BlockFragment: frag,
|
|
EndStream: w.endStream,
|
|
EndHeaders: lastFrag,
|
|
})
|
|
} else {
|
|
return ctx.Framer().WriteContinuation(w.streamID, lastFrag, frag)
|
|
}
|
|
}
|
|
|
|
// writePushPromise is a request to write a PUSH_PROMISE and 0+ CONTINUATION frames.
|
|
type writePushPromise struct {
|
|
streamID uint32 // pusher stream
|
|
method string // for :method
|
|
url *url.URL // for :scheme, :authority, :path
|
|
h http.Header
|
|
|
|
// Creates an ID for a pushed stream. This runs on serveG just before
|
|
// the frame is written. The returned ID is copied to promisedID.
|
|
allocatePromisedID func() (uint32, error)
|
|
promisedID uint32
|
|
}
|
|
|
|
func (w *writePushPromise) staysWithinBuffer(max int) bool {
|
|
// TODO: see writeResHeaders.staysWithinBuffer
|
|
return false
|
|
}
|
|
|
|
func (w *writePushPromise) writeFrame(ctx writeContext) error {
|
|
enc, buf := ctx.HeaderEncoder()
|
|
buf.Reset()
|
|
|
|
encKV(enc, ":method", w.method)
|
|
encKV(enc, ":scheme", w.url.Scheme)
|
|
encKV(enc, ":authority", w.url.Host)
|
|
encKV(enc, ":path", w.url.RequestURI())
|
|
encodeHeaders(enc, w.h, nil)
|
|
|
|
headerBlock := buf.Bytes()
|
|
if len(headerBlock) == 0 {
|
|
panic("unexpected empty hpack")
|
|
}
|
|
|
|
return splitHeaderBlock(ctx, headerBlock, w.writeHeaderBlock)
|
|
}
|
|
|
|
func (w *writePushPromise) writeHeaderBlock(ctx writeContext, frag []byte, firstFrag, lastFrag bool) error {
|
|
if firstFrag {
|
|
return ctx.Framer().WritePushPromise(PushPromiseParam{
|
|
StreamID: w.streamID,
|
|
PromiseID: w.promisedID,
|
|
BlockFragment: frag,
|
|
EndHeaders: lastFrag,
|
|
})
|
|
} else {
|
|
return ctx.Framer().WriteContinuation(w.streamID, lastFrag, frag)
|
|
}
|
|
}
|
|
|
|
type write100ContinueHeadersFrame struct {
|
|
streamID uint32
|
|
}
|
|
|
|
func (w write100ContinueHeadersFrame) writeFrame(ctx writeContext) error {
|
|
enc, buf := ctx.HeaderEncoder()
|
|
buf.Reset()
|
|
encKV(enc, ":status", "100")
|
|
return ctx.Framer().WriteHeaders(HeadersFrameParam{
|
|
StreamID: w.streamID,
|
|
BlockFragment: buf.Bytes(),
|
|
EndStream: false,
|
|
EndHeaders: true,
|
|
})
|
|
}
|
|
|
|
func (w write100ContinueHeadersFrame) staysWithinBuffer(max int) bool {
|
|
// Sloppy but conservative:
|
|
return 9+2*(len(":status")+len("100")) <= max
|
|
}
|
|
|
|
type writeWindowUpdate struct {
|
|
streamID uint32 // or 0 for conn-level
|
|
n uint32
|
|
}
|
|
|
|
func (wu writeWindowUpdate) staysWithinBuffer(max int) bool { return frameHeaderLen+4 <= max }
|
|
|
|
func (wu writeWindowUpdate) writeFrame(ctx writeContext) error {
|
|
return ctx.Framer().WriteWindowUpdate(wu.streamID, wu.n)
|
|
}
|
|
|
|
// encodeHeaders encodes an http.Header. If keys is not nil, then (k, h[k])
|
|
// is encoded only if k is in keys.
|
|
func encodeHeaders(enc *hpack.Encoder, h http.Header, keys []string) {
|
|
if keys == nil {
|
|
sorter := sorterPool.Get().(*sorter)
|
|
// Using defer here, since the returned keys from the
|
|
// sorter.Keys method is only valid until the sorter
|
|
// is returned:
|
|
defer sorterPool.Put(sorter)
|
|
keys = sorter.Keys(h)
|
|
}
|
|
for _, k := range keys {
|
|
vv := h[k]
|
|
k = lowerHeader(k)
|
|
if !validWireHeaderFieldName(k) {
|
|
// Skip it as backup paranoia. Per
|
|
// golang.org/issue/14048, these should
|
|
// already be rejected at a higher level.
|
|
continue
|
|
}
|
|
isTE := k == "transfer-encoding"
|
|
for _, v := range vv {
|
|
if !httpguts.ValidHeaderFieldValue(v) {
|
|
// TODO: return an error? golang.org/issue/14048
|
|
// For now just omit it.
|
|
continue
|
|
}
|
|
// TODO: more of "8.1.2.2 Connection-Specific Header Fields"
|
|
if isTE && v != "trailers" {
|
|
continue
|
|
}
|
|
encKV(enc, k, v)
|
|
}
|
|
}
|
|
}
|