194 files changed, 51625 insertions, 6975 deletions

diff --git a/vendor/google.golang.org/api/AUTHORS b/vendor/google.golang.org/api/AUTHORS
new file mode 100644
index 0000000..f73b725
--- /dev/null
+++ b/vendor/google.golang.org/api/AUTHORS
@@ -0,0 +1,10 @@
+# This is the official list of authors for copyright purposes.
+# This file is distinct from the CONTRIBUTORS files.
+# See the latter for an explanation.
+
+# Names should be added to this file as
+#       Name or Organization <email address>
+# The email address is not required for organizations.
+
+# Please keep the list sorted.
+Google Inc.
diff --git a/vendor/google.golang.org/api/CONTRIBUTORS b/vendor/google.golang.org/api/CONTRIBUTORS
new file mode 100644
index 0000000..fe55ebf
--- /dev/null
+++ b/vendor/google.golang.org/api/CONTRIBUTORS
@@ -0,0 +1,55 @@
+# This is the official list of people who can contribute
+# (and typically have contributed) code to the repository.
+# The AUTHORS file lists the copyright holders; this file
+# lists people.  For example, Google employees are listed here
+# but not in AUTHORS, because Google holds the copyright.
+#
+# The submission process automatically checks to make sure
+# that people submitting code are listed in this file (by email address).
+#
+# Names should be added to this file only after verifying that
+# the individual or the individual's organization has agreed to
+# the appropriate Contributor License Agreement, found here:
+#
+#     https://cla.developers.google.com/about/google-individual
+#     https://cla.developers.google.com/about/google-corporate
+#
+# The CLA can be filled out on the web:
+#
+#     https://cla.developers.google.com/
+#
+# When adding J Random Contributor's name to this file,
+# either J's name or J's organization's name should be
+# added to the AUTHORS file, depending on whether the
+# individual or corporate CLA was used.
+
+# Names should be added to this file like so:
+#     Name <email address>
+#
+# An entry with two email addresses specifies that the
+# first address should be used in the submit logs and
+# that the second address should be recognized as the
+# same person when interacting with Rietveld.
+
+# Please keep the list sorted.
+
+Alain Vongsouvanhalainv <alainv@google.com>
+Andrew Gerrand <adg@golang.org>
+Brad Fitzpatrick <bradfitz@golang.org>
+Eric Koleda <ekoleda+devrel@googlers.com>
+Francesc Campoy <campoy@golang.org>
+Garrick Evans <garrick@google.com>
+Glenn Lewis <gmlewis@google.com>
+Ivan Krasin <krasin@golang.org>
+Jason Hall <jasonhall@google.com>
+Johan Euphrosine <proppy@google.com>
+Kostik Shtoyk <kostik@google.com>
+Kunpei Sakai <namusyaka@gmail.com>
+Matthew Whisenhunt <matt.whisenhunt@gmail.com>
+Michael McGreevy <mcgreevy@golang.org>
+Nick Craig-Wood <nickcw@gmail.com>
+Robbie Trencheny <me@robbiet.us>
+Ross Light <light@google.com>
+Sarah Adams <shadams@google.com>
+Scott Van Woudenberg <scottvw@google.com>
+Takashi Matsuo <tmatsuo@google.com>
diff --git a/vendor/google.golang.org/api/LICENSE b/vendor/google.golang.org/api/LICENSE
new file mode 100644
index 0000000..263aa7a
--- /dev/null
+++ b/vendor/google.golang.org/api/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2011 Google Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/google.golang.org/api/gensupport/backoff.go b/vendor/google.golang.org/api/gensupport/backoff.go
new file mode 100644
index 0000000..94b7789
--- /dev/null
+++ b/vendor/google.golang.org/api/gensupport/backoff.go
@@ -0,0 +1,51 @@
+// Copyright 2016 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 gensupport
+
+import (
+        "math/rand"
+        "time"
+)
+
+// BackoffStrategy defines the set of functions that a backoff-er must
+// implement.
+type BackoffStrategy interface {
+        // Pause returns the duration of the next pause and true if the operation should be
+        // retried, or false if no further retries should be attempted.
+        Pause() (time.Duration, bool)
+
+        // Reset restores the strategy to its initial state.
+        Reset()
+}
+
+// ExponentialBackoff performs exponential backoff as per https://en.wikipedia.org/wiki/Exponential_backoff.
+// The initial pause time is given by Base.
+// Once the total pause time exceeds Max, Pause will indicate no further retries.
+type ExponentialBackoff struct {
+        Base  time.Duration
+        Max   time.Duration
+        total time.Duration
+        n     uint
+}
+
+// Pause returns the amount of time the caller should wait.
+func (eb *ExponentialBackoff) Pause() (time.Duration, bool) {
+        if eb.total > eb.Max {
+                return 0, false
+        }
+
+        // The next pause is selected from randomly from [0, 2^n * Base).
+        d := time.Duration(rand.Int63n((1 << eb.n) * int64(eb.Base)))
+        eb.total += d
+        eb.n++
+        return d, true
+}
+
+// Reset resets the backoff strategy such that the next Pause call will begin
+// counting from the start. It is not safe to call concurrently with Pause.
+func (eb *ExponentialBackoff) Reset() {
+        eb.n = 0
+        eb.total = 0
+}
diff --git a/vendor/google.golang.org/api/gensupport/buffer.go b/vendor/google.golang.org/api/gensupport/buffer.go
new file mode 100644
index 0000000..3d0817e
--- /dev/null
+++ b/vendor/google.golang.org/api/gensupport/buffer.go
@@ -0,0 +1,79 @@
+// Copyright 2016 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 gensupport
+
+import (
+        "bytes"
+        "io"
+
+        "google.golang.org/api/googleapi"
+)
+
+// MediaBuffer buffers data from an io.Reader to support uploading media in
+// retryable chunks. It should be created with NewMediaBuffer.
+type MediaBuffer struct {
+        media io.Reader
+
+        chunk []byte // The current chunk which is pending upload.  The capacity is the chunk size.
+        err   error  // Any error generated when populating chunk by reading media.
+
+        // The absolute position of chunk in the underlying media.
+        off int64
+}
+
+// NewMediaBuffer initializes a MediaBuffer.
+func NewMediaBuffer(media io.Reader, chunkSize int) *MediaBuffer {
+        return &MediaBuffer{media: media, chunk: make([]byte, 0, chunkSize)}
+}
+
+// Chunk returns the current buffered chunk, the offset in the underlying media
+// from which the chunk is drawn, and the size of the chunk.
+// Successive calls to Chunk return the same chunk between calls to Next.
+func (mb *MediaBuffer) Chunk() (chunk io.Reader, off int64, size int, err error) {
+        // There may already be data in chunk if Next has not been called since the previous call to Chunk.
+        if mb.err == nil && len(mb.chunk) == 0 {
+                mb.err = mb.loadChunk()
+        }
+        return bytes.NewReader(mb.chunk), mb.off, len(mb.chunk), mb.err
+}
+
+// loadChunk will read from media into chunk, up to the capacity of chunk.
+func (mb *MediaBuffer) loadChunk() error {
+        bufSize := cap(mb.chunk)
+        mb.chunk = mb.chunk[:bufSize]
+
+        read := 0
+        var err error
+        for err == nil && read < bufSize {
+                var n int
+                n, err = mb.media.Read(mb.chunk[read:])
+                read += n
+        }
+        mb.chunk = mb.chunk[:read]
+        return err
+}
+
+// Next advances to the next chunk, which will be returned by the next call to Chunk.
+// Calls to Next without a corresponding prior call to Chunk will have no effect.
+func (mb *MediaBuffer) Next() {
+        mb.off += int64(len(mb.chunk))
+        mb.chunk = mb.chunk[0:0]
+}
+
+type readerTyper struct {
+        io.Reader
+        googleapi.ContentTyper
+}
+
+// ReaderAtToReader adapts a ReaderAt to be used as a Reader.
+// If ra implements googleapi.ContentTyper, then the returned reader
+// will also implement googleapi.ContentTyper, delegating to ra.
+func ReaderAtToReader(ra io.ReaderAt, size int64) io.Reader {
+        r := io.NewSectionReader(ra, 0, size)
+        if typer, ok := ra.(googleapi.ContentTyper); ok {
+                return readerTyper{r, typer}
+        }
+        return r
+}
diff --git a/vendor/google.golang.org/api/gensupport/doc.go b/vendor/google.golang.org/api/gensupport/doc.go
new file mode 100644
index 0000000..752c4b4
--- /dev/null
+++ b/vendor/google.golang.org/api/gensupport/doc.go
@@ -0,0 +1,10 @@
+// Copyright 2016 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 gensupport is an internal implementation detail used by code
+// generated by the google-api-go-generator tool.
+//
+// This package may be modified at any time without regard for backwards
+// compatibility. It should not be used directly by API users.
+package gensupport
diff --git a/vendor/google.golang.org/api/gensupport/header.go b/vendor/google.golang.org/api/gensupport/header.go
new file mode 100644
index 0000000..cb5e67c
--- /dev/null
+++ b/vendor/google.golang.org/api/gensupport/header.go
@@ -0,0 +1,22 @@
+// Copyright 2017 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 gensupport
+
+import (
+        "fmt"
+        "runtime"
+        "strings"
+)
+
+// GoogleClientHeader returns the value to use for the x-goog-api-client
+// header, which is used internally by Google.
+func GoogleClientHeader(generatorVersion, clientElement string) string {
+        elts := []string{"gl-go/" + strings.Replace(runtime.Version(), " ", "_", -1)}
+        if clientElement != "" {
+                elts = append(elts, clientElement)
+        }
+        elts = append(elts, fmt.Sprintf("gdcl/%s", generatorVersion))
+        return strings.Join(elts, " ")
+}
diff --git a/vendor/google.golang.org/api/gensupport/json.go b/vendor/google.golang.org/api/gensupport/json.go
new file mode 100644
index 0000000..c01e321
--- /dev/null
+++ b/vendor/google.golang.org/api/gensupport/json.go
@@ -0,0 +1,211 @@
+// Copyright 2015 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 gensupport
+
+import (
+        "encoding/json"
+        "fmt"
+        "reflect"
+        "strings"
+)
+
+// MarshalJSON returns a JSON encoding of schema containing only selected fields.
+// A field is selected if any of the following is true:
+//   * it has a non-empty value
+//   * its field name is present in forceSendFields and it is not a nil pointer or nil interface
+//   * its field name is present in nullFields.
+// The JSON key for each selected field is taken from the field's json: struct tag.
+func MarshalJSON(schema interface{}, forceSendFields, nullFields []string) ([]byte, error) {
+        if len(forceSendFields) == 0 && len(nullFields) == 0 {
+                return json.Marshal(schema)
+        }
+
+        mustInclude := make(map[string]bool)
+        for _, f := range forceSendFields {
+                mustInclude[f] = true
+        }
+        useNull := make(map[string]bool)
+        useNullMaps := make(map[string]map[string]bool)
+        for _, nf := range nullFields {
+                parts := strings.SplitN(nf, ".", 2)
+                field := parts[0]
+                if len(parts) == 1 {
+                        useNull[field] = true
+                } else {
+                        if useNullMaps[field] == nil {
+                                useNullMaps[field] = map[string]bool{}
+                        }
+                        useNullMaps[field][parts[1]] = true
+                }
+        }
+
+        dataMap, err := schemaToMap(schema, mustInclude, useNull, useNullMaps)
+        if err != nil {
+                return nil, err
+        }
+        return json.Marshal(dataMap)
+}
+
+func schemaToMap(schema interface{}, mustInclude, useNull map[string]bool, useNullMaps map[string]map[string]bool) (map[string]interface{}, error) {
+        m := make(map[string]interface{})
+        s := reflect.ValueOf(schema)
+        st := s.Type()
+
+        for i := 0; i < s.NumField(); i++ {
+                jsonTag := st.Field(i).Tag.Get("json")
+                if jsonTag == "" {
+                        continue
+                }
+                tag, err := parseJSONTag(jsonTag)
+                if err != nil {
+                        return nil, err
+                }
+                if tag.ignore {
+                        continue
+                }
+
+                v := s.Field(i)
+                f := st.Field(i)
+
+                if useNull[f.Name] {
+                        if !isEmptyValue(v) {
+                                return nil, fmt.Errorf("field %q in NullFields has non-empty value", f.Name)
+                        }
+                        m[tag.apiName] = nil
+                        continue
+                }
+
+                if !includeField(v, f, mustInclude) {
+                        continue
+                }
+
+                // If map fields are explicitly set to null, use a map[string]interface{}.
+                if f.Type.Kind() == reflect.Map && useNullMaps[f.Name] != nil {
+                        ms, ok := v.Interface().(map[string]string)
+                        if !ok {
+                                return nil, fmt.Errorf("field %q has keys in NullFields but is not a map[string]string", f.Name)
+                        }
+                        mi := map[string]interface{}{}
+                        for k, v := range ms {
+                                mi[k] = v
+                        }
+                        for k := range useNullMaps[f.Name] {
+                                mi[k] = nil
+                        }
+                        m[tag.apiName] = mi
+                        continue
+                }
+
+                // nil maps are treated as empty maps.
+                if f.Type.Kind() == reflect.Map && v.IsNil() {
+                        m[tag.apiName] = map[string]string{}
+                        continue
+                }
+
+                // nil slices are treated as empty slices.
+                if f.Type.Kind() == reflect.Slice && v.IsNil() {
+                        m[tag.apiName] = []bool{}
+                        continue
+                }
+
+                if tag.stringFormat {
+                        m[tag.apiName] = formatAsString(v, f.Type.Kind())
+                } else {
+                        m[tag.apiName] = v.Interface()
+                }
+        }
+        return m, nil
+}
+
+// formatAsString returns a string representation of v, dereferencing it first if possible.
+func formatAsString(v reflect.Value, kind reflect.Kind) string {
+        if kind == reflect.Ptr && !v.IsNil() {
+                v = v.Elem()
+        }
+
+        return fmt.Sprintf("%v", v.Interface())
+}
+
+// jsonTag represents a restricted version of the struct tag format used by encoding/json.
+// It is used to describe the JSON encoding of fields in a Schema struct.
+type jsonTag struct {
+        apiName      string
+        stringFormat bool
+        ignore       bool
+}
+
+// parseJSONTag parses a restricted version of the struct tag format used by encoding/json.
+// The format of the tag must match that generated by the Schema.writeSchemaStruct method
+// in the api generator.
+func parseJSONTag(val string) (jsonTag, error) {
+        if val == "-" {
+                return jsonTag{ignore: true}, nil
+        }
+
+        var tag jsonTag
+
+        i := strings.Index(val, ",")
+        if i == -1 || val[:i] == "" {
+                return tag, fmt.Errorf("malformed json tag: %s", val)
+        }
+
+        tag = jsonTag{
+                apiName: val[:i],
+        }
+
+        switch val[i+1:] {
+        case "omitempty":
+        case "omitempty,string":
+                tag.stringFormat = true
+        default:
+                return tag, fmt.Errorf("malformed json tag: %s", val)
+        }
+
+        return tag, nil
+}
+
+// Reports whether the struct field "f" with value "v" should be included in JSON output.
+func includeField(v reflect.Value, f reflect.StructField, mustInclude map[string]bool) bool {
+        // The regular JSON encoding of a nil pointer is "null", which means "delete this field".
+        // Therefore, we could enable field deletion by honoring pointer fields' presence in the mustInclude set.
+        // However, many fields are not pointers, so there would be no way to delete these fields.
+        // Rather than partially supporting field deletion, we ignore mustInclude for nil pointer fields.
+        // Deletion will be handled by a separate mechanism.
+        if f.Type.Kind() == reflect.Ptr && v.IsNil() {
+                return false
+        }
+
+        // The "any" type is represented as an interface{}.  If this interface
+        // is nil, there is no reasonable representation to send.  We ignore
+        // these fields, for the same reasons as given above for pointers.
+        if f.Type.Kind() == reflect.Interface && v.IsNil() {
+                return false
+        }
+
+        return mustInclude[f.Name] || !isEmptyValue(v)
+}
+
+// isEmptyValue reports whether v is the empty value for its type.  This
+// implementation is based on that of the encoding/json package, but its
+// correctness does not depend on it being identical. What's important is that
+// this function return false in situations where v should not be sent as part
+// of a PATCH operation.
+func isEmptyValue(v reflect.Value) bool {
+        switch v.Kind() {
+        case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+                return v.Len() == 0
+        case reflect.Bool:
+                return !v.Bool()
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                return v.Int() == 0
+        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+                return v.Uint() == 0
+        case reflect.Float32, reflect.Float64:
+                return v.Float() == 0
+        case reflect.Interface, reflect.Ptr:
+                return v.IsNil()
+        }
+        return false
+}
diff --git a/vendor/google.golang.org/api/gensupport/jsonfloat.go b/vendor/google.golang.org/api/gensupport/jsonfloat.go
new file mode 100644
index 0000000..8377850
--- /dev/null
+++ b/vendor/google.golang.org/api/gensupport/jsonfloat.go
@@ -0,0 +1,57 @@
+// Copyright 2016 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package gensupport
+
+import (
+        "encoding/json"
+        "errors"
+        "fmt"
+        "math"
+)
+
+// JSONFloat64 is a float64 that supports proper unmarshaling of special float
+// values in JSON, according to
+// https://developers.google.com/protocol-buffers/docs/proto3#json. Although
+// that is a proto-to-JSON spec, it applies to all Google APIs.
+//
+// The jsonpb package
+// (https://github.com/golang/protobuf/blob/master/jsonpb/jsonpb.go) has
+// similar functionality, but only for direct translation from proto messages
+// to JSON.
+type JSONFloat64 float64
+
+func (f *JSONFloat64) UnmarshalJSON(data []byte) error {
+        var ff float64
+        if err := json.Unmarshal(data, &ff); err == nil {
+                *f = JSONFloat64(ff)
+                return nil
+        }
+        var s string
+        if err := json.Unmarshal(data, &s); err == nil {
+                switch s {
+                case "NaN":
+                        ff = math.NaN()
+                case "Infinity":
+                        ff = math.Inf(1)
+                case "-Infinity":
+                        ff = math.Inf(-1)
+                default:
+                        return fmt.Errorf("google.golang.org/api/internal: bad float string %q", s)
+                }
+                *f = JSONFloat64(ff)
+                return nil
+        }
+        return errors.New("google.golang.org/api/internal: data not float or string")
+}
diff --git a/vendor/google.golang.org/api/gensupport/media.go b/vendor/google.golang.org/api/gensupport/media.go
new file mode 100644
index 0000000..4cef4ad
--- /dev/null
+++ b/vendor/google.golang.org/api/gensupport/media.go
@@ -0,0 +1,342 @@
+// Copyright 2016 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 gensupport
+
+import (
+        "bytes"
+        "fmt"
+        "io"
+        "io/ioutil"
+        "mime/multipart"
+        "net/http"
+        "net/textproto"
+        "strings"
+        "sync"
+
+        "google.golang.org/api/googleapi"
+)
+
+const sniffBuffSize = 512
+
+func newContentSniffer(r io.Reader) *contentSniffer {
+        return &contentSniffer{r: r}
+}
+
+// contentSniffer wraps a Reader, and reports the content type determined by sniffing up to 512 bytes from the Reader.
+type contentSniffer struct {
+        r     io.Reader
+        start []byte // buffer for the sniffed bytes.
+        err   error  // set to any error encountered while reading bytes to be sniffed.
+
+        ctype   string // set on first sniff.
+        sniffed bool   // set to true on first sniff.
+}
+
+func (cs *contentSniffer) Read(p []byte) (n int, err error) {
+        // Ensure that the content type is sniffed before any data is consumed from Reader.
+        _, _ = cs.ContentType()
+
+        if len(cs.start) > 0 {
+                n := copy(p, cs.start)
+                cs.start = cs.start[n:]
+                return n, nil
+        }
+
+        // We may have read some bytes into start while sniffing, even if the read ended in an error.
+        // We should first return those bytes, then the error.
+        if cs.err != nil {
+                return 0, cs.err
+        }
+
+        // Now we have handled all bytes that were buffered while sniffing.  Now just delegate to the underlying reader.
+        return cs.r.Read(p)
+}
+
+// ContentType returns the sniffed content type, and whether the content type was succesfully sniffed.
+func (cs *contentSniffer) ContentType() (string, bool) {
+        if cs.sniffed {
+                return cs.ctype, cs.ctype != ""
+        }
+        cs.sniffed = true
+        // If ReadAll hits EOF, it returns err==nil.
+        cs.start, cs.err = ioutil.ReadAll(io.LimitReader(cs.r, sniffBuffSize))
+
+        // Don't try to detect the content type based on possibly incomplete data.
+        if cs.err != nil {
+                return "", false
+        }
+
+        cs.ctype = http.DetectContentType(cs.start)
+        return cs.ctype, true
+}
+
+// DetermineContentType determines the content type of the supplied reader.
+// If the content type is already known, it can be specified via ctype.
+// Otherwise, the content of media will be sniffed to determine the content type.
+// If media implements googleapi.ContentTyper (deprecated), this will be used
+// instead of sniffing the content.
+// After calling DetectContentType the caller must not perform further reads on
+// media, but rather read from the Reader that is returned.
+func DetermineContentType(media io.Reader, ctype string) (io.Reader, string) {
+        // Note: callers could avoid calling DetectContentType if ctype != "",
+        // but doing the check inside this function reduces the amount of
+        // generated code.
+        if ctype != "" {
+                return media, ctype
+        }
+
+        // For backwards compatability, allow clients to set content
+        // type by providing a ContentTyper for media.
+        if typer, ok := media.(googleapi.ContentTyper); ok {
+                return media, typer.ContentType()
+        }
+
+        sniffer := newContentSniffer(media)
+        if ctype, ok := sniffer.ContentType(); ok {
+                return sniffer, ctype
+        }
+        // If content type could not be sniffed, reads from sniffer will eventually fail with an error.
+        return sniffer, ""
+}
+
+type typeReader struct {
+        io.Reader
+        typ string
+}
+
+// multipartReader combines the contents of multiple readers to create a multipart/related HTTP body.
+// Close must be called if reads from the multipartReader are abandoned before reaching EOF.
+type multipartReader struct {
+        pr       *io.PipeReader
+        ctype    string
+        mu       sync.Mutex
+        pipeOpen bool
+}
+
+func newMultipartReader(parts []typeReader) *multipartReader {
+        mp := &multipartReader{pipeOpen: true}
+        var pw *io.PipeWriter
+        mp.pr, pw = io.Pipe()
+        mpw := multipart.NewWriter(pw)
+        mp.ctype = "multipart/related; boundary=" + mpw.Boundary()
+        go func() {
+                for _, part := range parts {
+                        w, err := mpw.CreatePart(typeHeader(part.typ))
+                        if err != nil {
+                                mpw.Close()
+                                pw.CloseWithError(fmt.Errorf("googleapi: CreatePart failed: %v", err))
+                                return
+                        }
+                        _, err = io.Copy(w, part.Reader)
+                        if err != nil {
+                                mpw.Close()
+                                pw.CloseWithError(fmt.Errorf("googleapi: Copy failed: %v", err))
+                                return
+                        }
+                }
+
+                mpw.Close()
+                pw.Close()
+        }()
+        return mp
+}
+
+func (mp *multipartReader) Read(data []byte) (n int, err error) {
+        return mp.pr.Read(data)
+}
+
+func (mp *multipartReader) Close() error {
+        mp.mu.Lock()
+        if !mp.pipeOpen {
+                mp.mu.Unlock()
+                return nil
+        }
+        mp.pipeOpen = false
+        mp.mu.Unlock()
+        return mp.pr.Close()
+}
+
+// CombineBodyMedia combines a json body with media content to create a multipart/related HTTP body.
+// It returns a ReadCloser containing the combined body, and the overall "multipart/related" content type, with random boundary.
+//
+// The caller must call Close on the returned ReadCloser if reads are abandoned before reaching EOF.
+func CombineBodyMedia(body io.Reader, bodyContentType string, media io.Reader, mediaContentType string) (io.ReadCloser, string) {
+        mp := newMultipartReader([]typeReader{
+                {body, bodyContentType},
+                {media, mediaContentType},
+        })
+        return mp, mp.ctype
+}
+
+func typeHeader(contentType string) textproto.MIMEHeader {
+        h := make(textproto.MIMEHeader)
+        if contentType != "" {
+                h.Set("Content-Type", contentType)
+        }
+        return h
+}
+
+// PrepareUpload determines whether the data in the supplied reader should be
+// uploaded in a single request, or in sequential chunks.
+// chunkSize is the size of the chunk that media should be split into.
+//
+// If chunkSize is zero, media is returned as the first value, and the other
+// two return values are nil, true.
+//
+// Otherwise, a MediaBuffer is returned, along with a bool indicating whether the
+// contents of media fit in a single chunk.
+//
+// After PrepareUpload has been called, media should no longer be used: the
+// media content should be accessed via one of the return values.
+func PrepareUpload(media io.Reader, chunkSize int) (r io.Reader, mb *MediaBuffer, singleChunk bool) {
+        if chunkSize == 0 { // do not chunk
+                return media, nil, true
+        }
+        mb = NewMediaBuffer(media, chunkSize)
+        _, _, _, err := mb.Chunk()
+        // If err is io.EOF, we can upload this in a single request. Otherwise, err is
+        // either nil or a non-EOF error. If it is the latter, then the next call to
+        // mb.Chunk will return the same error. Returning a MediaBuffer ensures that this
+        // error will be handled at some point.
+        return nil, mb, err == io.EOF
+}
+
+// MediaInfo holds information for media uploads. It is intended for use by generated
+// code only.
+type MediaInfo struct {
+        // At most one of Media and MediaBuffer will be set.
+        media           io.Reader
+        buffer          *MediaBuffer
+        singleChunk     bool
+        mType           string
+        size            int64 // mediaSize, if known.  Used only for calls to progressUpdater_.
+        progressUpdater googleapi.ProgressUpdater
+}
+
+// NewInfoFromMedia should be invoked from the Media method of a call. It returns a
+// MediaInfo populated with chunk size and content type, and a reader or MediaBuffer
+// if needed.
+func NewInfoFromMedia(r io.Reader, options []googleapi.MediaOption) *MediaInfo {
+        mi := &MediaInfo{}
+        opts := googleapi.ProcessMediaOptions(options)
+        if !opts.ForceEmptyContentType {
+                r, mi.mType = DetermineContentType(r, opts.ContentType)
+        }
+        mi.media, mi.buffer, mi.singleChunk = PrepareUpload(r, opts.ChunkSize)
+        return mi
+}
+
+// NewInfoFromResumableMedia should be invoked from the ResumableMedia method of a
+// call. It returns a MediaInfo using the given reader, size and media type.
+func NewInfoFromResumableMedia(r io.ReaderAt, size int64, mediaType string) *MediaInfo {
+        rdr := ReaderAtToReader(r, size)
+        rdr, mType := DetermineContentType(rdr, mediaType)
+        return &MediaInfo{
+                size:        size,
+                mType:       mType,
+                buffer:      NewMediaBuffer(rdr, googleapi.DefaultUploadChunkSize),
+                media:       nil,
+                singleChunk: false,
+        }
+}
+
+// SetProgressUpdater sets the progress updater for the media info.
+func (mi *MediaInfo) SetProgressUpdater(pu googleapi.ProgressUpdater) {
+        if mi != nil {
+                mi.progressUpdater = pu
+        }
+}
+
+// UploadType determines the type of upload: a single request, or a resumable
+// series of requests.
+func (mi *MediaInfo) UploadType() string {
+        if mi.singleChunk {
+                return "multipart"
+        }
+        return "resumable"
+}
+
+// UploadRequest sets up an HTTP request for media upload. It adds headers
+// as necessary, and returns a replacement for the body and a function for http.Request.GetBody.
+func (mi *MediaInfo) UploadRequest(reqHeaders http.Header, body io.Reader) (newBody io.Reader, getBody func() (io.ReadCloser, error), cleanup func()) {
+        cleanup = func() {}
+        if mi == nil {
+                return body, nil, cleanup
+        }
+        var media io.Reader
+        if mi.media != nil {
+                // This only happens when the caller has turned off chunking. In that
+                // case, we write all of media in a single non-retryable request.
+                media = mi.media
+        } else if mi.singleChunk {
+                // The data fits in a single chunk, which has now been read into the MediaBuffer.
+                // We obtain that chunk so we can write it in a single request. The request can
+                // be retried because the data is stored in the MediaBuffer.
+                media, _, _, _ = mi.buffer.Chunk()
+        }
+        if media != nil {
+                fb := readerFunc(body)
+                fm := readerFunc(media)
+                combined, ctype := CombineBodyMedia(body, "application/json", media, mi.mType)
+                if fb != nil && fm != nil {
+                        getBody = func() (io.ReadCloser, error) {
+                                rb := ioutil.NopCloser(fb())
+                                rm := ioutil.NopCloser(fm())
+                                r, _ := CombineBodyMedia(rb, "application/json", rm, mi.mType)
+                                return r, nil
+                        }
+                }
+                cleanup = func() { combined.Close() }
+                reqHeaders.Set("Content-Type", ctype)
+                body = combined
+        }
+        if mi.buffer != nil && mi.mType != "" && !mi.singleChunk {
+                reqHeaders.Set("X-Upload-Content-Type", mi.mType)
+        }
+        return body, getBody, cleanup
+}
+
+// readerFunc returns a function that always returns an io.Reader that has the same
+// contents as r, provided that can be done without consuming r. Otherwise, it
+// returns nil.
+// See http.NewRequest (in net/http/request.go).
+func readerFunc(r io.Reader) func() io.Reader {
+        switch r := r.(type) {
+        case *bytes.Buffer:
+                buf := r.Bytes()
+                return func() io.Reader { return bytes.NewReader(buf) }
+        case *bytes.Reader:
+                snapshot := *r
+                return func() io.Reader { r := snapshot; return &r }
+        case *strings.Reader:
+                snapshot := *r
+                return func() io.Reader { r := snapshot; return &r }
+        default:
+                return nil
+        }
+}
+
+// ResumableUpload returns an appropriately configured ResumableUpload value if the
+// upload is resumable, or nil otherwise.
+func (mi *MediaInfo) ResumableUpload(locURI string) *ResumableUpload {
+        if mi == nil || mi.singleChunk {
+                return nil
+        }
+        return &ResumableUpload{
+                URI:       locURI,
+                Media:     mi.buffer,
+                MediaType: mi.mType,
+                Callback: func(curr int64) {
+                        if mi.progressUpdater != nil {
+                                mi.progressUpdater(curr, mi.size)
+                        }
+                },
+        }
+}
+
+// SetGetBody sets the GetBody field of req to f.
+func SetGetBody(req *http.Request, f func() (io.ReadCloser, error)) {
+        req.GetBody = f
+}
diff --git a/vendor/google.golang.org/api/gensupport/params.go b/vendor/google.golang.org/api/gensupport/params.go
new file mode 100644
index 0000000..0e878a4
--- /dev/null
+++ b/vendor/google.golang.org/api/gensupport/params.go
@@ -0,0 +1,51 @@
+// Copyright 2015 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 gensupport
+
+import (
+        "net/url"
+
+        "google.golang.org/api/googleapi"
+)
+
+// URLParams is a simplified replacement for url.Values
+// that safely builds up URL parameters for encoding.
+type URLParams map[string][]string
+
+// Get returns the first value for the given key, or "".
+func (u URLParams) Get(key string) string {
+        vs := u[key]
+        if len(vs) == 0 {
+                return ""
+        }
+        return vs[0]
+}
+
+// Set sets the key to value.
+// It replaces any existing values.
+func (u URLParams) Set(key, value string) {
+        u[key] = []string{value}
+}
+
+// SetMulti sets the key to an array of values.
+// It replaces any existing values.
+// Note that values must not be modified after calling SetMulti
+// so the caller is responsible for making a copy if necessary.
+func (u URLParams) SetMulti(key string, values []string) {
+        u[key] = values
+}
+
+// Encode encodes the values into ``URL encoded'' form
+// ("bar=baz&foo=quux") sorted by key.
+func (u URLParams) Encode() string {
+        return url.Values(u).Encode()
+}
+
+// SetOptions sets the URL params and any additional call options.
+func SetOptions(u URLParams, opts ...googleapi.CallOption) {
+        for _, o := range opts {
+                u.Set(o.Get())
+        }
+}
diff --git a/vendor/google.golang.org/api/gensupport/resumable.go b/vendor/google.golang.org/api/gensupport/resumable.go
new file mode 100644
index 0000000..2552a6a
--- /dev/null
+++ b/vendor/google.golang.org/api/gensupport/resumable.go
@@ -0,0 +1,216 @@
+// Copyright 2016 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 gensupport
+
+import (
+        "context"
+        "errors"
+        "fmt"
+        "io"
+        "net/http"
+        "sync"
+        "time"
+)
+
+const (
+        // statusTooManyRequests is returned by the storage API if the
+        // per-project limits have been temporarily exceeded. The request
+        // should be retried.
+        // https://cloud.google.com/storage/docs/json_api/v1/status-codes#standardcodes
+        statusTooManyRequests = 429
+)
+
+// ResumableUpload is used by the generated APIs to provide resumable uploads.
+// It is not used by developers directly.
+type ResumableUpload struct {
+        Client *http.Client
+        // URI is the resumable resource destination provided by the server after specifying "&uploadType=resumable".
+        URI       string
+        UserAgent string // User-Agent for header of the request
+        // Media is the object being uploaded.
+        Media *MediaBuffer
+        // MediaType defines the media type, e.g. "image/jpeg".
+        MediaType string
+
+        mu       sync.Mutex // guards progress
+        progress int64      // number of bytes uploaded so far
+
+        // Callback is an optional function that will be periodically called with the cumulative number of bytes uploaded.
+        Callback func(int64)
+
+        // If not specified, a default exponential backoff strategy will be used.
+        Backoff BackoffStrategy
+}
+
+// Progress returns the number of bytes uploaded at this point.
+func (rx *ResumableUpload) Progress() int64 {
+        rx.mu.Lock()
+        defer rx.mu.Unlock()
+        return rx.progress
+}
+
+// doUploadRequest performs a single HTTP request to upload data.
+// off specifies the offset in rx.Media from which data is drawn.
+// size is the number of bytes in data.
+// final specifies whether data is the final chunk to be uploaded.
+func (rx *ResumableUpload) doUploadRequest(ctx context.Context, data io.Reader, off, size int64, final bool) (*http.Response, error) {
+        req, err := http.NewRequest("POST", rx.URI, data)
+        if err != nil {
+                return nil, err
+        }
+
+        req.ContentLength = size
+        var contentRange string
+        if final {
+                if size == 0 {
+                        contentRange = fmt.Sprintf("bytes */%v", off)
+                } else {
+                        contentRange = fmt.Sprintf("bytes %v-%v/%v", off, off+size-1, off+size)
+                }
+        } else {
+                contentRange = fmt.Sprintf("bytes %v-%v/*", off, off+size-1)
+        }
+        req.Header.Set("Content-Range", contentRange)
+        req.Header.Set("Content-Type", rx.MediaType)
+        req.Header.Set("User-Agent", rx.UserAgent)
+
+        // Google's upload endpoint uses status code 308 for a
+        // different purpose than the "308 Permanent Redirect"
+        // since-standardized in RFC 7238. Because of the conflict in
+        // semantics, Google added this new request header which
+        // causes it to not use "308" and instead reply with 200 OK
+        // and sets the upload-specific "X-HTTP-Status-Code-Override:
+        // 308" response header.
+        req.Header.Set("X-GUploader-No-308", "yes")
+
+        return SendRequest(ctx, rx.Client, req)
+}
+
+func statusResumeIncomplete(resp *http.Response) bool {
+        // This is how the server signals "status resume incomplete"
+        // when X-GUploader-No-308 is set to "yes":
+        return resp != nil && resp.Header.Get("X-Http-Status-Code-Override") == "308"
+}
+
+// reportProgress calls a user-supplied callback to report upload progress.
+// If old==updated, the callback is not called.
+func (rx *ResumableUpload) reportProgress(old, updated int64) {
+        if updated-old == 0 {
+                return
+        }
+        rx.mu.Lock()
+        rx.progress = updated
+        rx.mu.Unlock()
+        if rx.Callback != nil {
+                rx.Callback(updated)
+        }
+}
+
+// transferChunk performs a single HTTP request to upload a single chunk from rx.Media.
+func (rx *ResumableUpload) transferChunk(ctx context.Context) (*http.Response, error) {
+        chunk, off, size, err := rx.Media.Chunk()
+
+        done := err == io.EOF
+        if !done && err != nil {
+                return nil, err
+        }
+
+        res, err := rx.doUploadRequest(ctx, chunk, off, int64(size), done)
+        if err != nil {
+                return res, err
+        }
+
+        // We sent "X-GUploader-No-308: yes" (see comment elsewhere in
+        // this file), so we don't expect to get a 308.
+        if res.StatusCode == 308 {
+                return nil, errors.New("unexpected 308 response status code")
+        }
+
+        if res.StatusCode == http.StatusOK {
+                rx.reportProgress(off, off+int64(size))
+        }
+
+        if statusResumeIncomplete(res) {
+                rx.Media.Next()
+        }
+        return res, nil
+}
+
+func contextDone(ctx context.Context) bool {
+        select {
+        case <-ctx.Done():
+                return true
+        default:
+                return false
+        }
+}
+
+// Upload starts the process of a resumable upload with a cancellable context.
+// It retries using the provided back off strategy until cancelled or the
+// strategy indicates to stop retrying.
+// It is called from the auto-generated API code and is not visible to the user.
+// Before sending an HTTP request, Upload calls any registered hook functions,
+// and calls the returned functions after the request returns (see send.go).
+// rx is private to the auto-generated API code.
+// Exactly one of resp or err will be nil.  If resp is non-nil, the caller must call resp.Body.Close.
+func (rx *ResumableUpload) Upload(ctx context.Context) (resp *http.Response, err error) {
+        var pause time.Duration
+        backoff := rx.Backoff
+        if backoff == nil {
+                backoff = DefaultBackoffStrategy()
+        }
+
+        for {
+                // Ensure that we return in the case of cancelled context, even if pause is 0.
+                if contextDone(ctx) {
+                        return nil, ctx.Err()
+                }
+                select {
+                case <-ctx.Done():
+                        return nil, ctx.Err()
+                case <-time.After(pause):
+                }
+
+                resp, err = rx.transferChunk(ctx)
+
+                var status int
+                if resp != nil {
+                        status = resp.StatusCode
+                }
+
+                // Check if we should retry the request.
+                if shouldRetry(status, err) {
+                        var retry bool
+                        pause, retry = backoff.Pause()
+                        if retry {
+                                if resp != nil && resp.Body != nil {
+                                        resp.Body.Close()
+                                }
+                                continue
+                        }
+                }
+
+                // If the chunk was uploaded successfully, but there's still
+                // more to go, upload the next chunk without any delay.
+                if statusResumeIncomplete(resp) {
+                        pause = 0
+                        backoff.Reset()
+                        resp.Body.Close()
+                        continue
+                }
+
+                // It's possible for err and resp to both be non-nil here, but we expose a simpler
+                // contract to our callers: exactly one of resp and err will be non-nil.  This means
+                // that any response body must be closed here before returning a non-nil error.
+                if err != nil {
+                        if resp != nil && resp.Body != nil {
+                                resp.Body.Close()
+                        }
+                        return nil, err
+                }
+
+                return resp, nil
+        }
+}
diff --git a/vendor/google.golang.org/api/gensupport/retry.go b/vendor/google.golang.org/api/gensupport/retry.go
new file mode 100644
index 0000000..fdde3f4
--- /dev/null
+++ b/vendor/google.golang.org/api/gensupport/retry.go
@@ -0,0 +1,84 @@
+// Copyright 2017 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package gensupport
+
+import (
+        "context"
+        "io"
+        "net"
+        "net/http"
+        "time"
+)
+
+// Retry invokes the given function, retrying it multiple times if the connection failed or
+// the HTTP status response indicates the request should be attempted again. ctx may be nil.
+func Retry(ctx context.Context, f func() (*http.Response, error), backoff BackoffStrategy) (*http.Response, error) {
+        for {
+                resp, err := f()
+
+                var status int
+                if resp != nil {
+                        status = resp.StatusCode
+                }
+
+                // Return if we shouldn't retry.
+                pause, retry := backoff.Pause()
+                if !shouldRetry(status, err) || !retry {
+                        return resp, err
+                }
+
+                // Ensure the response body is closed, if any.
+                if resp != nil && resp.Body != nil {
+                        resp.Body.Close()
+                }
+
+                // Pause, but still listen to ctx.Done if context is not nil.
+                var done <-chan struct{}
+                if ctx != nil {
+                        done = ctx.Done()
+                }
+                select {
+                case <-done:
+                        return nil, ctx.Err()
+                case <-time.After(pause):
+                }
+        }
+}
+
+// DefaultBackoffStrategy returns a default strategy to use for retrying failed upload requests.
+func DefaultBackoffStrategy() BackoffStrategy {
+        return &ExponentialBackoff{
+                Base: 250 * time.Millisecond,
+                Max:  16 * time.Second,
+        }
+}
+
+// shouldRetry returns true if the HTTP response / error indicates that the
+// request should be attempted again.
+func shouldRetry(status int, err error) bool {
+        if 500 <= status && status <= 599 {
+                return true
+        }
+        if status == statusTooManyRequests {
+                return true
+        }
+        if err == io.ErrUnexpectedEOF {
+                return true
+        }
+        if err, ok := err.(net.Error); ok {
+                return err.Temporary()
+        }
+        return false
+}
diff --git a/vendor/google.golang.org/api/gensupport/send.go b/vendor/google.golang.org/api/gensupport/send.go
new file mode 100644
index 0000000..5799393
--- /dev/null
+++ b/vendor/google.golang.org/api/gensupport/send.go
@@ -0,0 +1,87 @@
+// Copyright 2016 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 gensupport
+
+import (
+        "context"
+        "encoding/json"
+        "errors"
+        "net/http"
+)
+
+// Hook is the type of a function that is called once before each HTTP request
+// that is sent by a generated API.  It returns a function that is called after
+// the request returns.
+// Hooks are not called if the context is nil.
+type Hook func(ctx context.Context, req *http.Request) func(resp *http.Response)
+
+var hooks []Hook
+
+// RegisterHook registers a Hook to be called before each HTTP request by a
+// generated API.  Hooks are called in the order they are registered.  Each
+// hook can return a function; if it is non-nil, it is called after the HTTP
+// request returns.  These functions are called in the reverse order.
+// RegisterHook should not be called concurrently with itself or SendRequest.
+func RegisterHook(h Hook) {
+        hooks = append(hooks, h)
+}
+
+// SendRequest sends a single HTTP request using the given client.
+// If ctx is non-nil, it calls all hooks, then sends the request with
+// req.WithContext, then calls any functions returned by the hooks in
+// reverse order.
+func SendRequest(ctx context.Context, client *http.Client, req *http.Request) (*http.Response, error) {
+        // Disallow Accept-Encoding because it interferes with the automatic gzip handling
+        // done by the default http.Transport. See https://github.com/google/google-api-go-client/issues/219.
+        if _, ok := req.Header["Accept-Encoding"]; ok {
+                return nil, errors.New("google api: custom Accept-Encoding headers not allowed")
+        }
+        if ctx == nil {
+                return client.Do(req)
+        }
+        // Call hooks in order of registration, store returned funcs.
+        post := make([]func(resp *http.Response), len(hooks))
+        for i, h := range hooks {
+                fn := h(ctx, req)
+                post[i] = fn
+        }
+
+        // Send request.
+        resp, err := send(ctx, client, req)
+
+        // Call returned funcs in reverse order.
+        for i := len(post) - 1; i >= 0; i-- {
+                if fn := post[i]; fn != nil {
+                        fn(resp)
+                }
+        }
+        return resp, err
+}
+
+func send(ctx context.Context, client *http.Client, req *http.Request) (*http.Response, error) {
+        if client == nil {
+                client = http.DefaultClient
+        }
+        resp, err := client.Do(req.WithContext(ctx))
+        // If we got an error, and the context has been canceled,
+        // the context's error is probably more useful.
+        if err != nil {
+                select {
+                case <-ctx.Done():
+                        err = ctx.Err()
+                default:
+                }
+        }
+        return resp, err
+}
+
+// DecodeResponse decodes the body of res into target. If there is no body,
+// target is unchanged.
+func DecodeResponse(target interface{}, res *http.Response) error {
+        if res.StatusCode == http.StatusNoContent {
+                return nil
+        }
+        return json.NewDecoder(res.Body).Decode(target)
+}
diff --git a/vendor/google.golang.org/api/googleapi/googleapi.go b/vendor/google.golang.org/api/googleapi/googleapi.go
new file mode 100644
index 0000000..8cdb03b
--- /dev/null
+++ b/vendor/google.golang.org/api/googleapi/googleapi.go
@@ -0,0 +1,429 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package googleapi contains the common code shared by all Google API
+// libraries.
+package googleapi // import "google.golang.org/api/googleapi"
+
+import (
+        "bytes"
+        "encoding/json"
+        "fmt"
+        "io"
+        "io/ioutil"
+        "net/http"
+        "net/url"
+        "strings"
+
+        "google.golang.org/api/googleapi/internal/uritemplates"
+)
+
+// ContentTyper is an interface for Readers which know (or would like
+// to override) their Content-Type. If a media body doesn't implement
+// ContentTyper, the type is sniffed from the content using
+// http.DetectContentType.
+type ContentTyper interface {
+        ContentType() string
+}
+
+// A SizeReaderAt is a ReaderAt with a Size method.
+// An io.SectionReader implements SizeReaderAt.
+type SizeReaderAt interface {
+        io.ReaderAt
+        Size() int64
+}
+
+// ServerResponse is embedded in each Do response and
+// provides the HTTP status code and header sent by the server.
+type ServerResponse struct {
+        // HTTPStatusCode is the server's response status code. When using a
+        // resource method's Do call, this will always be in the 2xx range.
+        HTTPStatusCode int
+        // Header contains the response header fields from the server.
+        Header http.Header
+}
+
+const (
+        // Version defines the gax version being used. This is typically sent
+        // in an HTTP header to services.
+        Version = "0.5"
+
+        // UserAgent is the header string used to identify this package.
+        UserAgent = "google-api-go-client/" + Version
+
+        // DefaultUploadChunkSize is the default chunk size to use for resumable
+        // uploads if not specified by the user.
+        DefaultUploadChunkSize = 8 * 1024 * 1024
+
+        // MinUploadChunkSize is the minimum chunk size that can be used for
+        // resumable uploads.  All user-specified chunk sizes must be multiple of
+        // this value.
+        MinUploadChunkSize = 256 * 1024
+)
+
+// Error contains an error response from the server.
+type Error struct {
+        // Code is the HTTP response status code and will always be populated.
+        Code int `json:"code"`
+        // Message is the server response message and is only populated when
+        // explicitly referenced by the JSON server response.
+        Message string `json:"message"`
+        // Body is the raw response returned by the server.
+        // It is often but not always JSON, depending on how the request fails.
+        Body string
+        // Header contains the response header fields from the server.
+        Header http.Header
+
+        Errors []ErrorItem
+}
+
+// ErrorItem is a detailed error code & message from the Google API frontend.
+type ErrorItem struct {
+        // Reason is the typed error code. For example: "some_example".
+        Reason string `json:"reason"`
+        // Message is the human-readable description of the error.
+        Message string `json:"message"`
+}
+
+func (e *Error) Error() string {
+        if len(e.Errors) == 0 && e.Message == "" {
+                return fmt.Sprintf("googleapi: got HTTP response code %d with body: %v", e.Code, e.Body)
+        }
+        var buf bytes.Buffer
+        fmt.Fprintf(&buf, "googleapi: Error %d: ", e.Code)
+        if e.Message != "" {
+                fmt.Fprintf(&buf, "%s", e.Message)
+        }
+        if len(e.Errors) == 0 {
+                return strings.TrimSpace(buf.String())
+        }
+        if len(e.Errors) == 1 && e.Errors[0].Message == e.Message {
+                fmt.Fprintf(&buf, ", %s", e.Errors[0].Reason)
+                return buf.String()
+        }
+        fmt.Fprintln(&buf, "\nMore details:")
+        for _, v := range e.Errors {
+                fmt.Fprintf(&buf, "Reason: %s, Message: %s\n", v.Reason, v.Message)
+        }
+        return buf.String()
+}
+
+type errorReply struct {
+        Error *Error `json:"error"`
+}
+
+// CheckResponse returns an error (of type *Error) if the response
+// status code is not 2xx.
+func CheckResponse(res *http.Response) error {
+        if res.StatusCode >= 200 && res.StatusCode <= 299 {
+                return nil
+        }
+        slurp, err := ioutil.ReadAll(res.Body)
+        if err == nil {
+                jerr := new(errorReply)
+                err = json.Unmarshal(slurp, jerr)
+                if err == nil && jerr.Error != nil {
+                        if jerr.Error.Code == 0 {
+                                jerr.Error.Code = res.StatusCode
+                        }
+                        jerr.Error.Body = string(slurp)
+                        return jerr.Error
+                }
+        }
+        return &Error{
+                Code:   res.StatusCode,
+                Body:   string(slurp),
+                Header: res.Header,
+        }
+}
+
+// IsNotModified reports whether err is the result of the
+// server replying with http.StatusNotModified.
+// Such error values are sometimes returned by "Do" methods
+// on calls when If-None-Match is used.
+func IsNotModified(err error) bool {
+        if err == nil {
+                return false
+        }
+        ae, ok := err.(*Error)
+        return ok && ae.Code == http.StatusNotModified
+}
+
+// CheckMediaResponse returns an error (of type *Error) if the response
+// status code is not 2xx. Unlike CheckResponse it does not assume the
+// body is a JSON error document.
+// It is the caller's responsibility to close res.Body.
+func CheckMediaResponse(res *http.Response) error {
+        if res.StatusCode >= 200 && res.StatusCode <= 299 {
+                return nil
+        }
+        slurp, _ := ioutil.ReadAll(io.LimitReader(res.Body, 1<<20))
+        return &Error{
+                Code: res.StatusCode,
+                Body: string(slurp),
+        }
+}
+
+// MarshalStyle defines whether to marshal JSON with a {"data": ...} wrapper.
+type MarshalStyle bool
+
+// WithDataWrapper marshals JSON with a {"data": ...} wrapper.
+var WithDataWrapper = MarshalStyle(true)
+
+// WithoutDataWrapper marshals JSON without a {"data": ...} wrapper.
+var WithoutDataWrapper = MarshalStyle(false)
+
+func (wrap MarshalStyle) JSONReader(v interface{}) (io.Reader, error) {
+        buf := new(bytes.Buffer)
+        if wrap {
+                buf.Write([]byte(`{"data": `))
+        }
+        err := json.NewEncoder(buf).Encode(v)
+        if err != nil {
+                return nil, err
+        }
+        if wrap {
+                buf.Write([]byte(`}`))
+        }
+        return buf, nil
+}
+
+// endingWithErrorReader from r until it returns an error.  If the
+// final error from r is io.EOF and e is non-nil, e is used instead.
+type endingWithErrorReader struct {
+        r io.Reader
+        e error
+}
+
+func (er endingWithErrorReader) Read(p []byte) (n int, err error) {
+        n, err = er.r.Read(p)
+        if err == io.EOF && er.e != nil {
+                err = er.e
+        }
+        return
+}
+
+// countingWriter counts the number of bytes it receives to write, but
+// discards them.
+type countingWriter struct {
+        n *int64
+}
+
+func (w countingWriter) Write(p []byte) (int, error) {
+        *w.n += int64(len(p))
+        return len(p), nil
+}
+
+// ProgressUpdater is a function that is called upon every progress update of a resumable upload.
+// This is the only part of a resumable upload (from googleapi) that is usable by the developer.
+// The remaining usable pieces of resumable uploads is exposed in each auto-generated API.
+type ProgressUpdater func(current, total int64)
+
+// MediaOption defines the interface for setting media options.
+type MediaOption interface {
+        setOptions(o *MediaOptions)
+}
+
+type contentTypeOption string
+
+func (ct contentTypeOption) setOptions(o *MediaOptions) {
+        o.ContentType = string(ct)
+        if o.ContentType == "" {
+                o.ForceEmptyContentType = true
+        }
+}
+
+// ContentType returns a MediaOption which sets the Content-Type header for media uploads.
+// If ctype is empty, the Content-Type header will be omitted.
+func ContentType(ctype string) MediaOption {
+        return contentTypeOption(ctype)
+}
+
+type chunkSizeOption int
+
+func (cs chunkSizeOption) setOptions(o *MediaOptions) {
+        size := int(cs)
+        if size%MinUploadChunkSize != 0 {
+                size += MinUploadChunkSize - (size % MinUploadChunkSize)
+        }
+        o.ChunkSize = size
+}
+
+// ChunkSize returns a MediaOption which sets the chunk size for media uploads.
+// size will be rounded up to the nearest multiple of 256K.
+// Media which contains fewer than size bytes will be uploaded in a single request.
+// Media which contains size bytes or more will be uploaded in separate chunks.
+// If size is zero, media will be uploaded in a single request.
+func ChunkSize(size int) MediaOption {
+        return chunkSizeOption(size)
+}
+
+// MediaOptions stores options for customizing media upload.  It is not used by developers directly.
+type MediaOptions struct {
+        ContentType           string
+        ForceEmptyContentType bool
+
+        ChunkSize int
+}
+
+// ProcessMediaOptions stores options from opts in a MediaOptions.
+// It is not used by developers directly.
+func ProcessMediaOptions(opts []MediaOption) *MediaOptions {
+        mo := &MediaOptions{ChunkSize: DefaultUploadChunkSize}
+        for _, o := range opts {
+                o.setOptions(mo)
+        }
+        return mo
+}
+
+// ResolveRelative resolves relatives such as "http://www.golang.org/" and
+// "topics/myproject/mytopic" into a single string, such as
+// "http://www.golang.org/topics/myproject/mytopic". It strips all parent
+// references (e.g. ../..) as well as anything after the host
+// (e.g. /bar/gaz gets stripped out of foo.com/bar/gaz).
+func ResolveRelative(basestr, relstr string) string {
+        u, _ := url.Parse(basestr)
+        afterColonPath := ""
+        if i := strings.IndexRune(relstr, ':'); i > 0 {
+                afterColonPath = relstr[i+1:]
+                relstr = relstr[:i]
+        }
+        rel, _ := url.Parse(relstr)
+        u = u.ResolveReference(rel)
+        us := u.String()
+        if afterColonPath != "" {
+                us = fmt.Sprintf("%s:%s", us, afterColonPath)
+        }
+        us = strings.Replace(us, "%7B", "{", -1)
+        us = strings.Replace(us, "%7D", "}", -1)
+        us = strings.Replace(us, "%2A", "*", -1)
+        return us
+}
+
+// Expand subsitutes any {encoded} strings in the URL passed in using
+// the map supplied.
+//
+// This calls SetOpaque to avoid encoding of the parameters in the URL path.
+func Expand(u *url.URL, expansions map[string]string) {
+        escaped, unescaped, err := uritemplates.Expand(u.Path, expansions)
+        if err == nil {
+                u.Path = unescaped
+                u.RawPath = escaped
+        }
+}
+
+// CloseBody is used to close res.Body.
+// Prior to calling Close, it also tries to Read a small amount to see an EOF.
+// Not seeing an EOF can prevent HTTP Transports from reusing connections.
+func CloseBody(res *http.Response) {
+        if res == nil || res.Body == nil {
+                return
+        }
+        // Justification for 3 byte reads: two for up to "\r\n" after
+        // a JSON/XML document, and then 1 to see EOF if we haven't yet.
+        // TODO(bradfitz): detect Go 1.3+ and skip these reads.
+        // See https://codereview.appspot.com/58240043
+        // and https://codereview.appspot.com/49570044
+        buf := make([]byte, 1)
+        for i := 0; i < 3; i++ {
+                _, err := res.Body.Read(buf)
+                if err != nil {
+                        break
+                }
+        }
+        res.Body.Close()
+
+}
+
+// VariantType returns the type name of the given variant.
+// If the map doesn't contain the named key or the value is not a []interface{}, "" is returned.
+// This is used to support "variant" APIs that can return one of a number of different types.
+func VariantType(t map[string]interface{}) string {
+        s, _ := t["type"].(string)
+        return s
+}
+
+// ConvertVariant uses the JSON encoder/decoder to fill in the struct 'dst' with the fields found in variant 'v'.
+// This is used to support "variant" APIs that can return one of a number of different types.
+// It reports whether the conversion was successful.
+func ConvertVariant(v map[string]interface{}, dst interface{}) bool {
+        var buf bytes.Buffer
+        err := json.NewEncoder(&buf).Encode(v)
+        if err != nil {
+                return false
+        }
+        return json.Unmarshal(buf.Bytes(), dst) == nil
+}
+
+// A Field names a field to be retrieved with a partial response.
+// See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+//
+// Partial responses can dramatically reduce the amount of data that must be sent to your application.
+// In order to request partial responses, you can specify the full list of fields
+// that your application needs by adding the Fields option to your request.
+//
+// Field strings use camelCase with leading lower-case characters to identify fields within the response.
+//
+// For example, if your response has a "NextPageToken" and a slice of "Items" with "Id" fields,
+// you could request just those fields like this:
+//
+//     svc.Events.List().Fields("nextPageToken", "items/id").Do()
+//
+// or if you were also interested in each Item's "Updated" field, you can combine them like this:
+//
+//     svc.Events.List().Fields("nextPageToken", "items(id,updated)").Do()
+//
+// More information about field formatting can be found here:
+// https://developers.google.com/+/api/#fields-syntax
+//
+// Another way to find field names is through the Google API explorer:
+// https://developers.google.com/apis-explorer/#p/
+type Field string
+
+// CombineFields combines fields into a single string.
+func CombineFields(s []Field) string {
+        r := make([]string, len(s))
+        for i, v := range s {
+                r[i] = string(v)
+        }
+        return strings.Join(r, ",")
+}
+
+// A CallOption is an optional argument to an API call.
+// It should be treated as an opaque value by users of Google APIs.
+//
+// A CallOption is something that configures an API call in a way that is
+// not specific to that API; for instance, controlling the quota user for
+// an API call is common across many APIs, and is thus a CallOption.
+type CallOption interface {
+        Get() (key, value string)
+}
+
+// QuotaUser returns a CallOption that will set the quota user for a call.
+// The quota user can be used by server-side applications to control accounting.
+// It can be an arbitrary string up to 40 characters, and will override UserIP
+// if both are provided.
+func QuotaUser(u string) CallOption { return quotaUser(u) }
+
+type quotaUser string
+
+func (q quotaUser) Get() (string, string) { return "quotaUser", string(q) }
+
+// UserIP returns a CallOption that will set the "userIp" parameter of a call.
+// This should be the IP address of the originating request.
+func UserIP(ip string) CallOption { return userIP(ip) }
+
+type userIP string
+
+func (i userIP) Get() (string, string) { return "userIp", string(i) }
+
+// Trace returns a CallOption that enables diagnostic tracing for a call.
+// traceToken is an ID supplied by Google support.
+func Trace(traceToken string) CallOption { return traceTok(traceToken) }
+
+type traceTok string
+
+func (t traceTok) Get() (string, string) { return "trace", "token:" + string(t) }
+
+// TODO: Fields too
diff --git a/vendor/google.golang.org/api/googleapi/internal/uritemplates/LICENSE b/vendor/google.golang.org/api/googleapi/internal/uritemplates/LICENSE
new file mode 100644
index 0000000..de9c88c
--- /dev/null
+++ b/vendor/google.golang.org/api/googleapi/internal/uritemplates/LICENSE
@@ -0,0 +1,18 @@
+Copyright (c) 2013 Joshua Tacoma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/google.golang.org/api/googleapi/internal/uritemplates/uritemplates.go b/vendor/google.golang.org/api/googleapi/internal/uritemplates/uritemplates.go
new file mode 100644
index 0000000..63bf053
--- /dev/null
+++ b/vendor/google.golang.org/api/googleapi/internal/uritemplates/uritemplates.go
@@ -0,0 +1,248 @@
+// Copyright 2013 Joshua Tacoma. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package uritemplates is a level 3 implementation of RFC 6570 (URI
+// Template, http://tools.ietf.org/html/rfc6570).
+// uritemplates does not support composite values (in Go: slices or maps)
+// and so does not qualify as a level 4 implementation.
+package uritemplates
+
+import (
+        "bytes"
+        "errors"
+        "regexp"
+        "strconv"
+        "strings"
+)
+
+var (
+        unreserved = regexp.MustCompile("[^A-Za-z0-9\\-._~]")
+        reserved   = regexp.MustCompile("[^A-Za-z0-9\\-._~:/?#[\\]@!$&'()*+,;=]")
+        validname  = regexp.MustCompile("^([A-Za-z0-9_\\.]|%[0-9A-Fa-f][0-9A-Fa-f])+$")
+        hex        = []byte("0123456789ABCDEF")
+)
+
+func pctEncode(src []byte) []byte {
+        dst := make([]byte, len(src)*3)
+        for i, b := range src {
+                buf := dst[i*3 : i*3+3]
+                buf[0] = 0x25
+                buf[1] = hex[b/16]
+                buf[2] = hex[b%16]
+        }
+        return dst
+}
+
+// pairWriter is a convenience struct which allows escaped and unescaped
+// versions of the template to be written in parallel.
+type pairWriter struct {
+        escaped, unescaped bytes.Buffer
+}
+
+// Write writes the provided string directly without any escaping.
+func (w *pairWriter) Write(s string) {
+        w.escaped.WriteString(s)
+        w.unescaped.WriteString(s)
+}
+
+// Escape writes the provided string, escaping the string for the
+// escaped output.
+func (w *pairWriter) Escape(s string, allowReserved bool) {
+        w.unescaped.WriteString(s)
+        if allowReserved {
+                w.escaped.Write(reserved.ReplaceAllFunc([]byte(s), pctEncode))
+        } else {
+                w.escaped.Write(unreserved.ReplaceAllFunc([]byte(s), pctEncode))
+        }
+}
+
+// Escaped returns the escaped string.
+func (w *pairWriter) Escaped() string {
+        return w.escaped.String()
+}
+
+// Unescaped returns the unescaped string.
+func (w *pairWriter) Unescaped() string {
+        return w.unescaped.String()
+}
+
+// A uriTemplate is a parsed representation of a URI template.
+type uriTemplate struct {
+        raw   string
+        parts []templatePart
+}
+
+// parse parses a URI template string into a uriTemplate object.
+func parse(rawTemplate string) (*uriTemplate, error) {
+        split := strings.Split(rawTemplate, "{")
+        parts := make([]templatePart, len(split)*2-1)
+        for i, s := range split {
+                if i == 0 {
+                        if strings.Contains(s, "}") {
+                                return nil, errors.New("unexpected }")
+                        }
+                        parts[i].raw = s
+                        continue
+                }
+                subsplit := strings.Split(s, "}")
+                if len(subsplit) != 2 {
+                        return nil, errors.New("malformed template")
+                }
+                expression := subsplit[0]
+                var err error
+                parts[i*2-1], err = parseExpression(expression)
+                if err != nil {
+                        return nil, err
+                }
+                parts[i*2].raw = subsplit[1]
+        }
+        return &uriTemplate{
+                raw:   rawTemplate,
+                parts: parts,
+        }, nil
+}
+
+type templatePart struct {
+        raw           string
+        terms         []templateTerm
+        first         string
+        sep           string
+        named         bool
+        ifemp         string
+        allowReserved bool
+}
+
+type templateTerm struct {
+        name     string
+        explode  bool
+        truncate int
+}
+
+func parseExpression(expression string) (result templatePart, err error) {
+        switch expression[0] {
+        case '+':
+                result.sep = ","
+                result.allowReserved = true
+                expression = expression[1:]
+        case '.':
+                result.first = "."
+                result.sep = "."
+                expression = expression[1:]
+        case '/':
+                result.first = "/"
+                result.sep = "/"
+                expression = expression[1:]
+        case ';':
+                result.first = ";"
+                result.sep = ";"
+                result.named = true
+                expression = expression[1:]
+        case '?':
+                result.first = "?"
+                result.sep = "&"
+                result.named = true
+                result.ifemp = "="
+                expression = expression[1:]
+        case '&':
+                result.first = "&"
+                result.sep = "&"
+                result.named = true
+                result.ifemp = "="
+                expression = expression[1:]
+        case '#':
+                result.first = "#"
+                result.sep = ","
+                result.allowReserved = true
+                expression = expression[1:]
+        default:
+                result.sep = ","
+        }
+        rawterms := strings.Split(expression, ",")
+        result.terms = make([]templateTerm, len(rawterms))
+        for i, raw := range rawterms {
+                result.terms[i], err = parseTerm(raw)
+                if err != nil {
+                        break
+                }
+        }
+        return result, err
+}
+
+func parseTerm(term string) (result templateTerm, err error) {
+        // TODO(djd): Remove "*" suffix parsing once we check that no APIs have
+        // mistakenly used that attribute.
+        if strings.HasSuffix(term, "*") {
+                result.explode = true
+                term = term[:len(term)-1]
+        }
+        split := strings.Split(term, ":")
+        if len(split) == 1 {
+                result.name = term
+        } else if len(split) == 2 {
+                result.name = split[0]
+                var parsed int64
+                parsed, err = strconv.ParseInt(split[1], 10, 0)
+                result.truncate = int(parsed)
+        } else {
+                err = errors.New("multiple colons in same term")
+        }
+        if !validname.MatchString(result.name) {
+                err = errors.New("not a valid name: " + result.name)
+        }
+        if result.explode && result.truncate > 0 {
+                err = errors.New("both explode and prefix modifers on same term")
+        }
+        return result, err
+}
+
+// Expand expands a URI template with a set of values to produce the
+// resultant URI. Two forms of the result are returned: one with all the
+// elements escaped, and one with the elements unescaped.
+func (t *uriTemplate) Expand(values map[string]string) (escaped, unescaped string) {
+        var w pairWriter
+        for _, p := range t.parts {
+                p.expand(&w, values)
+        }
+        return w.Escaped(), w.Unescaped()
+}
+
+func (tp *templatePart) expand(w *pairWriter, values map[string]string) {
+        if len(tp.raw) > 0 {
+                w.Write(tp.raw)
+                return
+        }
+        var first = true
+        for _, term := range tp.terms {
+                value, exists := values[term.name]
+                if !exists {
+                        continue
+                }
+                if first {
+                        w.Write(tp.first)
+                        first = false
+                } else {
+                        w.Write(tp.sep)
+                }
+                tp.expandString(w, term, value)
+        }
+}
+
+func (tp *templatePart) expandName(w *pairWriter, name string, empty bool) {
+        if tp.named {
+                w.Write(name)
+                if empty {
+                        w.Write(tp.ifemp)
+                } else {
+                        w.Write("=")
+                }
+        }
+}
+
+func (tp *templatePart) expandString(w *pairWriter, t templateTerm, s string) {
+        if len(s) > t.truncate && t.truncate > 0 {
+                s = s[:t.truncate]
+        }
+        tp.expandName(w, t.name, len(s) == 0)
+        w.Escape(s, tp.allowReserved)
+}
diff --git a/vendor/google.golang.org/api/googleapi/internal/uritemplates/utils.go b/vendor/google.golang.org/api/googleapi/internal/uritemplates/utils.go
new file mode 100644
index 0000000..2e70b81
--- /dev/null
+++ b/vendor/google.golang.org/api/googleapi/internal/uritemplates/utils.go
@@ -0,0 +1,17 @@
+// Copyright 2016 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 uritemplates
+
+// Expand parses then expands a URI template with a set of values to produce
+// the resultant URI. Two forms of the result are returned: one with all the
+// elements escaped, and one with the elements unescaped.
+func Expand(path string, values map[string]string) (escaped, unescaped string, err error) {
+        template, err := parse(path)
+        if err != nil {
+                return "", "", err
+        }
+        escaped, unescaped = template.Expand(values)
+        return escaped, unescaped, nil
+}
diff --git a/vendor/google.golang.org/api/googleapi/transport/apikey.go b/vendor/google.golang.org/api/googleapi/transport/apikey.go
new file mode 100644
index 0000000..eca1ea2
--- /dev/null
+++ b/vendor/google.golang.org/api/googleapi/transport/apikey.go
@@ -0,0 +1,38 @@
+// Copyright 2012 Google Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package transport contains HTTP transports used to make
+// authenticated API requests.
+package transport
+
+import (
+        "errors"
+        "net/http"
+)
+
+// APIKey is an HTTP Transport which wraps an underlying transport and
+// appends an API Key "key" parameter to the URL of outgoing requests.
+type APIKey struct {
+        // Key is the API Key to set on requests.
+        Key string
+
+        // Transport is the underlying HTTP transport.
+        // If nil, http.DefaultTransport is used.
+        Transport http.RoundTripper
+}
+
+func (t *APIKey) RoundTrip(req *http.Request) (*http.Response, error) {
+        rt := t.Transport
+        if rt == nil {
+                rt = http.DefaultTransport
+                if rt == nil {
+                        return nil, errors.New("googleapi/transport: no Transport specified or available")
+                }
+        }
+        newReq := *req
+        args := newReq.URL.Query()
+        args.Set("key", t.Key)
+        newReq.URL.RawQuery = args.Encode()
+        return rt.RoundTrip(&newReq)
+}
diff --git a/vendor/google.golang.org/api/googleapi/types.go b/vendor/google.golang.org/api/googleapi/types.go
new file mode 100644
index 0000000..a280e30
--- /dev/null
+++ b/vendor/google.golang.org/api/googleapi/types.go
@@ -0,0 +1,202 @@
+// Copyright 2013 Google Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package googleapi
+
+import (
+        "encoding/json"
+        "errors"
+        "strconv"
+)
+
+// Int64s is a slice of int64s that marshal as quoted strings in JSON.
+type Int64s []int64
+
+func (q *Int64s) UnmarshalJSON(raw []byte) error {
+        *q = (*q)[:0]
+        var ss []string
+        if err := json.Unmarshal(raw, &ss); err != nil {
+                return err
+        }
+        for _, s := range ss {
+                v, err := strconv.ParseInt(s, 10, 64)
+                if err != nil {
+                        return err
+                }
+                *q = append(*q, int64(v))
+        }
+        return nil
+}
+
+// Int32s is a slice of int32s that marshal as quoted strings in JSON.
+type Int32s []int32
+
+func (q *Int32s) UnmarshalJSON(raw []byte) error {
+        *q = (*q)[:0]
+        var ss []string
+        if err := json.Unmarshal(raw, &ss); err != nil {
+                return err
+        }
+        for _, s := range ss {
+                v, err := strconv.ParseInt(s, 10, 32)
+                if err != nil {
+                        return err
+                }
+                *q = append(*q, int32(v))
+        }
+        return nil
+}
+
+// Uint64s is a slice of uint64s that marshal as quoted strings in JSON.
+type Uint64s []uint64
+
+func (q *Uint64s) UnmarshalJSON(raw []byte) error {
+        *q = (*q)[:0]
+        var ss []string
+        if err := json.Unmarshal(raw, &ss); err != nil {
+                return err
+        }
+        for _, s := range ss {
+                v, err := strconv.ParseUint(s, 10, 64)
+                if err != nil {
+                        return err
+                }
+                *q = append(*q, uint64(v))
+        }
+        return nil
+}
+
+// Uint32s is a slice of uint32s that marshal as quoted strings in JSON.
+type Uint32s []uint32
+
+func (q *Uint32s) UnmarshalJSON(raw []byte) error {
+        *q = (*q)[:0]
+        var ss []string
+        if err := json.Unmarshal(raw, &ss); err != nil {
+                return err
+        }
+        for _, s := range ss {
+                v, err := strconv.ParseUint(s, 10, 32)
+                if err != nil {
+                        return err
+                }
+                *q = append(*q, uint32(v))
+        }
+        return nil
+}
+
+// Float64s is a slice of float64s that marshal as quoted strings in JSON.
+type Float64s []float64
+
+func (q *Float64s) UnmarshalJSON(raw []byte) error {
+        *q = (*q)[:0]
+        var ss []string
+        if err := json.Unmarshal(raw, &ss); err != nil {
+                return err
+        }
+        for _, s := range ss {
+                v, err := strconv.ParseFloat(s, 64)
+                if err != nil {
+                        return err
+                }
+                *q = append(*q, float64(v))
+        }
+        return nil
+}
+
+func quotedList(n int, fn func(dst []byte, i int) []byte) ([]byte, error) {
+        dst := make([]byte, 0, 2+n*10) // somewhat arbitrary
+        dst = append(dst, '[')
+        for i := 0; i < n; i++ {
+                if i > 0 {
+                        dst = append(dst, ',')
+                }
+                dst = append(dst, '"')
+                dst = fn(dst, i)
+                dst = append(dst, '"')
+        }
+        dst = append(dst, ']')
+        return dst, nil
+}
+
+func (q Int64s) MarshalJSON() ([]byte, error) {
+        return quotedList(len(q), func(dst []byte, i int) []byte {
+                return strconv.AppendInt(dst, q[i], 10)
+        })
+}
+
+func (q Int32s) MarshalJSON() ([]byte, error) {
+        return quotedList(len(q), func(dst []byte, i int) []byte {
+                return strconv.AppendInt(dst, int64(q[i]), 10)
+        })
+}
+
+func (q Uint64s) MarshalJSON() ([]byte, error) {
+        return quotedList(len(q), func(dst []byte, i int) []byte {
+                return strconv.AppendUint(dst, q[i], 10)
+        })
+}
+
+func (q Uint32s) MarshalJSON() ([]byte, error) {
+        return quotedList(len(q), func(dst []byte, i int) []byte {
+                return strconv.AppendUint(dst, uint64(q[i]), 10)
+        })
+}
+
+func (q Float64s) MarshalJSON() ([]byte, error) {
+        return quotedList(len(q), func(dst []byte, i int) []byte {
+                return strconv.AppendFloat(dst, q[i], 'g', -1, 64)
+        })
+}
+
+// RawMessage is a raw encoded JSON value.
+// It is identical to json.RawMessage, except it does not suffer from
+// https://golang.org/issue/14493.
+type RawMessage []byte
+
+// MarshalJSON returns m.
+func (m RawMessage) MarshalJSON() ([]byte, error) {
+        return m, nil
+}
+
+// UnmarshalJSON sets *m to a copy of data.
+func (m *RawMessage) UnmarshalJSON(data []byte) error {
+        if m == nil {
+                return errors.New("googleapi.RawMessage: UnmarshalJSON on nil pointer")
+        }
+        *m = append((*m)[:0], data...)
+        return nil
+}
+
+/*
+ * Helper routines for simplifying the creation of optional fields of basic type.
+ */
+
+// Bool is a helper routine that allocates a new bool value
+// to store v and returns a pointer to it.
+func Bool(v bool) *bool { return &v }
+
+// Int32 is a helper routine that allocates a new int32 value
+// to store v and returns a pointer to it.
+func Int32(v int32) *int32 { return &v }
+
+// Int64 is a helper routine that allocates a new int64 value
+// to store v and returns a pointer to it.
+func Int64(v int64) *int64 { return &v }
+
+// Float64 is a helper routine that allocates a new float64 value
+// to store v and returns a pointer to it.
+func Float64(v float64) *float64 { return &v }
+
+// Uint32 is a helper routine that allocates a new uint32 value
+// to store v and returns a pointer to it.
+func Uint32(v uint32) *uint32 { return &v }
+
+// Uint64 is a helper routine that allocates a new uint64 value
+// to store v and returns a pointer to it.
+func Uint64(v uint64) *uint64 { return &v }
+
+// String is a helper routine that allocates a new string value
+// to store v and returns a pointer to it.
+func String(v string) *string { return &v }
diff --git a/vendor/google.golang.org/api/internal/creds.go b/vendor/google.golang.org/api/internal/creds.go
new file mode 100644
index 0000000..e5b849b
--- /dev/null
+++ b/vendor/google.golang.org/api/internal/creds.go
@@ -0,0 +1,45 @@
+// Copyright 2017 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package internal
+
+import (
+        "context"
+        "fmt"
+        "io/ioutil"
+
+        "golang.org/x/oauth2/google"
+)
+
+// Creds returns credential information obtained from DialSettings, or if none, then
+// it returns default credential information.
+func Creds(ctx context.Context, ds *DialSettings) (*google.DefaultCredentials, error) {
+        if ds.Credentials != nil {
+                return ds.Credentials, nil
+        }
+        if ds.CredentialsJSON != nil {
+                return google.CredentialsFromJSON(ctx, ds.CredentialsJSON, ds.Scopes...)
+        }
+        if ds.CredentialsFile != "" {
+                data, err := ioutil.ReadFile(ds.CredentialsFile)
+                if err != nil {
+                        return nil, fmt.Errorf("cannot read credentials file: %v", err)
+                }
+                return google.CredentialsFromJSON(ctx, data, ds.Scopes...)
+        }
+        if ds.TokenSource != nil {
+                return &google.DefaultCredentials{TokenSource: ds.TokenSource}, nil
+        }
+        return google.FindDefaultCredentials(ctx, ds.Scopes...)
+}
diff --git a/vendor/google.golang.org/api/internal/pool.go b/vendor/google.golang.org/api/internal/pool.go
new file mode 100644
index 0000000..ba40624
--- /dev/null
+++ b/vendor/google.golang.org/api/internal/pool.go
@@ -0,0 +1,61 @@
+// Copyright 2016 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package internal
+
+import (
+        "errors"
+
+        "google.golang.org/grpc/naming"
+)
+
+// PoolResolver provides a fixed list of addresses to load balance between
+// and does not provide further updates.
+type PoolResolver struct {
+        poolSize int
+        dialOpt  *DialSettings
+        ch       chan []*naming.Update
+}
+
+// NewPoolResolver returns a PoolResolver
+// This is an EXPERIMENTAL API and may be changed or removed in the future.
+func NewPoolResolver(size int, o *DialSettings) *PoolResolver {
+        return &PoolResolver{poolSize: size, dialOpt: o}
+}
+
+// Resolve returns a Watcher for the endpoint defined by the DialSettings
+// provided to NewPoolResolver.
+func (r *PoolResolver) Resolve(target string) (naming.Watcher, error) {
+        if r.dialOpt.Endpoint == "" {
+                return nil, errors.New("No endpoint configured")
+        }
+        addrs := make([]*naming.Update, 0, r.poolSize)
+        for i := 0; i < r.poolSize; i++ {
+                addrs = append(addrs, &naming.Update{Op: naming.Add, Addr: r.dialOpt.Endpoint, Metadata: i})
+        }
+        r.ch = make(chan []*naming.Update, 1)
+        r.ch <- addrs
+        return r, nil
+}
+
+// Next returns a static list of updates on the first call,
+// and blocks indefinitely until Close is called on subsequent calls.
+func (r *PoolResolver) Next() ([]*naming.Update, error) {
+        return <-r.ch, nil
+}
+
+// Close releases resources associated with the pool and causes Next to unblock.
+func (r *PoolResolver) Close() {
+        close(r.ch)
+}
diff --git a/vendor/google.golang.org/api/internal/service-account.json b/vendor/google.golang.org/api/internal/service-account.json
new file mode 100644
index 0000000..2cb54c2
--- /dev/null
+++ b/vendor/google.golang.org/api/internal/service-account.json
@@ -0,0 +1,12 @@
+{
+  "type": "service_account",
+  "project_id": "project_id",
+  "private_key_id": "private_key_id",
+  "private_key": "private_key",
+  "client_email": "xyz@developer.gserviceaccount.com",
+  "client_id": "123",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://accounts.google.com/o/oauth2/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/xyz%40developer.gserviceaccount.com"
+}
diff --git a/vendor/google.golang.org/api/internal/settings.go b/vendor/google.golang.org/api/internal/settings.go
new file mode 100644
index 0000000..afabdc4
--- /dev/null
+++ b/vendor/google.golang.org/api/internal/settings.go
@@ -0,0 +1,81 @@
+// Copyright 2017 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package internal supports the options and transport packages.
+package internal
+
+import (
+        "errors"
+        "net/http"
+
+        "golang.org/x/oauth2"
+        "golang.org/x/oauth2/google"
+        "google.golang.org/grpc"
+)
+
+// DialSettings holds information needed to establish a connection with a
+// Google API service.
+type DialSettings struct {
+        Endpoint        string
+        Scopes          []string
+        TokenSource     oauth2.TokenSource
+        Credentials     *google.DefaultCredentials
+        CredentialsFile string // if set, Token Source is ignored.
+        CredentialsJSON []byte
+        UserAgent       string
+        APIKey          string
+        HTTPClient      *http.Client
+        GRPCDialOpts    []grpc.DialOption
+        GRPCConn        *grpc.ClientConn
+        NoAuth          bool
+}
+
+// Validate reports an error if ds is invalid.
+func (ds *DialSettings) Validate() error {
+        hasCreds := ds.APIKey != "" || ds.TokenSource != nil || ds.CredentialsFile != "" || ds.Credentials != nil
+        if ds.NoAuth && hasCreds {
+                return errors.New("options.WithoutAuthentication is incompatible with any option that provides credentials")
+        }
+        // Credentials should not appear with other options.
+        // We currently allow TokenSource and CredentialsFile to coexist.
+        // TODO(jba): make TokenSource & CredentialsFile an error (breaking change).
+        nCreds := 0
+        if ds.Credentials != nil {
+                nCreds++
+        }
+        if ds.CredentialsJSON != nil {
+                nCreds++
+        }
+        if ds.CredentialsFile != "" {
+                nCreds++
+        }
+        if ds.APIKey != "" {
+                nCreds++
+        }
+        if ds.TokenSource != nil {
+                nCreds++
+        }
+        // Accept only one form of credentials, except we allow TokenSource and CredentialsFile for backwards compatibility.
+        if nCreds > 1 && !(nCreds == 2 && ds.TokenSource != nil && ds.CredentialsFile != "") {
+                return errors.New("multiple credential options provided")
+        }
+        if ds.HTTPClient != nil && ds.GRPCConn != nil {
+                return errors.New("WithHTTPClient is incompatible with WithGRPCConn")
+        }
+        if ds.HTTPClient != nil && ds.GRPCDialOpts != nil {
+                return errors.New("WithHTTPClient is incompatible with gRPC dial options")
+        }
+
+        return nil
+}
diff --git a/vendor/google.golang.org/api/iterator/iterator.go b/vendor/google.golang.org/api/iterator/iterator.go
new file mode 100644
index 0000000..3c8ea77
--- /dev/null
+++ b/vendor/google.golang.org/api/iterator/iterator.go
@@ -0,0 +1,231 @@
+// Copyright 2016 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package iterator provides support for standard Google API iterators.
+// See https://github.com/GoogleCloudPlatform/gcloud-golang/wiki/Iterator-Guidelines.
+package iterator
+
+import (
+        "errors"
+        "fmt"
+        "reflect"
+)
+
+// Done is returned by an iterator's Next method when the iteration is
+// complete; when there are no more items to return.
+var Done = errors.New("no more items in iterator")
+
+// We don't support mixed calls to Next and NextPage because they play
+// with the paging state in incompatible ways.
+var errMixed = errors.New("iterator: Next and NextPage called on same iterator")
+
+// PageInfo contains information about an iterator's paging state.
+type PageInfo struct {
+        // Token is the token used to retrieve the next page of items from the
+        // API. You may set Token immediately after creating an iterator to
+        // begin iteration at a particular point. If Token is the empty string,
+        // the iterator will begin with the first eligible item.
+        //
+        // The result of setting Token after the first call to Next is undefined.
+        //
+        // After the underlying API method is called to retrieve a page of items,
+        // Token is set to the next-page token in the response.
+        Token string
+
+        // MaxSize is the maximum number of items returned by a call to the API.
+        // Set MaxSize as a hint to optimize the buffering behavior of the iterator.
+        // If zero, the page size is determined by the underlying service.
+        //
+        // Use Pager to retrieve a page of a specific, exact size.
+        MaxSize int
+
+        // The error state of the iterator. Manipulated by PageInfo.next and Pager.
+        // This is a latch: it starts as nil, and once set should never change.
+        err error
+
+        // If true, no more calls to fetch should be made. Set to true when fetch
+        // returns an empty page token. The iterator is Done when this is true AND
+        // the buffer is empty.
+        atEnd bool
+
+        // Function that fetches a page from the underlying service. It should pass
+        // the pageSize and pageToken arguments to the service, fill the buffer
+        // with the results from the call, and return the next-page token returned
+        // by the service. The function must not remove any existing items from the
+        // buffer. If the underlying RPC takes an int32 page size, pageSize should
+        // be silently truncated.
+        fetch func(pageSize int, pageToken string) (nextPageToken string, err error)
+
+        // Function that returns the number of currently buffered items.
+        bufLen func() int
+
+        // Function that returns the buffer, after setting the buffer variable to nil.
+        takeBuf func() interface{}
+
+        // Set to true on first call to PageInfo.next or Pager.NextPage. Used to check
+        // for calls to both Next and NextPage with the same iterator.
+        nextCalled, nextPageCalled bool
+}
+
+// NewPageInfo exposes internals for iterator implementations.
+// It is not a stable interface.
+var NewPageInfo = newPageInfo
+
+// If an iterator can support paging, its iterator-creating method should call
+// this (via the NewPageInfo variable above).
+//
+// The fetch, bufLen and takeBuf arguments provide access to the
+// iterator's internal slice of buffered items. They behave as described in
+// PageInfo, above.
+//
+// The return value is the PageInfo.next method bound to the returned PageInfo value.
+// (Returning it avoids exporting PageInfo.next.)
+func newPageInfo(fetch func(int, string) (string, error), bufLen func() int, takeBuf func() interface{}) (*PageInfo, func() error) {
+        pi := &PageInfo{
+                fetch:   fetch,
+                bufLen:  bufLen,
+                takeBuf: takeBuf,
+        }
+        return pi, pi.next
+}
+
+// Remaining returns the number of items available before the iterator makes another API call.
+func (pi *PageInfo) Remaining() int { return pi.bufLen() }
+
+// next provides support for an iterator's Next function. An iterator's Next
+// should return the error returned by next if non-nil; else it can assume
+// there is at least one item in its buffer, and it should return that item and
+// remove it from the buffer.
+func (pi *PageInfo) next() error {
+        pi.nextCalled = true
+        if pi.err != nil { // Once we get an error, always return it.
+                // TODO(jba): fix so users can retry on transient errors? Probably not worth it.
+                return pi.err
+        }
+        if pi.nextPageCalled {
+                pi.err = errMixed
+                return pi.err
+        }
+        // Loop until we get some items or reach the end.
+        for pi.bufLen() == 0 && !pi.atEnd {
+                if err := pi.fill(pi.MaxSize); err != nil {
+                        pi.err = err
+                        return pi.err
+                }
+                if pi.Token == "" {
+                        pi.atEnd = true
+                }
+        }
+        // Either the buffer is non-empty or pi.atEnd is true (or both).
+        if pi.bufLen() == 0 {
+                // The buffer is empty and pi.atEnd is true, i.e. the service has no
+                // more items.
+                pi.err = Done
+        }
+        return pi.err
+}
+
+// Call the service to fill the buffer, using size and pi.Token. Set pi.Token to the
+// next-page token returned by the call.
+// If fill returns a non-nil error, the buffer will be empty.
+func (pi *PageInfo) fill(size int) error {
+        tok, err := pi.fetch(size, pi.Token)
+        if err != nil {
+                pi.takeBuf() // clear the buffer
+                return err
+        }
+        pi.Token = tok
+        return nil
+}
+
+// Pageable is implemented by iterators that support paging.
+type Pageable interface {
+        // PageInfo returns paging information associated with the iterator.
+        PageInfo() *PageInfo
+}
+
+// Pager supports retrieving iterator items a page at a time.
+type Pager struct {
+        pageInfo *PageInfo
+        pageSize int
+}
+
+// NewPager returns a pager that uses iter. Calls to its NextPage method will
+// obtain exactly pageSize items, unless fewer remain. The pageToken argument
+// indicates where to start the iteration. Pass the empty string to start at
+// the beginning, or pass a token retrieved from a call to Pager.NextPage.
+//
+// If you use an iterator with a Pager, you must not call Next on the iterator.
+func NewPager(iter Pageable, pageSize int, pageToken string) *Pager {
+        p := &Pager{
+                pageInfo: iter.PageInfo(),
+                pageSize: pageSize,
+        }
+        p.pageInfo.Token = pageToken
+        if pageSize <= 0 {
+                p.pageInfo.err = errors.New("iterator: page size must be positive")
+        }
+        return p
+}
+
+// NextPage retrieves a sequence of items from the iterator and appends them
+// to slicep, which must be a pointer to a slice of the iterator's item type.
+// Exactly p.pageSize items will be appended, unless fewer remain.
+//
+// The first return value is the page token to use for the next page of items.
+// If empty, there are no more pages. Aside from checking for the end of the
+// iteration, the returned page token is only needed if the iteration is to be
+// resumed a later time, in another context (possibly another process).
+//
+// The second return value is non-nil if an error occurred. It will never be
+// the special iterator sentinel value Done. To recognize the end of the
+// iteration, compare nextPageToken to the empty string.
+//
+// It is possible for NextPage to return a single zero-length page along with
+// an empty page token when there are no more items in the iteration.
+func (p *Pager) NextPage(slicep interface{}) (nextPageToken string, err error) {
+        p.pageInfo.nextPageCalled = true
+        if p.pageInfo.err != nil {
+                return "", p.pageInfo.err
+        }
+        if p.pageInfo.nextCalled {
+                p.pageInfo.err = errMixed
+                return "", p.pageInfo.err
+        }
+        if p.pageInfo.bufLen() > 0 {
+                return "", errors.New("must call NextPage with an empty buffer")
+        }
+        // The buffer must be empty here, so takeBuf is a no-op. We call it just to get
+        // the buffer's type.
+        wantSliceType := reflect.PtrTo(reflect.ValueOf(p.pageInfo.takeBuf()).Type())
+        if slicep == nil {
+                return "", errors.New("nil passed to Pager.NextPage")
+        }
+        vslicep := reflect.ValueOf(slicep)
+        if vslicep.Type() != wantSliceType {
+                return "", fmt.Errorf("slicep should be of type %s, got %T", wantSliceType, slicep)
+        }
+        for p.pageInfo.bufLen() < p.pageSize {
+                if err := p.pageInfo.fill(p.pageSize - p.pageInfo.bufLen()); err != nil {
+                        p.pageInfo.err = err
+                        return "", p.pageInfo.err
+                }
+                if p.pageInfo.Token == "" {
+                        break
+                }
+        }
+        e := vslicep.Elem()
+        e.Set(reflect.AppendSlice(e, reflect.ValueOf(p.pageInfo.takeBuf())))
+        return p.pageInfo.Token, nil
+}
diff --git a/vendor/google.golang.org/api/option/credentials_go19.go b/vendor/google.golang.org/api/option/credentials_go19.go
new file mode 100644
index 0000000..0636a82
--- /dev/null
+++ b/vendor/google.golang.org/api/option/credentials_go19.go
@@ -0,0 +1,33 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build go1.9
+
+package option
+
+import (
+        "golang.org/x/oauth2/google"
+        "google.golang.org/api/internal"
+)
+
+type withCreds google.Credentials
+
+func (w *withCreds) Apply(o *internal.DialSettings) {
+        o.Credentials = (*google.Credentials)(w)
+}
+
+// WithCredentials returns a ClientOption that authenticates API calls.
+func WithCredentials(creds *google.Credentials) ClientOption {
+        return (*withCreds)(creds)
+}
diff --git a/vendor/google.golang.org/api/option/credentials_notgo19.go b/vendor/google.golang.org/api/option/credentials_notgo19.go
new file mode 100644
index 0000000..74d3a4b
--- /dev/null
+++ b/vendor/google.golang.org/api/option/credentials_notgo19.go
@@ -0,0 +1,32 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build !go1.9
+
+package option
+
+import (
+        "golang.org/x/oauth2/google"
+        "google.golang.org/api/internal"
+)
+
+type withCreds google.DefaultCredentials
+
+func (w *withCreds) Apply(o *internal.DialSettings) {
+        o.Credentials = (*google.DefaultCredentials)(w)
+}
+
+func WithCredentials(creds *google.DefaultCredentials) ClientOption {
+        return (*withCreds)(creds)
+}
diff --git a/vendor/google.golang.org/api/option/option.go b/vendor/google.golang.org/api/option/option.go
new file mode 100644
index 0000000..e7ecfe3
--- /dev/null
+++ b/vendor/google.golang.org/api/option/option.go
@@ -0,0 +1,191 @@
+// Copyright 2017 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package option contains options for Google API clients.
+package option
+
+import (
+        "net/http"
+
+        "golang.org/x/oauth2"
+        "google.golang.org/api/internal"
+        "google.golang.org/grpc"
+)
+
+// A ClientOption is an option for a Google API client.
+type ClientOption interface {
+        Apply(*internal.DialSettings)
+}
+
+// WithTokenSource returns a ClientOption that specifies an OAuth2 token
+// source to be used as the basis for authentication.
+func WithTokenSource(s oauth2.TokenSource) ClientOption {
+        return withTokenSource{s}
+}
+
+type withTokenSource struct{ ts oauth2.TokenSource }
+
+func (w withTokenSource) Apply(o *internal.DialSettings) {
+        o.TokenSource = w.ts
+}
+
+type withCredFile string
+
+func (w withCredFile) Apply(o *internal.DialSettings) {
+        o.CredentialsFile = string(w)
+}
+
+// WithCredentialsFile returns a ClientOption that authenticates
+// API calls with the given service account or refresh token JSON
+// credentials file.
+func WithCredentialsFile(filename string) ClientOption {
+        return withCredFile(filename)
+}
+
+// WithServiceAccountFile returns a ClientOption that uses a Google service
+// account credentials file to authenticate.
+//
+// Deprecated: Use WithCredentialsFile instead.
+func WithServiceAccountFile(filename string) ClientOption {
+        return WithCredentialsFile(filename)
+}
+
+// WithCredentialsJSON returns a ClientOption that authenticates
+// API calls with the given service account or refresh token JSON
+// credentials.
+func WithCredentialsJSON(p []byte) ClientOption {
+        return withCredentialsJSON(p)
+}
+
+type withCredentialsJSON []byte
+
+func (w withCredentialsJSON) Apply(o *internal.DialSettings) {
+        o.CredentialsJSON = make([]byte, len(w))
+        copy(o.CredentialsJSON, w)
+}
+
+// WithEndpoint returns a ClientOption that overrides the default endpoint
+// to be used for a service.
+func WithEndpoint(url string) ClientOption {
+        return withEndpoint(url)
+}
+
+type withEndpoint string
+
+func (w withEndpoint) Apply(o *internal.DialSettings) {
+        o.Endpoint = string(w)
+}
+
+// WithScopes returns a ClientOption that overrides the default OAuth2 scopes
+// to be used for a service.
+func WithScopes(scope ...string) ClientOption {
+        return withScopes(scope)
+}
+
+type withScopes []string
+
+func (w withScopes) Apply(o *internal.DialSettings) {
+        o.Scopes = make([]string, len(w))
+        copy(o.Scopes, w)
+}
+
+// WithUserAgent returns a ClientOption that sets the User-Agent.
+func WithUserAgent(ua string) ClientOption {
+        return withUA(ua)
+}
+
+type withUA string
+
+func (w withUA) Apply(o *internal.DialSettings) { o.UserAgent = string(w) }
+
+// WithHTTPClient returns a ClientOption that specifies the HTTP client to use
+// as the basis of communications. This option may only be used with services
+// that support HTTP as their communication transport. When used, the
+// WithHTTPClient option takes precedent over all other supplied options.
+func WithHTTPClient(client *http.Client) ClientOption {
+        return withHTTPClient{client}
+}
+
+type withHTTPClient struct{ client *http.Client }
+
+func (w withHTTPClient) Apply(o *internal.DialSettings) {
+        o.HTTPClient = w.client
+}
+
+// WithGRPCConn returns a ClientOption that specifies the gRPC client
+// connection to use as the basis of communications. This option many only be
+// used with services that support gRPC as their communication transport. When
+// used, the WithGRPCConn option takes precedent over all other supplied
+// options.
+func WithGRPCConn(conn *grpc.ClientConn) ClientOption {
+        return withGRPCConn{conn}
+}
+
+type withGRPCConn struct{ conn *grpc.ClientConn }
+
+func (w withGRPCConn) Apply(o *internal.DialSettings) {
+        o.GRPCConn = w.conn
+}
+
+// WithGRPCDialOption returns a ClientOption that appends a new grpc.DialOption
+// to an underlying gRPC dial. It does not work with WithGRPCConn.
+func WithGRPCDialOption(opt grpc.DialOption) ClientOption {
+        return withGRPCDialOption{opt}
+}
+
+type withGRPCDialOption struct{ opt grpc.DialOption }
+
+func (w withGRPCDialOption) Apply(o *internal.DialSettings) {
+        o.GRPCDialOpts = append(o.GRPCDialOpts, w.opt)
+}
+
+// WithGRPCConnectionPool returns a ClientOption that creates a pool of gRPC
+// connections that requests will be balanced between.
+// This is an EXPERIMENTAL API and may be changed or removed in the future.
+func WithGRPCConnectionPool(size int) ClientOption {
+        return withGRPCConnectionPool(size)
+}
+
+type withGRPCConnectionPool int
+
+func (w withGRPCConnectionPool) Apply(o *internal.DialSettings) {
+        balancer := grpc.RoundRobin(internal.NewPoolResolver(int(w), o))
+        o.GRPCDialOpts = append(o.GRPCDialOpts, grpc.WithBalancer(balancer))
+}
+
+// WithAPIKey returns a ClientOption that specifies an API key to be used
+// as the basis for authentication.
+//
+// API Keys can only be used for JSON-over-HTTP APIs, including those under
+// the import path google.golang.org/api/....
+func WithAPIKey(apiKey string) ClientOption {
+        return withAPIKey(apiKey)
+}
+
+type withAPIKey string
+
+func (w withAPIKey) Apply(o *internal.DialSettings) { o.APIKey = string(w) }
+
+// WithoutAuthentication returns a ClientOption that specifies that no
+// authentication should be used. It is suitable only for testing and for
+// accessing public resources, like public Google Cloud Storage buckets.
+// It is an error to provide both WithoutAuthentication and any of WithAPIKey,
+// WithTokenSource, WithCredentialsFile or WithServiceAccountFile.
+func WithoutAuthentication() ClientOption {
+        return withoutAuthentication{}
+}
+
+type withoutAuthentication struct{}
+
+func (w withoutAuthentication) Apply(o *internal.DialSettings) { o.NoAuth = true }
diff --git a/vendor/google.golang.org/api/storage/v1/storage-api.json b/vendor/google.golang.org/api/storage/v1/storage-api.json
new file mode 100644
index 0000000..49d0a51
--- /dev/null
+++ b/vendor/google.golang.org/api/storage/v1/storage-api.json
@@ -0,0 +1,3818 @@
+{
+  "auth": {
+    "oauth2": {
+      "scopes": {
+        "https://www.googleapis.com/auth/cloud-platform": {
+          "description": "View and manage your data across Google Cloud Platform services"
+        },
+        "https://www.googleapis.com/auth/cloud-platform.read-only": {
+          "description": "View your data across Google Cloud Platform services"
+        },
+        "https://www.googleapis.com/auth/devstorage.full_control": {
+          "description": "Manage your data and permissions in Google Cloud Storage"
+        },
+        "https://www.googleapis.com/auth/devstorage.read_only": {
+          "description": "View your data in Google Cloud Storage"
+        },
+        "https://www.googleapis.com/auth/devstorage.read_write": {
+          "description": "Manage your data in Google Cloud Storage"
+        }
+      }
+    }
+  },
+  "basePath": "/storage/v1/",
+  "baseUrl": "https://www.googleapis.com/storage/v1/",
+  "batchPath": "batch/storage/v1",
+  "description": "Stores and retrieves potentially large, immutable data objects.",
+  "discoveryVersion": "v1",
+  "documentationLink": "https://developers.google.com/storage/docs/json_api/",
+  "etag": "\"J3WqvAcMk4eQjJXvfSI4Yr8VouA/KPalWULMnQfaqumeaBhBrVfHFNM\"",
+  "icons": {
+    "x16": "https://www.google.com/images/icons/product/cloud_storage-16.png",
+    "x32": "https://www.google.com/images/icons/product/cloud_storage-32.png"
+  },
+  "id": "storage:v1",
+  "kind": "discovery#restDescription",
+  "labels": [
+    "labs"
+  ],
+  "name": "storage",
+  "ownerDomain": "google.com",
+  "ownerName": "Google",
+  "parameters": {
+    "alt": {
+      "default": "json",
+      "description": "Data format for the response.",
+      "enum": [
+        "json"
+      ],
+      "enumDescriptions": [
+        "Responses with Content-Type of application/json"
+      ],
+      "location": "query",
+      "type": "string"
+    },
+    "fields": {
+      "description": "Selector specifying which fields to include in a partial response.",
+      "location": "query",
+      "type": "string"
+    },
+    "key": {
+      "description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.",
+      "location": "query",
+      "type": "string"
+    },
+    "oauth_token": {
+      "description": "OAuth 2.0 token for the current user.",
+      "location": "query",
+      "type": "string"
+    },
+    "prettyPrint": {
+      "default": "true",
+      "description": "Returns response with indentations and line breaks.",
+      "location": "query",
+      "type": "boolean"
+    },
+    "quotaUser": {
+      "description": "An opaque string that represents a user for quota purposes. Must not exceed 40 characters.",
+      "location": "query",
+      "type": "string"
+    },
+    "userIp": {
+      "description": "Deprecated. Please use quotaUser instead.",
+      "location": "query",
+      "type": "string"
+    }
+  },
+  "protocol": "rest",
+  "resources": {
+    "bucketAccessControls": {
+      "methods": {
+        "delete": {
+          "description": "Permanently deletes the ACL entry for the specified entity on the specified bucket.",
+          "httpMethod": "DELETE",
+          "id": "storage.bucketAccessControls.delete",
+          "parameterOrder": [
+            "bucket",
+            "entity"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "entity": {
+              "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/acl/{entity}",
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        },
+        "get": {
+          "description": "Returns the ACL entry for the specified entity on the specified bucket.",
+          "httpMethod": "GET",
+          "id": "storage.bucketAccessControls.get",
+          "parameterOrder": [
+            "bucket",
+            "entity"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "entity": {
+              "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/acl/{entity}",
+          "response": {
+            "$ref": "BucketAccessControl"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        },
+        "insert": {
+          "description": "Creates a new ACL entry on the specified bucket.",
+          "httpMethod": "POST",
+          "id": "storage.bucketAccessControls.insert",
+          "parameterOrder": [
+            "bucket"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/acl",
+          "request": {
+            "$ref": "BucketAccessControl"
+          },
+          "response": {
+            "$ref": "BucketAccessControl"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        },
+        "list": {
+          "description": "Retrieves ACL entries on the specified bucket.",
+          "httpMethod": "GET",
+          "id": "storage.bucketAccessControls.list",
+          "parameterOrder": [
+            "bucket"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/acl",
+          "response": {
+            "$ref": "BucketAccessControls"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        },
+        "patch": {
+          "description": "Patches an ACL entry on the specified bucket.",
+          "httpMethod": "PATCH",
+          "id": "storage.bucketAccessControls.patch",
+          "parameterOrder": [
+            "bucket",
+            "entity"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "entity": {
+              "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/acl/{entity}",
+          "request": {
+            "$ref": "BucketAccessControl"
+          },
+          "response": {
+            "$ref": "BucketAccessControl"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        },
+        "update": {
+          "description": "Updates an ACL entry on the specified bucket.",
+          "httpMethod": "PUT",
+          "id": "storage.bucketAccessControls.update",
+          "parameterOrder": [
+            "bucket",
+            "entity"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "entity": {
+              "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/acl/{entity}",
+          "request": {
+            "$ref": "BucketAccessControl"
+          },
+          "response": {
+            "$ref": "BucketAccessControl"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        }
+      }
+    },
+    "buckets": {
+      "methods": {
+        "delete": {
+          "description": "Permanently deletes an empty bucket.",
+          "httpMethod": "DELETE",
+          "id": "storage.buckets.delete",
+          "parameterOrder": [
+            "bucket"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "ifMetagenerationMatch": {
+              "description": "If set, only deletes the bucket if its metageneration matches this value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationNotMatch": {
+              "description": "If set, only deletes the bucket if its metageneration does not match this value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}",
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        },
+        "get": {
+          "description": "Returns metadata for the specified bucket.",
+          "httpMethod": "GET",
+          "id": "storage.buckets.get",
+          "parameterOrder": [
+            "bucket"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "ifMetagenerationMatch": {
+              "description": "Makes the return of the bucket metadata conditional on whether the bucket's current metageneration matches the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationNotMatch": {
+              "description": "Makes the return of the bucket metadata conditional on whether the bucket's current metageneration does not match the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "projection": {
+              "description": "Set of properties to return. Defaults to noAcl.",
+              "enum": [
+                "full",
+                "noAcl"
+              ],
+              "enumDescriptions": [
+                "Include all properties.",
+                "Omit owner, acl and defaultObjectAcl properties."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}",
+          "response": {
+            "$ref": "Bucket"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_only",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        },
+        "getIamPolicy": {
+          "description": "Returns an IAM policy for the specified bucket.",
+          "httpMethod": "GET",
+          "id": "storage.buckets.getIamPolicy",
+          "parameterOrder": [
+            "bucket"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/iam",
+          "response": {
+            "$ref": "Policy"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_only",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        },
+        "insert": {
+          "description": "Creates a new bucket.",
+          "httpMethod": "POST",
+          "id": "storage.buckets.insert",
+          "parameterOrder": [
+            "project"
+          ],
+          "parameters": {
+            "predefinedAcl": {
+              "description": "Apply a predefined set of access controls to this bucket.",
+              "enum": [
+                "authenticatedRead",
+                "private",
+                "projectPrivate",
+                "publicRead",
+                "publicReadWrite"
+              ],
+              "enumDescriptions": [
+                "Project team owners get OWNER access, and allAuthenticatedUsers get READER access.",
+                "Project team owners get OWNER access.",
+                "Project team members get access according to their roles.",
+                "Project team owners get OWNER access, and allUsers get READER access.",
+                "Project team owners get OWNER access, and allUsers get WRITER access."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "predefinedDefaultObjectAcl": {
+              "description": "Apply a predefined set of default object access controls to this bucket.",
+              "enum": [
+                "authenticatedRead",
+                "bucketOwnerFullControl",
+                "bucketOwnerRead",
+                "private",
+                "projectPrivate",
+                "publicRead"
+              ],
+              "enumDescriptions": [
+                "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.",
+                "Object owner gets OWNER access, and project team owners get OWNER access.",
+                "Object owner gets OWNER access, and project team owners get READER access.",
+                "Object owner gets OWNER access.",
+                "Object owner gets OWNER access, and project team members get access according to their roles.",
+                "Object owner gets OWNER access, and allUsers get READER access."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "project": {
+              "description": "A valid API project identifier.",
+              "location": "query",
+              "required": true,
+              "type": "string"
+            },
+            "projection": {
+              "description": "Set of properties to return. Defaults to noAcl, unless the bucket resource specifies acl or defaultObjectAcl properties, when it defaults to full.",
+              "enum": [
+                "full",
+                "noAcl"
+              ],
+              "enumDescriptions": [
+                "Include all properties.",
+                "Omit owner, acl and defaultObjectAcl properties."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b",
+          "request": {
+            "$ref": "Bucket"
+          },
+          "response": {
+            "$ref": "Bucket"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        },
+        "list": {
+          "description": "Retrieves a list of buckets for a given project.",
+          "httpMethod": "GET",
+          "id": "storage.buckets.list",
+          "parameterOrder": [
+            "project"
+          ],
+          "parameters": {
+            "maxResults": {
+              "default": "1000",
+              "description": "Maximum number of buckets to return in a single response. The service will use this parameter or 1,000 items, whichever is smaller.",
+              "format": "uint32",
+              "location": "query",
+              "minimum": "0",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "A previously-returned page token representing part of the larger set of results to view.",
+              "location": "query",
+              "type": "string"
+            },
+            "prefix": {
+              "description": "Filter results to buckets whose names begin with this prefix.",
+              "location": "query",
+              "type": "string"
+            },
+            "project": {
+              "description": "A valid API project identifier.",
+              "location": "query",
+              "required": true,
+              "type": "string"
+            },
+            "projection": {
+              "description": "Set of properties to return. Defaults to noAcl.",
+              "enum": [
+                "full",
+                "noAcl"
+              ],
+              "enumDescriptions": [
+                "Include all properties.",
+                "Omit owner, acl and defaultObjectAcl properties."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b",
+          "response": {
+            "$ref": "Buckets"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_only",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        },
+        "lockRetentionPolicy": {
+          "description": "Locks retention policy on a bucket.",
+          "httpMethod": "POST",
+          "id": "storage.buckets.lockRetentionPolicy",
+          "parameterOrder": [
+            "bucket",
+            "ifMetagenerationMatch"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "ifMetagenerationMatch": {
+              "description": "Makes the operation conditional on whether bucket's current metageneration matches the given value.",
+              "format": "int64",
+              "location": "query",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/lockRetentionPolicy",
+          "response": {
+            "$ref": "Bucket"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        },
+        "patch": {
+          "description": "Patches a bucket. Changes to the bucket will be readable immediately after writing, but configuration changes may take time to propagate.",
+          "httpMethod": "PATCH",
+          "id": "storage.buckets.patch",
+          "parameterOrder": [
+            "bucket"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "ifMetagenerationMatch": {
+              "description": "Makes the return of the bucket metadata conditional on whether the bucket's current metageneration matches the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationNotMatch": {
+              "description": "Makes the return of the bucket metadata conditional on whether the bucket's current metageneration does not match the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "predefinedAcl": {
+              "description": "Apply a predefined set of access controls to this bucket.",
+              "enum": [
+                "authenticatedRead",
+                "private",
+                "projectPrivate",
+                "publicRead",
+                "publicReadWrite"
+              ],
+              "enumDescriptions": [
+                "Project team owners get OWNER access, and allAuthenticatedUsers get READER access.",
+                "Project team owners get OWNER access.",
+                "Project team members get access according to their roles.",
+                "Project team owners get OWNER access, and allUsers get READER access.",
+                "Project team owners get OWNER access, and allUsers get WRITER access."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "predefinedDefaultObjectAcl": {
+              "description": "Apply a predefined set of default object access controls to this bucket.",
+              "enum": [
+                "authenticatedRead",
+                "bucketOwnerFullControl",
+                "bucketOwnerRead",
+                "private",
+                "projectPrivate",
+                "publicRead"
+              ],
+              "enumDescriptions": [
+                "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.",
+                "Object owner gets OWNER access, and project team owners get OWNER access.",
+                "Object owner gets OWNER access, and project team owners get READER access.",
+                "Object owner gets OWNER access.",
+                "Object owner gets OWNER access, and project team members get access according to their roles.",
+                "Object owner gets OWNER access, and allUsers get READER access."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "projection": {
+              "description": "Set of properties to return. Defaults to full.",
+              "enum": [
+                "full",
+                "noAcl"
+              ],
+              "enumDescriptions": [
+                "Include all properties.",
+                "Omit owner, acl and defaultObjectAcl properties."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}",
+          "request": {
+            "$ref": "Bucket"
+          },
+          "response": {
+            "$ref": "Bucket"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        },
+        "setIamPolicy": {
+          "description": "Updates an IAM policy for the specified bucket.",
+          "httpMethod": "PUT",
+          "id": "storage.buckets.setIamPolicy",
+          "parameterOrder": [
+            "bucket"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/iam",
+          "request": {
+            "$ref": "Policy"
+          },
+          "response": {
+            "$ref": "Policy"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        },
+        "testIamPermissions": {
+          "description": "Tests a set of permissions on the given bucket to see which, if any, are held by the caller.",
+          "httpMethod": "GET",
+          "id": "storage.buckets.testIamPermissions",
+          "parameterOrder": [
+            "bucket",
+            "permissions"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "permissions": {
+              "description": "Permissions to test.",
+              "location": "query",
+              "repeated": true,
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/iam/testPermissions",
+          "response": {
+            "$ref": "TestIamPermissionsResponse"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_only",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        },
+        "update": {
+          "description": "Updates a bucket. Changes to the bucket will be readable immediately after writing, but configuration changes may take time to propagate.",
+          "httpMethod": "PUT",
+          "id": "storage.buckets.update",
+          "parameterOrder": [
+            "bucket"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "ifMetagenerationMatch": {
+              "description": "Makes the return of the bucket metadata conditional on whether the bucket's current metageneration matches the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationNotMatch": {
+              "description": "Makes the return of the bucket metadata conditional on whether the bucket's current metageneration does not match the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "predefinedAcl": {
+              "description": "Apply a predefined set of access controls to this bucket.",
+              "enum": [
+                "authenticatedRead",
+                "private",
+                "projectPrivate",
+                "publicRead",
+                "publicReadWrite"
+              ],
+              "enumDescriptions": [
+                "Project team owners get OWNER access, and allAuthenticatedUsers get READER access.",
+                "Project team owners get OWNER access.",
+                "Project team members get access according to their roles.",
+                "Project team owners get OWNER access, and allUsers get READER access.",
+                "Project team owners get OWNER access, and allUsers get WRITER access."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "predefinedDefaultObjectAcl": {
+              "description": "Apply a predefined set of default object access controls to this bucket.",
+              "enum": [
+                "authenticatedRead",
+                "bucketOwnerFullControl",
+                "bucketOwnerRead",
+                "private",
+                "projectPrivate",
+                "publicRead"
+              ],
+              "enumDescriptions": [
+                "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.",
+                "Object owner gets OWNER access, and project team owners get OWNER access.",
+                "Object owner gets OWNER access, and project team owners get READER access.",
+                "Object owner gets OWNER access.",
+                "Object owner gets OWNER access, and project team members get access according to their roles.",
+                "Object owner gets OWNER access, and allUsers get READER access."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "projection": {
+              "description": "Set of properties to return. Defaults to full.",
+              "enum": [
+                "full",
+                "noAcl"
+              ],
+              "enumDescriptions": [
+                "Include all properties.",
+                "Omit owner, acl and defaultObjectAcl properties."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}",
+          "request": {
+            "$ref": "Bucket"
+          },
+          "response": {
+            "$ref": "Bucket"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        }
+      }
+    },
+    "channels": {
+      "methods": {
+        "stop": {
+          "description": "Stop watching resources through this channel",
+          "httpMethod": "POST",
+          "id": "storage.channels.stop",
+          "path": "channels/stop",
+          "request": {
+            "$ref": "Channel",
+            "parameterName": "resource"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_only",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        }
+      }
+    },
+    "defaultObjectAccessControls": {
+      "methods": {
+        "delete": {
+          "description": "Permanently deletes the default object ACL entry for the specified entity on the specified bucket.",
+          "httpMethod": "DELETE",
+          "id": "storage.defaultObjectAccessControls.delete",
+          "parameterOrder": [
+            "bucket",
+            "entity"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "entity": {
+              "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/defaultObjectAcl/{entity}",
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        },
+        "get": {
+          "description": "Returns the default object ACL entry for the specified entity on the specified bucket.",
+          "httpMethod": "GET",
+          "id": "storage.defaultObjectAccessControls.get",
+          "parameterOrder": [
+            "bucket",
+            "entity"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "entity": {
+              "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/defaultObjectAcl/{entity}",
+          "response": {
+            "$ref": "ObjectAccessControl"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        },
+        "insert": {
+          "description": "Creates a new default object ACL entry on the specified bucket.",
+          "httpMethod": "POST",
+          "id": "storage.defaultObjectAccessControls.insert",
+          "parameterOrder": [
+            "bucket"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/defaultObjectAcl",
+          "request": {
+            "$ref": "ObjectAccessControl"
+          },
+          "response": {
+            "$ref": "ObjectAccessControl"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        },
+        "list": {
+          "description": "Retrieves default object ACL entries on the specified bucket.",
+          "httpMethod": "GET",
+          "id": "storage.defaultObjectAccessControls.list",
+          "parameterOrder": [
+            "bucket"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "ifMetagenerationMatch": {
+              "description": "If present, only return default ACL listing if the bucket's current metageneration matches this value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationNotMatch": {
+              "description": "If present, only return default ACL listing if the bucket's current metageneration does not match the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/defaultObjectAcl",
+          "response": {
+            "$ref": "ObjectAccessControls"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        },
+        "patch": {
+          "description": "Patches a default object ACL entry on the specified bucket.",
+          "httpMethod": "PATCH",
+          "id": "storage.defaultObjectAccessControls.patch",
+          "parameterOrder": [
+            "bucket",
+            "entity"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "entity": {
+              "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/defaultObjectAcl/{entity}",
+          "request": {
+            "$ref": "ObjectAccessControl"
+          },
+          "response": {
+            "$ref": "ObjectAccessControl"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        },
+        "update": {
+          "description": "Updates a default object ACL entry on the specified bucket.",
+          "httpMethod": "PUT",
+          "id": "storage.defaultObjectAccessControls.update",
+          "parameterOrder": [
+            "bucket",
+            "entity"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "entity": {
+              "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/defaultObjectAcl/{entity}",
+          "request": {
+            "$ref": "ObjectAccessControl"
+          },
+          "response": {
+            "$ref": "ObjectAccessControl"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        }
+      }
+    },
+    "notifications": {
+      "methods": {
+        "delete": {
+          "description": "Permanently deletes a notification subscription.",
+          "httpMethod": "DELETE",
+          "id": "storage.notifications.delete",
+          "parameterOrder": [
+            "bucket",
+            "notification"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "The parent bucket of the notification.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "notification": {
+              "description": "ID of the notification to delete.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/notificationConfigs/{notification}",
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        },
+        "get": {
+          "description": "View a notification configuration.",
+          "httpMethod": "GET",
+          "id": "storage.notifications.get",
+          "parameterOrder": [
+            "bucket",
+            "notification"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "The parent bucket of the notification.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "notification": {
+              "description": "Notification ID",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/notificationConfigs/{notification}",
+          "response": {
+            "$ref": "Notification"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_only",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        },
+        "insert": {
+          "description": "Creates a notification subscription for a given bucket.",
+          "httpMethod": "POST",
+          "id": "storage.notifications.insert",
+          "parameterOrder": [
+            "bucket"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "The parent bucket of the notification.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/notificationConfigs",
+          "request": {
+            "$ref": "Notification"
+          },
+          "response": {
+            "$ref": "Notification"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        },
+        "list": {
+          "description": "Retrieves a list of notification subscriptions for a given bucket.",
+          "httpMethod": "GET",
+          "id": "storage.notifications.list",
+          "parameterOrder": [
+            "bucket"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a Google Cloud Storage bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/notificationConfigs",
+          "response": {
+            "$ref": "Notifications"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_only",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        }
+      }
+    },
+    "objectAccessControls": {
+      "methods": {
+        "delete": {
+          "description": "Permanently deletes the ACL entry for the specified entity on the specified object.",
+          "httpMethod": "DELETE",
+          "id": "storage.objectAccessControls.delete",
+          "parameterOrder": [
+            "bucket",
+            "object",
+            "entity"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "entity": {
+              "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "generation": {
+              "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "object": {
+              "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/o/{object}/acl/{entity}",
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        },
+        "get": {
+          "description": "Returns the ACL entry for the specified entity on the specified object.",
+          "httpMethod": "GET",
+          "id": "storage.objectAccessControls.get",
+          "parameterOrder": [
+            "bucket",
+            "object",
+            "entity"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "entity": {
+              "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "generation": {
+              "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "object": {
+              "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/o/{object}/acl/{entity}",
+          "response": {
+            "$ref": "ObjectAccessControl"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        },
+        "insert": {
+          "description": "Creates a new ACL entry on the specified object.",
+          "httpMethod": "POST",
+          "id": "storage.objectAccessControls.insert",
+          "parameterOrder": [
+            "bucket",
+            "object"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "generation": {
+              "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "object": {
+              "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/o/{object}/acl",
+          "request": {
+            "$ref": "ObjectAccessControl"
+          },
+          "response": {
+            "$ref": "ObjectAccessControl"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        },
+        "list": {
+          "description": "Retrieves ACL entries on the specified object.",
+          "httpMethod": "GET",
+          "id": "storage.objectAccessControls.list",
+          "parameterOrder": [
+            "bucket",
+            "object"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "generation": {
+              "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "object": {
+              "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/o/{object}/acl",
+          "response": {
+            "$ref": "ObjectAccessControls"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        },
+        "patch": {
+          "description": "Patches an ACL entry on the specified object.",
+          "httpMethod": "PATCH",
+          "id": "storage.objectAccessControls.patch",
+          "parameterOrder": [
+            "bucket",
+            "object",
+            "entity"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "entity": {
+              "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "generation": {
+              "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "object": {
+              "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/o/{object}/acl/{entity}",
+          "request": {
+            "$ref": "ObjectAccessControl"
+          },
+          "response": {
+            "$ref": "ObjectAccessControl"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        },
+        "update": {
+          "description": "Updates an ACL entry on the specified object.",
+          "httpMethod": "PUT",
+          "id": "storage.objectAccessControls.update",
+          "parameterOrder": [
+            "bucket",
+            "object",
+            "entity"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of a bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "entity": {
+              "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "generation": {
+              "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "object": {
+              "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/o/{object}/acl/{entity}",
+          "request": {
+            "$ref": "ObjectAccessControl"
+          },
+          "response": {
+            "$ref": "ObjectAccessControl"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        }
+      }
+    },
+    "objects": {
+      "methods": {
+        "compose": {
+          "description": "Concatenates a list of existing objects into a new object in the same bucket.",
+          "httpMethod": "POST",
+          "id": "storage.objects.compose",
+          "parameterOrder": [
+            "destinationBucket",
+            "destinationObject"
+          ],
+          "parameters": {
+            "destinationBucket": {
+              "description": "Name of the bucket containing the source objects. The destination object is stored in this bucket.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "destinationObject": {
+              "description": "Name of the new object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "destinationPredefinedAcl": {
+              "description": "Apply a predefined set of access controls to the destination object.",
+              "enum": [
+                "authenticatedRead",
+                "bucketOwnerFullControl",
+                "bucketOwnerRead",
+                "private",
+                "projectPrivate",
+                "publicRead"
+              ],
+              "enumDescriptions": [
+                "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.",
+                "Object owner gets OWNER access, and project team owners get OWNER access.",
+                "Object owner gets OWNER access, and project team owners get READER access.",
+                "Object owner gets OWNER access.",
+                "Object owner gets OWNER access, and project team members get access according to their roles.",
+                "Object owner gets OWNER access, and allUsers get READER access."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "ifGenerationMatch": {
+              "description": "Makes the operation conditional on whether the object's current generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationMatch": {
+              "description": "Makes the operation conditional on whether the object's current metageneration matches the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "kmsKeyName": {
+              "description": "Resource name of the Cloud KMS key, of the form projects/my-project/locations/global/keyRings/my-kr/cryptoKeys/my-key, that will be used to encrypt the object. Overrides the object metadata's kms_key_name value, if any.",
+              "location": "query",
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{destinationBucket}/o/{destinationObject}/compose",
+          "request": {
+            "$ref": "ComposeRequest"
+          },
+          "response": {
+            "$ref": "Object"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        },
+        "copy": {
+          "description": "Copies a source object to a destination object. Optionally overrides metadata.",
+          "httpMethod": "POST",
+          "id": "storage.objects.copy",
+          "parameterOrder": [
+            "sourceBucket",
+            "sourceObject",
+            "destinationBucket",
+            "destinationObject"
+          ],
+          "parameters": {
+            "destinationBucket": {
+              "description": "Name of the bucket in which to store the new object. Overrides the provided object metadata's bucket value, if any.For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "destinationObject": {
+              "description": "Name of the new object. Required when the object metadata is not otherwise provided. Overrides the object metadata's name value, if any.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "destinationPredefinedAcl": {
+              "description": "Apply a predefined set of access controls to the destination object.",
+              "enum": [
+                "authenticatedRead",
+                "bucketOwnerFullControl",
+                "bucketOwnerRead",
+                "private",
+                "projectPrivate",
+                "publicRead"
+              ],
+              "enumDescriptions": [
+                "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.",
+                "Object owner gets OWNER access, and project team owners get OWNER access.",
+                "Object owner gets OWNER access, and project team owners get READER access.",
+                "Object owner gets OWNER access.",
+                "Object owner gets OWNER access, and project team members get access according to their roles.",
+                "Object owner gets OWNER access, and allUsers get READER access."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "ifGenerationMatch": {
+              "description": "Makes the operation conditional on whether the destination object's current generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifGenerationNotMatch": {
+              "description": "Makes the operation conditional on whether the destination object's current generation does not match the given value. If no live object exists, the precondition fails. Setting to 0 makes the operation succeed only if there is a live version of the object.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationMatch": {
+              "description": "Makes the operation conditional on whether the destination object's current metageneration matches the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationNotMatch": {
+              "description": "Makes the operation conditional on whether the destination object's current metageneration does not match the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifSourceGenerationMatch": {
+              "description": "Makes the operation conditional on whether the source object's current generation matches the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifSourceGenerationNotMatch": {
+              "description": "Makes the operation conditional on whether the source object's current generation does not match the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifSourceMetagenerationMatch": {
+              "description": "Makes the operation conditional on whether the source object's current metageneration matches the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifSourceMetagenerationNotMatch": {
+              "description": "Makes the operation conditional on whether the source object's current metageneration does not match the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "projection": {
+              "description": "Set of properties to return. Defaults to noAcl, unless the object resource specifies the acl property, when it defaults to full.",
+              "enum": [
+                "full",
+                "noAcl"
+              ],
+              "enumDescriptions": [
+                "Include all properties.",
+                "Omit the owner, acl property."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "sourceBucket": {
+              "description": "Name of the bucket in which to find the source object.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "sourceGeneration": {
+              "description": "If present, selects a specific revision of the source object (as opposed to the latest version, the default).",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "sourceObject": {
+              "description": "Name of the source object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{sourceBucket}/o/{sourceObject}/copyTo/b/{destinationBucket}/o/{destinationObject}",
+          "request": {
+            "$ref": "Object"
+          },
+          "response": {
+            "$ref": "Object"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        },
+        "delete": {
+          "description": "Deletes an object and its metadata. Deletions are permanent if versioning is not enabled for the bucket, or if the generation parameter is used.",
+          "httpMethod": "DELETE",
+          "id": "storage.objects.delete",
+          "parameterOrder": [
+            "bucket",
+            "object"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of the bucket in which the object resides.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "generation": {
+              "description": "If present, permanently deletes a specific revision of this object (as opposed to the latest version, the default).",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifGenerationMatch": {
+              "description": "Makes the operation conditional on whether the object's current generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifGenerationNotMatch": {
+              "description": "Makes the operation conditional on whether the object's current generation does not match the given value. If no live object exists, the precondition fails. Setting to 0 makes the operation succeed only if there is a live version of the object.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationMatch": {
+              "description": "Makes the operation conditional on whether the object's current metageneration matches the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationNotMatch": {
+              "description": "Makes the operation conditional on whether the object's current metageneration does not match the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "object": {
+              "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/o/{object}",
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        },
+        "get": {
+          "description": "Retrieves an object or its metadata.",
+          "httpMethod": "GET",
+          "id": "storage.objects.get",
+          "parameterOrder": [
+            "bucket",
+            "object"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of the bucket in which the object resides.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "generation": {
+              "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifGenerationMatch": {
+              "description": "Makes the operation conditional on whether the object's current generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifGenerationNotMatch": {
+              "description": "Makes the operation conditional on whether the object's current generation does not match the given value. If no live object exists, the precondition fails. Setting to 0 makes the operation succeed only if there is a live version of the object.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationMatch": {
+              "description": "Makes the operation conditional on whether the object's current metageneration matches the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationNotMatch": {
+              "description": "Makes the operation conditional on whether the object's current metageneration does not match the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "object": {
+              "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "projection": {
+              "description": "Set of properties to return. Defaults to noAcl.",
+              "enum": [
+                "full",
+                "noAcl"
+              ],
+              "enumDescriptions": [
+                "Include all properties.",
+                "Omit the owner, acl property."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/o/{object}",
+          "response": {
+            "$ref": "Object"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_only",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ],
+          "supportsMediaDownload": true,
+          "useMediaDownloadService": true
+        },
+        "getIamPolicy": {
+          "description": "Returns an IAM policy for the specified object.",
+          "httpMethod": "GET",
+          "id": "storage.objects.getIamPolicy",
+          "parameterOrder": [
+            "bucket",
+            "object"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of the bucket in which the object resides.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "generation": {
+              "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "object": {
+              "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/o/{object}/iam",
+          "response": {
+            "$ref": "Policy"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_only",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        },
+        "insert": {
+          "description": "Stores a new object and metadata.",
+          "httpMethod": "POST",
+          "id": "storage.objects.insert",
+          "mediaUpload": {
+            "accept": [
+              "*/*"
+            ],
+            "protocols": {
+              "resumable": {
+                "multipart": true,
+                "path": "/resumable/upload/storage/v1/b/{bucket}/o"
+              },
+              "simple": {
+                "multipart": true,
+                "path": "/upload/storage/v1/b/{bucket}/o"
+              }
+            }
+          },
+          "parameterOrder": [
+            "bucket"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of the bucket in which to store the new object. Overrides the provided object metadata's bucket value, if any.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "contentEncoding": {
+              "description": "If set, sets the contentEncoding property of the final object to this value. Setting this parameter is equivalent to setting the contentEncoding metadata property. This can be useful when uploading an object with uploadType=media to indicate the encoding of the content being uploaded.",
+              "location": "query",
+              "type": "string"
+            },
+            "ifGenerationMatch": {
+              "description": "Makes the operation conditional on whether the object's current generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifGenerationNotMatch": {
+              "description": "Makes the operation conditional on whether the object's current generation does not match the given value. If no live object exists, the precondition fails. Setting to 0 makes the operation succeed only if there is a live version of the object.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationMatch": {
+              "description": "Makes the operation conditional on whether the object's current metageneration matches the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationNotMatch": {
+              "description": "Makes the operation conditional on whether the object's current metageneration does not match the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "kmsKeyName": {
+              "description": "Resource name of the Cloud KMS key, of the form projects/my-project/locations/global/keyRings/my-kr/cryptoKeys/my-key, that will be used to encrypt the object. Overrides the object metadata's kms_key_name value, if any.",
+              "location": "query",
+              "type": "string"
+            },
+            "name": {
+              "description": "Name of the object. Required when the object metadata is not otherwise provided. Overrides the object metadata's name value, if any. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "query",
+              "type": "string"
+            },
+            "predefinedAcl": {
+              "description": "Apply a predefined set of access controls to this object.",
+              "enum": [
+                "authenticatedRead",
+                "bucketOwnerFullControl",
+                "bucketOwnerRead",
+                "private",
+                "projectPrivate",
+                "publicRead"
+              ],
+              "enumDescriptions": [
+                "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.",
+                "Object owner gets OWNER access, and project team owners get OWNER access.",
+                "Object owner gets OWNER access, and project team owners get READER access.",
+                "Object owner gets OWNER access.",
+                "Object owner gets OWNER access, and project team members get access according to their roles.",
+                "Object owner gets OWNER access, and allUsers get READER access."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "projection": {
+              "description": "Set of properties to return. Defaults to noAcl, unless the object resource specifies the acl property, when it defaults to full.",
+              "enum": [
+                "full",
+                "noAcl"
+              ],
+              "enumDescriptions": [
+                "Include all properties.",
+                "Omit the owner, acl property."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/o",
+          "request": {
+            "$ref": "Object"
+          },
+          "response": {
+            "$ref": "Object"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ],
+          "supportsMediaUpload": true
+        },
+        "list": {
+          "description": "Retrieves a list of objects matching the criteria.",
+          "httpMethod": "GET",
+          "id": "storage.objects.list",
+          "parameterOrder": [
+            "bucket"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of the bucket in which to look for objects.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "delimiter": {
+              "description": "Returns results in a directory-like mode. items will contain only objects whose names, aside from the prefix, do not contain delimiter. Objects whose names, aside from the prefix, contain delimiter will have their name, truncated after the delimiter, returned in prefixes. Duplicate prefixes are omitted.",
+              "location": "query",
+              "type": "string"
+            },
+            "includeTrailingDelimiter": {
+              "description": "If true, objects that end in exactly one instance of delimiter will have their metadata included in items in addition to prefixes.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "maxResults": {
+              "default": "1000",
+              "description": "Maximum number of items plus prefixes to return in a single page of responses. As duplicate prefixes are omitted, fewer total results may be returned than requested. The service will use this parameter or 1,000 items, whichever is smaller.",
+              "format": "uint32",
+              "location": "query",
+              "minimum": "0",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "A previously-returned page token representing part of the larger set of results to view.",
+              "location": "query",
+              "type": "string"
+            },
+            "prefix": {
+              "description": "Filter results to objects whose names begin with this prefix.",
+              "location": "query",
+              "type": "string"
+            },
+            "projection": {
+              "description": "Set of properties to return. Defaults to noAcl.",
+              "enum": [
+                "full",
+                "noAcl"
+              ],
+              "enumDescriptions": [
+                "Include all properties.",
+                "Omit the owner, acl property."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            },
+            "versions": {
+              "description": "If true, lists all versions of an object as distinct results. The default is false. For more information, see Object Versioning.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "b/{bucket}/o",
+          "response": {
+            "$ref": "Objects"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_only",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ],
+          "supportsSubscription": true
+        },
+        "patch": {
+          "description": "Patches an object's metadata.",
+          "httpMethod": "PATCH",
+          "id": "storage.objects.patch",
+          "parameterOrder": [
+            "bucket",
+            "object"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of the bucket in which the object resides.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "generation": {
+              "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifGenerationMatch": {
+              "description": "Makes the operation conditional on whether the object's current generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifGenerationNotMatch": {
+              "description": "Makes the operation conditional on whether the object's current generation does not match the given value. If no live object exists, the precondition fails. Setting to 0 makes the operation succeed only if there is a live version of the object.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationMatch": {
+              "description": "Makes the operation conditional on whether the object's current metageneration matches the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationNotMatch": {
+              "description": "Makes the operation conditional on whether the object's current metageneration does not match the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "object": {
+              "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "predefinedAcl": {
+              "description": "Apply a predefined set of access controls to this object.",
+              "enum": [
+                "authenticatedRead",
+                "bucketOwnerFullControl",
+                "bucketOwnerRead",
+                "private",
+                "projectPrivate",
+                "publicRead"
+              ],
+              "enumDescriptions": [
+                "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.",
+                "Object owner gets OWNER access, and project team owners get OWNER access.",
+                "Object owner gets OWNER access, and project team owners get READER access.",
+                "Object owner gets OWNER access.",
+                "Object owner gets OWNER access, and project team members get access according to their roles.",
+                "Object owner gets OWNER access, and allUsers get READER access."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "projection": {
+              "description": "Set of properties to return. Defaults to full.",
+              "enum": [
+                "full",
+                "noAcl"
+              ],
+              "enumDescriptions": [
+                "Include all properties.",
+                "Omit the owner, acl property."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request, for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/o/{object}",
+          "request": {
+            "$ref": "Object"
+          },
+          "response": {
+            "$ref": "Object"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        },
+        "rewrite": {
+          "description": "Rewrites a source object to a destination object. Optionally overrides metadata.",
+          "httpMethod": "POST",
+          "id": "storage.objects.rewrite",
+          "parameterOrder": [
+            "sourceBucket",
+            "sourceObject",
+            "destinationBucket",
+            "destinationObject"
+          ],
+          "parameters": {
+            "destinationBucket": {
+              "description": "Name of the bucket in which to store the new object. Overrides the provided object metadata's bucket value, if any.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "destinationKmsKeyName": {
+              "description": "Resource name of the Cloud KMS key, of the form projects/my-project/locations/global/keyRings/my-kr/cryptoKeys/my-key, that will be used to encrypt the object. Overrides the object metadata's kms_key_name value, if any.",
+              "location": "query",
+              "type": "string"
+            },
+            "destinationObject": {
+              "description": "Name of the new object. Required when the object metadata is not otherwise provided. Overrides the object metadata's name value, if any. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "destinationPredefinedAcl": {
+              "description": "Apply a predefined set of access controls to the destination object.",
+              "enum": [
+                "authenticatedRead",
+                "bucketOwnerFullControl",
+                "bucketOwnerRead",
+                "private",
+                "projectPrivate",
+                "publicRead"
+              ],
+              "enumDescriptions": [
+                "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.",
+                "Object owner gets OWNER access, and project team owners get OWNER access.",
+                "Object owner gets OWNER access, and project team owners get READER access.",
+                "Object owner gets OWNER access.",
+                "Object owner gets OWNER access, and project team members get access according to their roles.",
+                "Object owner gets OWNER access, and allUsers get READER access."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "ifGenerationMatch": {
+              "description": "Makes the operation conditional on whether the object's current generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifGenerationNotMatch": {
+              "description": "Makes the operation conditional on whether the object's current generation does not match the given value. If no live object exists, the precondition fails. Setting to 0 makes the operation succeed only if there is a live version of the object.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationMatch": {
+              "description": "Makes the operation conditional on whether the destination object's current metageneration matches the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationNotMatch": {
+              "description": "Makes the operation conditional on whether the destination object's current metageneration does not match the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifSourceGenerationMatch": {
+              "description": "Makes the operation conditional on whether the source object's current generation matches the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifSourceGenerationNotMatch": {
+              "description": "Makes the operation conditional on whether the source object's current generation does not match the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifSourceMetagenerationMatch": {
+              "description": "Makes the operation conditional on whether the source object's current metageneration matches the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifSourceMetagenerationNotMatch": {
+              "description": "Makes the operation conditional on whether the source object's current metageneration does not match the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "maxBytesRewrittenPerCall": {
+              "description": "The maximum number of bytes that will be rewritten per rewrite request. Most callers shouldn't need to specify this parameter - it is primarily in place to support testing. If specified the value must be an integral multiple of 1 MiB (1048576). Also, this only applies to requests where the source and destination span locations and/or storage classes. Finally, this value must not change across rewrite calls else you'll get an error that the rewriteToken is invalid.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "projection": {
+              "description": "Set of properties to return. Defaults to noAcl, unless the object resource specifies the acl property, when it defaults to full.",
+              "enum": [
+                "full",
+                "noAcl"
+              ],
+              "enumDescriptions": [
+                "Include all properties.",
+                "Omit the owner, acl property."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "rewriteToken": {
+              "description": "Include this field (from the previous rewrite response) on each rewrite request after the first one, until the rewrite response 'done' flag is true. Calls that provide a rewriteToken can omit all other request fields, but if included those fields must match the values provided in the first rewrite request.",
+              "location": "query",
+              "type": "string"
+            },
+            "sourceBucket": {
+              "description": "Name of the bucket in which to find the source object.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "sourceGeneration": {
+              "description": "If present, selects a specific revision of the source object (as opposed to the latest version, the default).",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "sourceObject": {
+              "description": "Name of the source object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{sourceBucket}/o/{sourceObject}/rewriteTo/b/{destinationBucket}/o/{destinationObject}",
+          "request": {
+            "$ref": "Object"
+          },
+          "response": {
+            "$ref": "RewriteResponse"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        },
+        "setIamPolicy": {
+          "description": "Updates an IAM policy for the specified object.",
+          "httpMethod": "PUT",
+          "id": "storage.objects.setIamPolicy",
+          "parameterOrder": [
+            "bucket",
+            "object"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of the bucket in which the object resides.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "generation": {
+              "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "object": {
+              "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/o/{object}/iam",
+          "request": {
+            "$ref": "Policy"
+          },
+          "response": {
+            "$ref": "Policy"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        },
+        "testIamPermissions": {
+          "description": "Tests a set of permissions on the given object to see which, if any, are held by the caller.",
+          "httpMethod": "GET",
+          "id": "storage.objects.testIamPermissions",
+          "parameterOrder": [
+            "bucket",
+            "object",
+            "permissions"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of the bucket in which the object resides.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "generation": {
+              "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "object": {
+              "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "permissions": {
+              "description": "Permissions to test.",
+              "location": "query",
+              "repeated": true,
+              "required": true,
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/o/{object}/iam/testPermissions",
+          "response": {
+            "$ref": "TestIamPermissionsResponse"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_only",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ]
+        },
+        "update": {
+          "description": "Updates an object's metadata.",
+          "httpMethod": "PUT",
+          "id": "storage.objects.update",
+          "parameterOrder": [
+            "bucket",
+            "object"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of the bucket in which the object resides.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "generation": {
+              "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifGenerationMatch": {
+              "description": "Makes the operation conditional on whether the object's current generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifGenerationNotMatch": {
+              "description": "Makes the operation conditional on whether the object's current generation does not match the given value. If no live object exists, the precondition fails. Setting to 0 makes the operation succeed only if there is a live version of the object.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationMatch": {
+              "description": "Makes the operation conditional on whether the object's current metageneration matches the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "ifMetagenerationNotMatch": {
+              "description": "Makes the operation conditional on whether the object's current metageneration does not match the given value.",
+              "format": "int64",
+              "location": "query",
+              "type": "string"
+            },
+            "object": {
+              "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "predefinedAcl": {
+              "description": "Apply a predefined set of access controls to this object.",
+              "enum": [
+                "authenticatedRead",
+                "bucketOwnerFullControl",
+                "bucketOwnerRead",
+                "private",
+                "projectPrivate",
+                "publicRead"
+              ],
+              "enumDescriptions": [
+                "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.",
+                "Object owner gets OWNER access, and project team owners get OWNER access.",
+                "Object owner gets OWNER access, and project team owners get READER access.",
+                "Object owner gets OWNER access.",
+                "Object owner gets OWNER access, and project team members get access according to their roles.",
+                "Object owner gets OWNER access, and allUsers get READER access."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "projection": {
+              "description": "Set of properties to return. Defaults to full.",
+              "enum": [
+                "full",
+                "noAcl"
+              ],
+              "enumDescriptions": [
+                "Include all properties.",
+                "Omit the owner, acl property."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "b/{bucket}/o/{object}",
+          "request": {
+            "$ref": "Object"
+          },
+          "response": {
+            "$ref": "Object"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control"
+          ]
+        },
+        "watchAll": {
+          "description": "Watch for changes on all objects in a bucket.",
+          "httpMethod": "POST",
+          "id": "storage.objects.watchAll",
+          "parameterOrder": [
+            "bucket"
+          ],
+          "parameters": {
+            "bucket": {
+              "description": "Name of the bucket in which to look for objects.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "delimiter": {
+              "description": "Returns results in a directory-like mode. items will contain only objects whose names, aside from the prefix, do not contain delimiter. Objects whose names, aside from the prefix, contain delimiter will have their name, truncated after the delimiter, returned in prefixes. Duplicate prefixes are omitted.",
+              "location": "query",
+              "type": "string"
+            },
+            "includeTrailingDelimiter": {
+              "description": "If true, objects that end in exactly one instance of delimiter will have their metadata included in items in addition to prefixes.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "maxResults": {
+              "default": "1000",
+              "description": "Maximum number of items plus prefixes to return in a single page of responses. As duplicate prefixes are omitted, fewer total results may be returned than requested. The service will use this parameter or 1,000 items, whichever is smaller.",
+              "format": "uint32",
+              "location": "query",
+              "minimum": "0",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "A previously-returned page token representing part of the larger set of results to view.",
+              "location": "query",
+              "type": "string"
+            },
+            "prefix": {
+              "description": "Filter results to objects whose names begin with this prefix.",
+              "location": "query",
+              "type": "string"
+            },
+            "projection": {
+              "description": "Set of properties to return. Defaults to noAcl.",
+              "enum": [
+                "full",
+                "noAcl"
+              ],
+              "enumDescriptions": [
+                "Include all properties.",
+                "Omit the owner, acl property."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "userProject": {
+              "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+              "location": "query",
+              "type": "string"
+            },
+            "versions": {
+              "description": "If true, lists all versions of an object as distinct results. The default is false. For more information, see Object Versioning.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "b/{bucket}/o/watch",
+          "request": {
+            "$ref": "Channel",
+            "parameterName": "resource"
+          },
+          "response": {
+            "$ref": "Channel"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_only",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ],
+          "supportsSubscription": true
+        }
+      }
+    },
+    "projects": {
+      "resources": {
+        "serviceAccount": {
+          "methods": {
+            "get": {
+              "description": "Get the email address of this project's Google Cloud Storage service account.",
+              "httpMethod": "GET",
+              "id": "storage.projects.serviceAccount.get",
+              "parameterOrder": [
+                "projectId"
+              ],
+              "parameters": {
+                "projectId": {
+                  "description": "Project ID",
+                  "location": "path",
+                  "required": true,
+                  "type": "string"
+                },
+                "userProject": {
+                  "description": "The project to be billed for this request.",
+                  "location": "query",
+                  "type": "string"
+                }
+              },
+              "path": "projects/{projectId}/serviceAccount",
+              "response": {
+                "$ref": "ServiceAccount"
+              },
+              "scopes": [
+                "https://www.googleapis.com/auth/cloud-platform",
+                "https://www.googleapis.com/auth/cloud-platform.read-only",
+                "https://www.googleapis.com/auth/devstorage.full_control",
+                "https://www.googleapis.com/auth/devstorage.read_only",
+                "https://www.googleapis.com/auth/devstorage.read_write"
+              ]
+            }
+          }
+        }
+      }
+    }
+  },
+  "revision": "20181109",
+  "rootUrl": "https://www.googleapis.com/",
+  "schemas": {
+    "Bucket": {
+      "description": "A bucket.",
+      "id": "Bucket",
+      "properties": {
+        "acl": {
+          "annotations": {
+            "required": [
+              "storage.buckets.update"
+            ]
+          },
+          "description": "Access controls on the bucket.",
+          "items": {
+            "$ref": "BucketAccessControl"
+          },
+          "type": "array"
+        },
+        "billing": {
+          "description": "The bucket's billing configuration.",
+          "properties": {
+            "requesterPays": {
+              "description": "When set to true, Requester Pays is enabled for this bucket.",
+              "type": "boolean"
+            }
+          },
+          "type": "object"
+        },
+        "cors": {
+          "description": "The bucket's Cross-Origin Resource Sharing (CORS) configuration.",
+          "items": {
+            "properties": {
+              "maxAgeSeconds": {
+                "description": "The value, in seconds, to return in the  Access-Control-Max-Age header used in preflight responses.",
+                "format": "int32",
+                "type": "integer"
+              },
+              "method": {
+                "description": "The list of HTTP methods on which to include CORS response headers, (GET, OPTIONS, POST, etc) Note: \"*\" is permitted in the list of methods, and means \"any method\".",
+                "items": {
+                  "type": "string"
+                },
+                "type": "array"
+              },
+              "origin": {
+                "description": "The list of Origins eligible to receive CORS response headers. Note: \"*\" is permitted in the list of origins, and means \"any Origin\".",
+                "items": {
+                  "type": "string"
+                },
+                "type": "array"
+              },
+              "responseHeader": {
+                "description": "The list of HTTP headers other than the simple response headers to give permission for the user-agent to share across domains.",
+                "items": {
+                  "type": "string"
+                },
+                "type": "array"
+              }
+            },
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "defaultEventBasedHold": {
+          "description": "The default value for event-based hold on newly created objects in this bucket. Event-based hold is a way to retain objects indefinitely until an event occurs, signified by the hold's release. After being released, such objects will be subject to bucket-level retention (if any). One sample use case of this flag is for banks to hold loan documents for at least 3 years after loan is paid in full. Here, bucket-level retention is 3 years and the event is loan being paid in full. In this example, these objects will be held intact for any number of years until the event has occurred (event-based hold on the object is released) and then 3 more years after that. That means retention duration of the objects begins from the moment event-based hold transitioned from true to false. Objects under event-based hold cannot be deleted, overwritten or archived until the hold is removed.",
+          "type": "boolean"
+        },
+        "defaultObjectAcl": {
+          "description": "Default access controls to apply to new objects when no ACL is provided.",
+          "items": {
+            "$ref": "ObjectAccessControl"
+          },
+          "type": "array"
+        },
+        "encryption": {
+          "description": "Encryption configuration for a bucket.",
+          "properties": {
+            "defaultKmsKeyName": {
+              "description": "A Cloud KMS key that will be used to encrypt objects inserted into this bucket, if no encryption method is specified.",
+              "type": "string"
+            }
+          },
+          "type": "object"
+        },
+        "etag": {
+          "description": "HTTP 1.1 Entity tag for the bucket.",
+          "type": "string"
+        },
+        "iamConfiguration": {
+          "description": "The bucket's IAM configuration.",
+          "properties": {
+            "bucketPolicyOnly": {
+              "properties": {
+                "enabled": {
+                  "description": "If set, access checks only use bucket-level IAM policies or above.",
+                  "type": "boolean"
+                },
+                "lockedTime": {
+                  "description": "The deadline time for changing iamConfiguration.bucketPolicyOnly.enabled from true to false in RFC 3339 format. iamConfiguration.bucketPolicyOnly.enabled may be changed from true to false until the locked time, after which the field is immutable.",
+                  "format": "date-time",
+                  "type": "string"
+                }
+              },
+              "type": "object"
+            }
+          },
+          "type": "object"
+        },
+        "id": {
+          "description": "The ID of the bucket. For buckets, the id and name properties are the same.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "storage#bucket",
+          "description": "The kind of item this is. For buckets, this is always storage#bucket.",
+          "type": "string"
+        },
+        "labels": {
+          "additionalProperties": {
+            "description": "An individual label entry.",
+            "type": "string"
+          },
+          "description": "User-provided labels, in key/value pairs.",
+          "type": "object"
+        },
+        "lifecycle": {
+          "description": "The bucket's lifecycle configuration. See lifecycle management for more information.",
+          "properties": {
+            "rule": {
+              "description": "A lifecycle management rule, which is made of an action to take and the condition(s) under which the action will be taken.",
+              "items": {
+                "properties": {
+                  "action": {
+                    "description": "The action to take.",
+                    "properties": {
+                      "storageClass": {
+                        "description": "Target storage class. Required iff the type of the action is SetStorageClass.",
+                        "type": "string"
+                      },
+                      "type": {
+                        "description": "Type of the action. Currently, only Delete and SetStorageClass are supported.",
+                        "type": "string"
+                      }
+                    },
+                    "type": "object"
+                  },
+                  "condition": {
+                    "description": "The condition(s) under which the action will be taken.",
+                    "properties": {
+                      "age": {
+                        "description": "Age of an object (in days). This condition is satisfied when an object reaches the specified age.",
+                        "format": "int32",
+                        "type": "integer"
+                      },
+                      "createdBefore": {
+                        "description": "A date in RFC 3339 format with only the date part (for instance, \"2013-01-15\"). This condition is satisfied when an object is created before midnight of the specified date in UTC.",
+                        "format": "date",
+                        "type": "string"
+                      },
+                      "isLive": {
+                        "description": "Relevant only for versioned objects. If the value is true, this condition matches live objects; if the value is false, it matches archived objects.",
+                        "type": "boolean"
+                      },
+                      "matchesPattern": {
+                        "description": "A regular expression that satisfies the RE2 syntax. This condition is satisfied when the name of the object matches the RE2 pattern. Note: This feature is currently in the \"Early Access\" launch stage and is only available to a whitelisted set of users; that means that this feature may be changed in backward-incompatible ways and that it is not guaranteed to be released.",
+                        "type": "string"
+                      },
+                      "matchesStorageClass": {
+                        "description": "Objects having any of the storage classes specified by this condition will be matched. Values include MULTI_REGIONAL, REGIONAL, NEARLINE, COLDLINE, STANDARD, and DURABLE_REDUCED_AVAILABILITY.",
+                        "items": {
+                          "type": "string"
+                        },
+                        "type": "array"
+                      },
+                      "numNewerVersions": {
+                        "description": "Relevant only for versioned objects. If the value is N, this condition is satisfied when there are at least N versions (including the live version) newer than this version of the object.",
+                        "format": "int32",
+                        "type": "integer"
+                      }
+                    },
+                    "type": "object"
+                  }
+                },
+                "type": "object"
+              },
+              "type": "array"
+            }
+          },
+          "type": "object"
+        },
+        "location": {
+          "description": "The location of the bucket. Object data for objects in the bucket resides in physical storage within this region. Defaults to US. See the developer's guide for the authoritative list.",
+          "type": "string"
+        },
+        "logging": {
+          "description": "The bucket's logging configuration, which defines the destination bucket and optional name prefix for the current bucket's logs.",
+          "properties": {
+            "logBucket": {
+              "description": "The destination bucket where the current bucket's logs should be placed.",
+              "type": "string"
+            },
+            "logObjectPrefix": {
+              "description": "A prefix for log object names.",
+              "type": "string"
+            }
+          },
+          "type": "object"
+        },
+        "metageneration": {
+          "description": "The metadata generation of this bucket.",
+          "format": "int64",
+          "type": "string"
+        },
+        "name": {
+          "annotations": {
+            "required": [
+              "storage.buckets.insert"
+            ]
+          },
+          "description": "The name of the bucket.",
+          "type": "string"
+        },
+        "owner": {
+          "description": "The owner of the bucket. This is always the project team's owner group.",
+          "properties": {
+            "entity": {
+              "description": "The entity, in the form project-owner-projectId.",
+              "type": "string"
+            },
+            "entityId": {
+              "description": "The ID for the entity.",
+              "type": "string"
+            }
+          },
+          "type": "object"
+        },
+        "projectNumber": {
+          "description": "The project number of the project the bucket belongs to.",
+          "format": "uint64",
+          "type": "string"
+        },
+        "retentionPolicy": {
+          "description": "The bucket's retention policy. The retention policy enforces a minimum retention time for all objects contained in the bucket, based on their creation time. Any attempt to overwrite or delete objects younger than the retention period will result in a PERMISSION_DENIED error. An unlocked retention policy can be modified or removed from the bucket via a storage.buckets.update operation. A locked retention policy cannot be removed or shortened in duration for the lifetime of the bucket. Attempting to remove or decrease period of a locked retention policy will result in a PERMISSION_DENIED error.",
+          "properties": {
+            "effectiveTime": {
+              "description": "Server-determined value that indicates the time from which policy was enforced and effective. This value is in RFC 3339 format.",
+              "format": "date-time",
+              "type": "string"
+            },
+            "isLocked": {
+              "description": "Once locked, an object retention policy cannot be modified.",
+              "type": "boolean"
+            },
+            "retentionPeriod": {
+              "description": "The duration in seconds that objects need to be retained. Retention duration must be greater than zero and less than 100 years. Note that enforcement of retention periods less than a day is not guaranteed. Such periods should only be used for testing purposes.",
+              "format": "int64",
+              "type": "string"
+            }
+          },
+          "type": "object"
+        },
+        "selfLink": {
+          "description": "The URI of this bucket.",
+          "type": "string"
+        },
+        "storageClass": {
+          "description": "The bucket's default storage class, used whenever no storageClass is specified for a newly-created object. This defines how objects in the bucket are stored and determines the SLA and the cost of storage. Values include MULTI_REGIONAL, REGIONAL, STANDARD, NEARLINE, COLDLINE, and DURABLE_REDUCED_AVAILABILITY. If this value is not specified when the bucket is created, it will default to STANDARD. For more information, see storage classes.",
+          "type": "string"
+        },
+        "timeCreated": {
+          "description": "The creation time of the bucket in RFC 3339 format.",
+          "format": "date-time",
+          "type": "string"
+        },
+        "updated": {
+          "description": "The modification time of the bucket in RFC 3339 format.",
+          "format": "date-time",
+          "type": "string"
+        },
+        "versioning": {
+          "description": "The bucket's versioning configuration.",
+          "properties": {
+            "enabled": {
+              "description": "While set to true, versioning is fully enabled for this bucket.",
+              "type": "boolean"
+            }
+          },
+          "type": "object"
+        },
+        "website": {
+          "description": "The bucket's website configuration, controlling how the service behaves when accessing bucket contents as a web site. See the Static Website Examples for more information.",
+          "properties": {
+            "mainPageSuffix": {
+              "description": "If the requested object path is missing, the service will ensure the path has a trailing '/', append this suffix, and attempt to retrieve the resulting object. This allows the creation of index.html objects to represent directory pages.",
+              "type": "string"
+            },
+            "notFoundPage": {
+              "description": "If the requested object path is missing, and any mainPageSuffix object is missing, if applicable, the service will return the named object from this bucket as the content for a 404 Not Found result.",
+              "type": "string"
+            }
+          },
+          "type": "object"
+        }
+      },
+      "type": "object"
+    },
+    "BucketAccessControl": {
+      "description": "An access-control entry.",
+      "id": "BucketAccessControl",
+      "properties": {
+        "bucket": {
+          "description": "The name of the bucket.",
+          "type": "string"
+        },
+        "domain": {
+          "description": "The domain associated with the entity, if any.",
+          "type": "string"
+        },
+        "email": {
+          "description": "The email address associated with the entity, if any.",
+          "type": "string"
+        },
+        "entity": {
+          "annotations": {
+            "required": [
+              "storage.bucketAccessControls.insert"
+            ]
+          },
+          "description": "The entity holding the permission, in one of the following forms: \n- user-userId \n- user-email \n- group-groupId \n- group-email \n- domain-domain \n- project-team-projectId \n- allUsers \n- allAuthenticatedUsers Examples: \n- The user liz@example.com would be user-liz@example.com. \n- The group example@googlegroups.com would be group-example@googlegroups.com. \n- To refer to all members of the Google Apps for Business domain example.com, the entity would be domain-example.com.",
+          "type": "string"
+        },
+        "entityId": {
+          "description": "The ID for the entity, if any.",
+          "type": "string"
+        },
+        "etag": {
+          "description": "HTTP 1.1 Entity tag for the access-control entry.",
+          "type": "string"
+        },
+        "id": {
+          "description": "The ID of the access-control entry.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "storage#bucketAccessControl",
+          "description": "The kind of item this is. For bucket access control entries, this is always storage#bucketAccessControl.",
+          "type": "string"
+        },
+        "projectTeam": {
+          "description": "The project team associated with the entity, if any.",
+          "properties": {
+            "projectNumber": {
+              "description": "The project number.",
+              "type": "string"
+            },
+            "team": {
+              "description": "The team.",
+              "type": "string"
+            }
+          },
+          "type": "object"
+        },
+        "role": {
+          "annotations": {
+            "required": [
+              "storage.bucketAccessControls.insert"
+            ]
+          },
+          "description": "The access permission for the entity.",
+          "type": "string"
+        },
+        "selfLink": {
+          "description": "The link to this access-control entry.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "BucketAccessControls": {
+      "description": "An access-control list.",
+      "id": "BucketAccessControls",
+      "properties": {
+        "items": {
+          "description": "The list of items.",
+          "items": {
+            "$ref": "BucketAccessControl"
+          },
+          "type": "array"
+        },
+        "kind": {
+          "default": "storage#bucketAccessControls",
+          "description": "The kind of item this is. For lists of bucket access control entries, this is always storage#bucketAccessControls.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Buckets": {
+      "description": "A list of buckets.",
+      "id": "Buckets",
+      "properties": {
+        "items": {
+          "description": "The list of items.",
+          "items": {
+            "$ref": "Bucket"
+          },
+          "type": "array"
+        },
+        "kind": {
+          "default": "storage#buckets",
+          "description": "The kind of item this is. For lists of buckets, this is always storage#buckets.",
+          "type": "string"
+        },
+        "nextPageToken": {
+          "description": "The continuation token, used to page through large result sets. Provide this value in a subsequent request to return the next page of results.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Channel": {
+      "description": "An notification channel used to watch for resource changes.",
+      "id": "Channel",
+      "properties": {
+        "address": {
+          "description": "The address where notifications are delivered for this channel.",
+          "type": "string"
+        },
+        "expiration": {
+          "description": "Date and time of notification channel expiration, expressed as a Unix timestamp, in milliseconds. Optional.",
+          "format": "int64",
+          "type": "string"
+        },
+        "id": {
+          "description": "A UUID or similar unique string that identifies this channel.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "api#channel",
+          "description": "Identifies this as a notification channel used to watch for changes to a resource. Value: the fixed string \"api#channel\".",
+          "type": "string"
+        },
+        "params": {
+          "additionalProperties": {
+            "description": "Declares a new parameter by name.",
+            "type": "string"
+          },
+          "description": "Additional parameters controlling delivery channel behavior. Optional.",
+          "type": "object"
+        },
+        "payload": {
+          "description": "A Boolean value to indicate whether payload is wanted. Optional.",
+          "type": "boolean"
+        },
+        "resourceId": {
+          "description": "An opaque ID that identifies the resource being watched on this channel. Stable across different API versions.",
+          "type": "string"
+        },
+        "resourceUri": {
+          "description": "A version-specific identifier for the watched resource.",
+          "type": "string"
+        },
+        "token": {
+          "description": "An arbitrary string delivered to the target address with each notification delivered over this channel. Optional.",
+          "type": "string"
+        },
+        "type": {
+          "description": "The type of delivery mechanism used for this channel.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "ComposeRequest": {
+      "description": "A Compose request.",
+      "id": "ComposeRequest",
+      "properties": {
+        "destination": {
+          "$ref": "Object",
+          "description": "Properties of the resulting object."
+        },
+        "kind": {
+          "default": "storage#composeRequest",
+          "description": "The kind of item this is.",
+          "type": "string"
+        },
+        "sourceObjects": {
+          "annotations": {
+            "required": [
+              "storage.objects.compose"
+            ]
+          },
+          "description": "The list of source objects that will be concatenated into a single object.",
+          "items": {
+            "properties": {
+              "generation": {
+                "description": "The generation of this object to use as the source.",
+                "format": "int64",
+                "type": "string"
+              },
+              "name": {
+                "annotations": {
+                  "required": [
+                    "storage.objects.compose"
+                  ]
+                },
+                "description": "The source object's name. All source objects must reside in the same bucket.",
+                "type": "string"
+              },
+              "objectPreconditions": {
+                "description": "Conditions that must be met for this operation to execute.",
+                "properties": {
+                  "ifGenerationMatch": {
+                    "description": "Only perform the composition if the generation of the source object that would be used matches this value. If this value and a generation are both specified, they must be the same value or the call will fail.",
+                    "format": "int64",
+                    "type": "string"
+                  }
+                },
+                "type": "object"
+              }
+            },
+            "type": "object"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "Notification": {
+      "description": "A subscription to receive Google PubSub notifications.",
+      "id": "Notification",
+      "properties": {
+        "custom_attributes": {
+          "additionalProperties": {
+            "type": "string"
+          },
+          "description": "An optional list of additional attributes to attach to each Cloud PubSub message published for this notification subscription.",
+          "type": "object"
+        },
+        "etag": {
+          "description": "HTTP 1.1 Entity tag for this subscription notification.",
+          "type": "string"
+        },
+        "event_types": {
+          "description": "If present, only send notifications about listed event types. If empty, sent notifications for all event types.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "id": {
+          "description": "The ID of the notification.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "storage#notification",
+          "description": "The kind of item this is. For notifications, this is always storage#notification.",
+          "type": "string"
+        },
+        "object_name_prefix": {
+          "description": "If present, only apply this notification configuration to object names that begin with this prefix.",
+          "type": "string"
+        },
+        "payload_format": {
+          "annotations": {
+            "required": [
+              "storage.notifications.insert"
+            ]
+          },
+          "default": "JSON_API_V1",
+          "description": "The desired content of the Payload.",
+          "type": "string"
+        },
+        "selfLink": {
+          "description": "The canonical URL of this notification.",
+          "type": "string"
+        },
+        "topic": {
+          "annotations": {
+            "required": [
+              "storage.notifications.insert"
+            ]
+          },
+          "description": "The Cloud PubSub topic to which this subscription publishes. Formatted as: '//pubsub.googleapis.com/projects/{project-identifier}/topics/{my-topic}'",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Notifications": {
+      "description": "A list of notification subscriptions.",
+      "id": "Notifications",
+      "properties": {
+        "items": {
+          "description": "The list of items.",
+          "items": {
+            "$ref": "Notification"
+          },
+          "type": "array"
+        },
+        "kind": {
+          "default": "storage#notifications",
+          "description": "The kind of item this is. For lists of notifications, this is always storage#notifications.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Object": {
+      "description": "An object.",
+      "id": "Object",
+      "properties": {
+        "acl": {
+          "annotations": {
+            "required": [
+              "storage.objects.update"
+            ]
+          },
+          "description": "Access controls on the object.",
+          "items": {
+            "$ref": "ObjectAccessControl"
+          },
+          "type": "array"
+        },
+        "bucket": {
+          "description": "The name of the bucket containing this object.",
+          "type": "string"
+        },
+        "cacheControl": {
+          "description": "Cache-Control directive for the object data. If omitted, and the object is accessible to all anonymous users, the default will be public, max-age=3600.",
+          "type": "string"
+        },
+        "componentCount": {
+          "description": "Number of underlying components that make up this object. Components are accumulated by compose operations.",
+          "format": "int32",
+          "type": "integer"
+        },
+        "contentDisposition": {
+          "description": "Content-Disposition of the object data.",
+          "type": "string"
+        },
+        "contentEncoding": {
+          "description": "Content-Encoding of the object data.",
+          "type": "string"
+        },
+        "contentLanguage": {
+          "description": "Content-Language of the object data.",
+          "type": "string"
+        },
+        "contentType": {
+          "description": "Content-Type of the object data. If an object is stored without a Content-Type, it is served as application/octet-stream.",
+          "type": "string"
+        },
+        "crc32c": {
+          "description": "CRC32c checksum, as described in RFC 4960, Appendix B; encoded using base64 in big-endian byte order. For more information about using the CRC32c checksum, see Hashes and ETags: Best Practices.",
+          "type": "string"
+        },
+        "customerEncryption": {
+          "description": "Metadata of customer-supplied encryption key, if the object is encrypted by such a key.",
+          "properties": {
+            "encryptionAlgorithm": {
+              "description": "The encryption algorithm.",
+              "type": "string"
+            },
+            "keySha256": {
+              "description": "SHA256 hash value of the encryption key.",
+              "type": "string"
+            }
+          },
+          "type": "object"
+        },
+        "etag": {
+          "description": "HTTP 1.1 Entity tag for the object.",
+          "type": "string"
+        },
+        "eventBasedHold": {
+          "description": "Whether an object is under event-based hold. Event-based hold is a way to retain objects until an event occurs, which is signified by the hold's release (i.e. this value is set to false). After being released (set to false), such objects will be subject to bucket-level retention (if any). One sample use case of this flag is for banks to hold loan documents for at least 3 years after loan is paid in full. Here, bucket-level retention is 3 years and the event is the loan being paid in full. In this example, these objects will be held intact for any number of years until the event has occurred (event-based hold on the object is released) and then 3 more years after that. That means retention duration of the objects begins from the moment event-based hold transitioned from true to false.",
+          "type": "boolean"
+        },
+        "generation": {
+          "description": "The content generation of this object. Used for object versioning.",
+          "format": "int64",
+          "type": "string"
+        },
+        "id": {
+          "description": "The ID of the object, including the bucket name, object name, and generation number.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "storage#object",
+          "description": "The kind of item this is. For objects, this is always storage#object.",
+          "type": "string"
+        },
+        "kmsKeyName": {
+          "description": "Cloud KMS Key used to encrypt this object, if the object is encrypted by such a key.",
+          "type": "string"
+        },
+        "md5Hash": {
+          "description": "MD5 hash of the data; encoded using base64. For more information about using the MD5 hash, see Hashes and ETags: Best Practices.",
+          "type": "string"
+        },
+        "mediaLink": {
+          "description": "Media download link.",
+          "type": "string"
+        },
+        "metadata": {
+          "additionalProperties": {
+            "description": "An individual metadata entry.",
+            "type": "string"
+          },
+          "description": "User-provided metadata, in key/value pairs.",
+          "type": "object"
+        },
+        "metageneration": {
+          "description": "The version of the metadata for this object at this generation. Used for preconditions and for detecting changes in metadata. A metageneration number is only meaningful in the context of a particular generation of a particular object.",
+          "format": "int64",
+          "type": "string"
+        },
+        "name": {
+          "description": "The name of the object. Required if not specified by URL parameter.",
+          "type": "string"
+        },
+        "owner": {
+          "description": "The owner of the object. This will always be the uploader of the object.",
+          "properties": {
+            "entity": {
+              "description": "The entity, in the form user-userId.",
+              "type": "string"
+            },
+            "entityId": {
+              "description": "The ID for the entity.",
+              "type": "string"
+            }
+          },
+          "type": "object"
+        },
+        "retentionExpirationTime": {
+          "description": "A server-determined value that specifies the earliest time that the object's retention period expires. This value is in RFC 3339 format. Note 1: This field is not provided for objects with an active event-based hold, since retention expiration is unknown until the hold is removed. Note 2: This value can be provided even when temporary hold is set (so that the user can reason about policy without having to first unset the temporary hold).",
+          "format": "date-time",
+          "type": "string"
+        },
+        "selfLink": {
+          "description": "The link to this object.",
+          "type": "string"
+        },
+        "size": {
+          "description": "Content-Length of the data in bytes.",
+          "format": "uint64",
+          "type": "string"
+        },
+        "storageClass": {
+          "description": "Storage class of the object.",
+          "type": "string"
+        },
+        "temporaryHold": {
+          "description": "Whether an object is under temporary hold. While this flag is set to true, the object is protected against deletion and overwrites. A common use case of this flag is regulatory investigations where objects need to be retained while the investigation is ongoing. Note that unlike event-based hold, temporary hold does not impact retention expiration time of an object.",
+          "type": "boolean"
+        },
+        "timeCreated": {
+          "description": "The creation time of the object in RFC 3339 format.",
+          "format": "date-time",
+          "type": "string"
+        },
+        "timeDeleted": {
+          "description": "The deletion time of the object in RFC 3339 format. Will be returned if and only if this version of the object has been deleted.",
+          "format": "date-time",
+          "type": "string"
+        },
+        "timeStorageClassUpdated": {
+          "description": "The time at which the object's storage class was last changed. When the object is initially created, it will be set to timeCreated.",
+          "format": "date-time",
+          "type": "string"
+        },
+        "updated": {
+          "description": "The modification time of the object metadata in RFC 3339 format.",
+          "format": "date-time",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "ObjectAccessControl": {
+      "description": "An access-control entry.",
+      "id": "ObjectAccessControl",
+      "properties": {
+        "bucket": {
+          "description": "The name of the bucket.",
+          "type": "string"
+        },
+        "domain": {
+          "description": "The domain associated with the entity, if any.",
+          "type": "string"
+        },
+        "email": {
+          "description": "The email address associated with the entity, if any.",
+          "type": "string"
+        },
+        "entity": {
+          "annotations": {
+            "required": [
+              "storage.defaultObjectAccessControls.insert",
+              "storage.objectAccessControls.insert"
+            ]
+          },
+          "description": "The entity holding the permission, in one of the following forms: \n- user-userId \n- user-email \n- group-groupId \n- group-email \n- domain-domain \n- project-team-projectId \n- allUsers \n- allAuthenticatedUsers Examples: \n- The user liz@example.com would be user-liz@example.com. \n- The group example@googlegroups.com would be group-example@googlegroups.com. \n- To refer to all members of the Google Apps for Business domain example.com, the entity would be domain-example.com.",
+          "type": "string"
+        },
+        "entityId": {
+          "description": "The ID for the entity, if any.",
+          "type": "string"
+        },
+        "etag": {
+          "description": "HTTP 1.1 Entity tag for the access-control entry.",
+          "type": "string"
+        },
+        "generation": {
+          "description": "The content generation of the object, if applied to an object.",
+          "format": "int64",
+          "type": "string"
+        },
+        "id": {
+          "description": "The ID of the access-control entry.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "storage#objectAccessControl",
+          "description": "The kind of item this is. For object access control entries, this is always storage#objectAccessControl.",
+          "type": "string"
+        },
+        "object": {
+          "description": "The name of the object, if applied to an object.",
+          "type": "string"
+        },
+        "projectTeam": {
+          "description": "The project team associated with the entity, if any.",
+          "properties": {
+            "projectNumber": {
+              "description": "The project number.",
+              "type": "string"
+            },
+            "team": {
+              "description": "The team.",
+              "type": "string"
+            }
+          },
+          "type": "object"
+        },
+        "role": {
+          "annotations": {
+            "required": [
+              "storage.defaultObjectAccessControls.insert",
+              "storage.objectAccessControls.insert"
+            ]
+          },
+          "description": "The access permission for the entity.",
+          "type": "string"
+        },
+        "selfLink": {
+          "description": "The link to this access-control entry.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "ObjectAccessControls": {
+      "description": "An access-control list.",
+      "id": "ObjectAccessControls",
+      "properties": {
+        "items": {
+          "description": "The list of items.",
+          "items": {
+            "$ref": "ObjectAccessControl"
+          },
+          "type": "array"
+        },
+        "kind": {
+          "default": "storage#objectAccessControls",
+          "description": "The kind of item this is. For lists of object access control entries, this is always storage#objectAccessControls.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Objects": {
+      "description": "A list of objects.",
+      "id": "Objects",
+      "properties": {
+        "items": {
+          "description": "The list of items.",
+          "items": {
+            "$ref": "Object"
+          },
+          "type": "array"
+        },
+        "kind": {
+          "default": "storage#objects",
+          "description": "The kind of item this is. For lists of objects, this is always storage#objects.",
+          "type": "string"
+        },
+        "nextPageToken": {
+          "description": "The continuation token, used to page through large result sets. Provide this value in a subsequent request to return the next page of results.",
+          "type": "string"
+        },
+        "prefixes": {
+          "description": "The list of prefixes of objects matching-but-not-listed up to and including the requested delimiter.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "Policy": {
+      "description": "A bucket/object IAM policy.",
+      "id": "Policy",
+      "properties": {
+        "bindings": {
+          "annotations": {
+            "required": [
+              "storage.buckets.setIamPolicy",
+              "storage.objects.setIamPolicy"
+            ]
+          },
+          "description": "An association between a role, which comes with a set of permissions, and members who may assume that role.",
+          "items": {
+            "properties": {
+              "condition": {
+                "type": "any"
+              },
+              "members": {
+                "annotations": {
+                  "required": [
+                    "storage.buckets.setIamPolicy",
+                    "storage.objects.setIamPolicy"
+                  ]
+                },
+                "description": "A collection of identifiers for members who may assume the provided role. Recognized identifiers are as follows:  \n- allUsers — A special identifier that represents anyone on the internet; with or without a Google account.  \n- allAuthenticatedUsers — A special identifier that represents anyone who is authenticated with a Google account or a service account.  \n- user:emailid — An email address that represents a specific account. For example, user:alice@gmail.com or user:joe@example.com.  \n- serviceAccount:emailid — An email address that represents a service account. For example,  serviceAccount:my-other-app@appspot.gserviceaccount.com .  \n- group:emailid — An email address that represents a Google group. For example, group:admins@example.com.  \n- domain:domain — A Google Apps domain name that represents all the users of that domain. For example, domain:google.com or domain:example.com.  \n- projectOwner:projectid — Owners of the given project. For example, projectOwner:my-example-project  \n- projectEditor:projectid — Editors of the given project. For example, projectEditor:my-example-project  \n- projectViewer:projectid — Viewers of the given project. For example, projectViewer:my-example-project",
+                "items": {
+                  "type": "string"
+                },
+                "type": "array"
+              },
+              "role": {
+                "annotations": {
+                  "required": [
+                    "storage.buckets.setIamPolicy",
+                    "storage.objects.setIamPolicy"
+                  ]
+                },
+                "description": "The role to which members belong. Two types of roles are supported: new IAM roles, which grant permissions that do not map directly to those provided by ACLs, and legacy IAM roles, which do map directly to ACL permissions. All roles are of the format roles/storage.specificRole.\nThe new IAM roles are:  \n- roles/storage.admin — Full control of Google Cloud Storage resources.  \n- roles/storage.objectViewer — Read-Only access to Google Cloud Storage objects.  \n- roles/storage.objectCreator — Access to create objects in Google Cloud Storage.  \n- roles/storage.objectAdmin — Full control of Google Cloud Storage objects.   The legacy IAM roles are:  \n- roles/storage.legacyObjectReader — Read-only access to objects without listing. Equivalent to an ACL entry on an object with the READER role.  \n- roles/storage.legacyObjectOwner — Read/write access to existing objects without listing. Equivalent to an ACL entry on an object with the OWNER role.  \n- roles/storage.legacyBucketReader — Read access to buckets with object listing. Equivalent to an ACL entry on a bucket with the READER role.  \n- roles/storage.legacyBucketWriter — Read access to buckets with object listing/creation/deletion. Equivalent to an ACL entry on a bucket with the WRITER role.  \n- roles/storage.legacyBucketOwner — Read and write access to existing buckets with object listing/creation/deletion. Equivalent to an ACL entry on a bucket with the OWNER role.",
+                "type": "string"
+              }
+            },
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "etag": {
+          "description": "HTTP 1.1  Entity tag for the policy.",
+          "format": "byte",
+          "type": "string"
+        },
+        "kind": {
+          "default": "storage#policy",
+          "description": "The kind of item this is. For policies, this is always storage#policy. This field is ignored on input.",
+          "type": "string"
+        },
+        "resourceId": {
+          "description": "The ID of the resource to which this policy belongs. Will be of the form projects/_/buckets/bucket for buckets, and projects/_/buckets/bucket/objects/object for objects. A specific generation may be specified by appending #generationNumber to the end of the object name, e.g. projects/_/buckets/my-bucket/objects/data.txt#17. The current generation can be denoted with #0. This field is ignored on input.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "RewriteResponse": {
+      "description": "A rewrite response.",
+      "id": "RewriteResponse",
+      "properties": {
+        "done": {
+          "description": "true if the copy is finished; otherwise, false if the copy is in progress. This property is always present in the response.",
+          "type": "boolean"
+        },
+        "kind": {
+          "default": "storage#rewriteResponse",
+          "description": "The kind of item this is.",
+          "type": "string"
+        },
+        "objectSize": {
+          "description": "The total size of the object being copied in bytes. This property is always present in the response.",
+          "format": "int64",
+          "type": "string"
+        },
+        "resource": {
+          "$ref": "Object",
+          "description": "A resource containing the metadata for the copied-to object. This property is present in the response only when copying completes."
+        },
+        "rewriteToken": {
+          "description": "A token to use in subsequent requests to continue copying data. This token is present in the response only when there is more data to copy.",
+          "type": "string"
+        },
+        "totalBytesRewritten": {
+          "description": "The total bytes written so far, which can be used to provide a waiting user with a progress indicator. This property is always present in the response.",
+          "format": "int64",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "ServiceAccount": {
+      "description": "A subscription to receive Google PubSub notifications.",
+      "id": "ServiceAccount",
+      "properties": {
+        "email_address": {
+          "description": "The ID of the notification.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "storage#serviceAccount",
+          "description": "The kind of item this is. For notifications, this is always storage#notification.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "TestIamPermissionsResponse": {
+      "description": "A storage.(buckets|objects).testIamPermissions response.",
+      "id": "TestIamPermissionsResponse",
+      "properties": {
+        "kind": {
+          "default": "storage#testIamPermissionsResponse",
+          "description": "The kind of item this is.",
+          "type": "string"
+        },
+        "permissions": {
+          "description": "The permissions held by the caller. Permissions are always of the format storage.resource.capability, where resource is one of buckets or objects. The supported permissions are as follows:  \n- storage.buckets.delete — Delete bucket.  \n- storage.buckets.get — Read bucket metadata.  \n- storage.buckets.getIamPolicy — Read bucket IAM policy.  \n- storage.buckets.create — Create bucket.  \n- storage.buckets.list — List buckets.  \n- storage.buckets.setIamPolicy — Update bucket IAM policy.  \n- storage.buckets.update — Update bucket metadata.  \n- storage.objects.delete — Delete object.  \n- storage.objects.get — Read object data and metadata.  \n- storage.objects.getIamPolicy — Read object IAM policy.  \n- storage.objects.create — Create object.  \n- storage.objects.list — List objects.  \n- storage.objects.setIamPolicy — Update object IAM policy.  \n- storage.objects.update — Update object metadata.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    }
+  },
+  "servicePath": "storage/v1/",
+  "title": "Cloud Storage JSON API",
+  "version": "v1"
+}
\ No newline at end of file
diff --git a/vendor/google.golang.org/api/storage/v1/storage-gen.go b/vendor/google.golang.org/api/storage/v1/storage-gen.go
new file mode 100644
index 0000000..606686f
--- /dev/null
+++ b/vendor/google.golang.org/api/storage/v1/storage-gen.go
@@ -0,0 +1,11472 @@
+// Copyright 2018 Google Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Code generated file. DO NOT EDIT.
+
+// Package storage provides access to the Cloud Storage JSON API.
+//
+// This package is DEPRECATED. Use package cloud.google.com/go/storage instead.
+//
+// See https://developers.google.com/storage/docs/json_api/
+//
+// Usage example:
+//
+//   import "google.golang.org/api/storage/v1"
+//   ...
+//   storageService, err := storage.New(oauthHttpClient)
+package storage // import "google.golang.org/api/storage/v1"
+
+import (
+        "bytes"
+        "context"
+        "encoding/json"
+        "errors"
+        "fmt"
+        "io"
+        "net/http"
+        "net/url"
+        "strconv"
+        "strings"
+
+        gensupport "google.golang.org/api/gensupport"
+        googleapi "google.golang.org/api/googleapi"
+)
+
+// Always reference these packages, just in case the auto-generated code
+// below doesn't.
+var _ = bytes.NewBuffer
+var _ = strconv.Itoa
+var _ = fmt.Sprintf
+var _ = json.NewDecoder
+var _ = io.Copy
+var _ = url.Parse
+var _ = gensupport.MarshalJSON
+var _ = googleapi.Version
+var _ = errors.New
+var _ = strings.Replace
+var _ = context.Canceled
+
+const apiId = "storage:v1"
+const apiName = "storage"
+const apiVersion = "v1"
+const basePath = "https://www.googleapis.com/storage/v1/"
+
+// OAuth2 scopes used by this API.
+const (
+        // View and manage your data across Google Cloud Platform services
+        CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform"
+
+        // View your data across Google Cloud Platform services
+        CloudPlatformReadOnlyScope = "https://www.googleapis.com/auth/cloud-platform.read-only"
+
+        // Manage your data and permissions in Google Cloud Storage
+        DevstorageFullControlScope = "https://www.googleapis.com/auth/devstorage.full_control"
+
+        // View your data in Google Cloud Storage
+        DevstorageReadOnlyScope = "https://www.googleapis.com/auth/devstorage.read_only"
+
+        // Manage your data in Google Cloud Storage
+        DevstorageReadWriteScope = "https://www.googleapis.com/auth/devstorage.read_write"
+)
+
+func New(client *http.Client) (*Service, error) {
+        if client == nil {
+                return nil, errors.New("client is nil")
+        }
+        s := &Service{client: client, BasePath: basePath}
+        s.BucketAccessControls = NewBucketAccessControlsService(s)
+        s.Buckets = NewBucketsService(s)
+        s.Channels = NewChannelsService(s)
+        s.DefaultObjectAccessControls = NewDefaultObjectAccessControlsService(s)
+        s.Notifications = NewNotificationsService(s)
+        s.ObjectAccessControls = NewObjectAccessControlsService(s)
+        s.Objects = NewObjectsService(s)
+        s.Projects = NewProjectsService(s)
+        return s, nil
+}
+
+type Service struct {
+        client    *http.Client
+        BasePath  string // API endpoint base URL
+        UserAgent string // optional additional User-Agent fragment
+
+        BucketAccessControls *BucketAccessControlsService
+
+        Buckets *BucketsService
+
+        Channels *ChannelsService
+
+        DefaultObjectAccessControls *DefaultObjectAccessControlsService
+
+        Notifications *NotificationsService
+
+        ObjectAccessControls *ObjectAccessControlsService
+
+        Objects *ObjectsService
+
+        Projects *ProjectsService
+}
+
+func (s *Service) userAgent() string {
+        if s.UserAgent == "" {
+                return googleapi.UserAgent
+        }
+        return googleapi.UserAgent + " " + s.UserAgent
+}
+
+func NewBucketAccessControlsService(s *Service) *BucketAccessControlsService {
+        rs := &BucketAccessControlsService{s: s}
+        return rs
+}
+
+type BucketAccessControlsService struct {
+        s *Service
+}
+
+func NewBucketsService(s *Service) *BucketsService {
+        rs := &BucketsService{s: s}
+        return rs
+}
+
+type BucketsService struct {
+        s *Service
+}
+
+func NewChannelsService(s *Service) *ChannelsService {
+        rs := &ChannelsService{s: s}
+        return rs
+}
+
+type ChannelsService struct {
+        s *Service
+}
+
+func NewDefaultObjectAccessControlsService(s *Service) *DefaultObjectAccessControlsService {
+        rs := &DefaultObjectAccessControlsService{s: s}
+        return rs
+}
+
+type DefaultObjectAccessControlsService struct {
+        s *Service
+}
+
+func NewNotificationsService(s *Service) *NotificationsService {
+        rs := &NotificationsService{s: s}
+        return rs
+}
+
+type NotificationsService struct {
+        s *Service
+}
+
+func NewObjectAccessControlsService(s *Service) *ObjectAccessControlsService {
+        rs := &ObjectAccessControlsService{s: s}
+        return rs
+}
+
+type ObjectAccessControlsService struct {
+        s *Service
+}
+
+func NewObjectsService(s *Service) *ObjectsService {
+        rs := &ObjectsService{s: s}
+        return rs
+}
+
+type ObjectsService struct {
+        s *Service
+}
+
+func NewProjectsService(s *Service) *ProjectsService {
+        rs := &ProjectsService{s: s}
+        rs.ServiceAccount = NewProjectsServiceAccountService(s)
+        return rs
+}
+
+type ProjectsService struct {
+        s *Service
+
+        ServiceAccount *ProjectsServiceAccountService
+}
+
+func NewProjectsServiceAccountService(s *Service) *ProjectsServiceAccountService {
+        rs := &ProjectsServiceAccountService{s: s}
+        return rs
+}
+
+type ProjectsServiceAccountService struct {
+        s *Service
+}
+
+// Bucket: A bucket.
+type Bucket struct {
+        // Acl: Access controls on the bucket.
+        Acl []*BucketAccessControl `json:"acl,omitempty"`
+
+        // Billing: The bucket's billing configuration.
+        Billing *BucketBilling `json:"billing,omitempty"`
+
+        // Cors: The bucket's Cross-Origin Resource Sharing (CORS)
+        // configuration.
+        Cors []*BucketCors `json:"cors,omitempty"`
+
+        // DefaultEventBasedHold: The default value for event-based hold on
+        // newly created objects in this bucket. Event-based hold is a way to
+        // retain objects indefinitely until an event occurs, signified by the
+        // hold's release. After being released, such objects will be subject to
+        // bucket-level retention (if any). One sample use case of this flag is
+        // for banks to hold loan documents for at least 3 years after loan is
+        // paid in full. Here, bucket-level retention is 3 years and the event
+        // is loan being paid in full. In this example, these objects will be
+        // held intact for any number of years until the event has occurred
+        // (event-based hold on the object is released) and then 3 more years
+        // after that. That means retention duration of the objects begins from
+        // the moment event-based hold transitioned from true to false. Objects
+        // under event-based hold cannot be deleted, overwritten or archived
+        // until the hold is removed.
+        DefaultEventBasedHold bool `json:"defaultEventBasedHold,omitempty"`
+
+        // DefaultObjectAcl: Default access controls to apply to new objects
+        // when no ACL is provided.
+        DefaultObjectAcl []*ObjectAccessControl `json:"defaultObjectAcl,omitempty"`
+
+        // Encryption: Encryption configuration for a bucket.
+        Encryption *BucketEncryption `json:"encryption,omitempty"`
+
+        // Etag: HTTP 1.1 Entity tag for the bucket.
+        Etag string `json:"etag,omitempty"`
+
+        // IamConfiguration: The bucket's IAM configuration.
+        IamConfiguration *BucketIamConfiguration `json:"iamConfiguration,omitempty"`
+
+        // Id: The ID of the bucket. For buckets, the id and name properties are
+        // the same.
+        Id string `json:"id,omitempty"`
+
+        // Kind: The kind of item this is. For buckets, this is always
+        // storage#bucket.
+        Kind string `json:"kind,omitempty"`
+
+        // Labels: User-provided labels, in key/value pairs.
+        Labels map[string]string `json:"labels,omitempty"`
+
+        // Lifecycle: The bucket's lifecycle configuration. See lifecycle
+        // management for more information.
+        Lifecycle *BucketLifecycle `json:"lifecycle,omitempty"`
+
+        // Location: The location of the bucket. Object data for objects in the
+        // bucket resides in physical storage within this region. Defaults to
+        // US. See the developer's guide for the authoritative list.
+        Location string `json:"location,omitempty"`
+
+        // Logging: The bucket's logging configuration, which defines the
+        // destination bucket and optional name prefix for the current bucket's
+        // logs.
+        Logging *BucketLogging `json:"logging,omitempty"`
+
+        // Metageneration: The metadata generation of this bucket.
+        Metageneration int64 `json:"metageneration,omitempty,string"`
+
+        // Name: The name of the bucket.
+        Name string `json:"name,omitempty"`
+
+        // Owner: The owner of the bucket. This is always the project team's
+        // owner group.
+        Owner *BucketOwner `json:"owner,omitempty"`
+
+        // ProjectNumber: The project number of the project the bucket belongs
+        // to.
+        ProjectNumber uint64 `json:"projectNumber,omitempty,string"`
+
+        // RetentionPolicy: The bucket's retention policy. The retention policy
+        // enforces a minimum retention time for all objects contained in the
+        // bucket, based on their creation time. Any attempt to overwrite or
+        // delete objects younger than the retention period will result in a
+        // PERMISSION_DENIED error. An unlocked retention policy can be modified
+        // or removed from the bucket via a storage.buckets.update operation. A
+        // locked retention policy cannot be removed or shortened in duration
+        // for the lifetime of the bucket. Attempting to remove or decrease
+        // period of a locked retention policy will result in a
+        // PERMISSION_DENIED error.
+        RetentionPolicy *BucketRetentionPolicy `json:"retentionPolicy,omitempty"`
+
+        // SelfLink: The URI of this bucket.
+        SelfLink string `json:"selfLink,omitempty"`
+
+        // StorageClass: The bucket's default storage class, used whenever no
+        // storageClass is specified for a newly-created object. This defines
+        // how objects in the bucket are stored and determines the SLA and the
+        // cost of storage. Values include MULTI_REGIONAL, REGIONAL, STANDARD,
+        // NEARLINE, COLDLINE, and DURABLE_REDUCED_AVAILABILITY. If this value
+        // is not specified when the bucket is created, it will default to
+        // STANDARD. For more information, see storage classes.
+        StorageClass string `json:"storageClass,omitempty"`
+
+        // TimeCreated: The creation time of the bucket in RFC 3339 format.
+        TimeCreated string `json:"timeCreated,omitempty"`
+
+        // Updated: The modification time of the bucket in RFC 3339 format.
+        Updated string `json:"updated,omitempty"`
+
+        // Versioning: The bucket's versioning configuration.
+        Versioning *BucketVersioning `json:"versioning,omitempty"`
+
+        // Website: The bucket's website configuration, controlling how the
+        // service behaves when accessing bucket contents as a web site. See the
+        // Static Website Examples for more information.
+        Website *BucketWebsite `json:"website,omitempty"`
+
+        // ServerResponse contains the HTTP response code and headers from the
+        // server.
+        googleapi.ServerResponse `json:"-"`
+
+        // ForceSendFields is a list of field names (e.g. "Acl") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Acl") to include in API
+        // requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *Bucket) MarshalJSON() ([]byte, error) {
+        type NoMethod Bucket
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// BucketBilling: The bucket's billing configuration.
+type BucketBilling struct {
+        // RequesterPays: When set to true, Requester Pays is enabled for this
+        // bucket.
+        RequesterPays bool `json:"requesterPays,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "RequesterPays") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "RequesterPays") to include
+        // in API requests with the JSON null value. By default, fields with
+        // empty values are omitted from API requests. However, any field with
+        // an empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *BucketBilling) MarshalJSON() ([]byte, error) {
+        type NoMethod BucketBilling
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+type BucketCors struct {
+        // MaxAgeSeconds: The value, in seconds, to return in the
+        // Access-Control-Max-Age header used in preflight responses.
+        MaxAgeSeconds int64 `json:"maxAgeSeconds,omitempty"`
+
+        // Method: The list of HTTP methods on which to include CORS response
+        // headers, (GET, OPTIONS, POST, etc) Note: "*" is permitted in the list
+        // of methods, and means "any method".
+        Method []string `json:"method,omitempty"`
+
+        // Origin: The list of Origins eligible to receive CORS response
+        // headers. Note: "*" is permitted in the list of origins, and means
+        // "any Origin".
+        Origin []string `json:"origin,omitempty"`
+
+        // ResponseHeader: The list of HTTP headers other than the simple
+        // response headers to give permission for the user-agent to share
+        // across domains.
+        ResponseHeader []string `json:"responseHeader,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "MaxAgeSeconds") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "MaxAgeSeconds") to include
+        // in API requests with the JSON null value. By default, fields with
+        // empty values are omitted from API requests. However, any field with
+        // an empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *BucketCors) MarshalJSON() ([]byte, error) {
+        type NoMethod BucketCors
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// BucketEncryption: Encryption configuration for a bucket.
+type BucketEncryption struct {
+        // DefaultKmsKeyName: A Cloud KMS key that will be used to encrypt
+        // objects inserted into this bucket, if no encryption method is
+        // specified.
+        DefaultKmsKeyName string `json:"defaultKmsKeyName,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "DefaultKmsKeyName")
+        // to unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "DefaultKmsKeyName") to
+        // include in API requests with the JSON null value. By default, fields
+        // with empty values are omitted from API requests. However, any field
+        // with an empty value appearing in NullFields will be sent to the
+        // server as null. It is an error if a field in this list has a
+        // non-empty value. This may be used to include null fields in Patch
+        // requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *BucketEncryption) MarshalJSON() ([]byte, error) {
+        type NoMethod BucketEncryption
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// BucketIamConfiguration: The bucket's IAM configuration.
+type BucketIamConfiguration struct {
+        BucketPolicyOnly *BucketIamConfigurationBucketPolicyOnly `json:"bucketPolicyOnly,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "BucketPolicyOnly") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "BucketPolicyOnly") to
+        // include in API requests with the JSON null value. By default, fields
+        // with empty values are omitted from API requests. However, any field
+        // with an empty value appearing in NullFields will be sent to the
+        // server as null. It is an error if a field in this list has a
+        // non-empty value. This may be used to include null fields in Patch
+        // requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *BucketIamConfiguration) MarshalJSON() ([]byte, error) {
+        type NoMethod BucketIamConfiguration
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+type BucketIamConfigurationBucketPolicyOnly struct {
+        // Enabled: If set, access checks only use bucket-level IAM policies or
+        // above.
+        Enabled bool `json:"enabled,omitempty"`
+
+        // LockedTime: The deadline time for changing
+        // iamConfiguration.bucketPolicyOnly.enabled from true to false in RFC
+        // 3339 format. iamConfiguration.bucketPolicyOnly.enabled may be changed
+        // from true to false until the locked time, after which the field is
+        // immutable.
+        LockedTime string `json:"lockedTime,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "Enabled") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Enabled") to include in
+        // API requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *BucketIamConfigurationBucketPolicyOnly) MarshalJSON() ([]byte, error) {
+        type NoMethod BucketIamConfigurationBucketPolicyOnly
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// BucketLifecycle: The bucket's lifecycle configuration. See lifecycle
+// management for more information.
+type BucketLifecycle struct {
+        // Rule: A lifecycle management rule, which is made of an action to take
+        // and the condition(s) under which the action will be taken.
+        Rule []*BucketLifecycleRule `json:"rule,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "Rule") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Rule") to include in API
+        // requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *BucketLifecycle) MarshalJSON() ([]byte, error) {
+        type NoMethod BucketLifecycle
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+type BucketLifecycleRule struct {
+        // Action: The action to take.
+        Action *BucketLifecycleRuleAction `json:"action,omitempty"`
+
+        // Condition: The condition(s) under which the action will be taken.
+        Condition *BucketLifecycleRuleCondition `json:"condition,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "Action") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Action") to include in API
+        // requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *BucketLifecycleRule) MarshalJSON() ([]byte, error) {
+        type NoMethod BucketLifecycleRule
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// BucketLifecycleRuleAction: The action to take.
+type BucketLifecycleRuleAction struct {
+        // StorageClass: Target storage class. Required iff the type of the
+        // action is SetStorageClass.
+        StorageClass string `json:"storageClass,omitempty"`
+
+        // Type: Type of the action. Currently, only Delete and SetStorageClass
+        // are supported.
+        Type string `json:"type,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "StorageClass") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "StorageClass") to include
+        // in API requests with the JSON null value. By default, fields with
+        // empty values are omitted from API requests. However, any field with
+        // an empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *BucketLifecycleRuleAction) MarshalJSON() ([]byte, error) {
+        type NoMethod BucketLifecycleRuleAction
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// BucketLifecycleRuleCondition: The condition(s) under which the action
+// will be taken.
+type BucketLifecycleRuleCondition struct {
+        // Age: Age of an object (in days). This condition is satisfied when an
+        // object reaches the specified age.
+        Age int64 `json:"age,omitempty"`
+
+        // CreatedBefore: A date in RFC 3339 format with only the date part (for
+        // instance, "2013-01-15"). This condition is satisfied when an object
+        // is created before midnight of the specified date in UTC.
+        CreatedBefore string `json:"createdBefore,omitempty"`
+
+        // IsLive: Relevant only for versioned objects. If the value is true,
+        // this condition matches live objects; if the value is false, it
+        // matches archived objects.
+        IsLive *bool `json:"isLive,omitempty"`
+
+        // MatchesPattern: A regular expression that satisfies the RE2 syntax.
+        // This condition is satisfied when the name of the object matches the
+        // RE2 pattern. Note: This feature is currently in the "Early Access"
+        // launch stage and is only available to a whitelisted set of users;
+        // that means that this feature may be changed in backward-incompatible
+        // ways and that it is not guaranteed to be released.
+        MatchesPattern string `json:"matchesPattern,omitempty"`
+
+        // MatchesStorageClass: Objects having any of the storage classes
+        // specified by this condition will be matched. Values include
+        // MULTI_REGIONAL, REGIONAL, NEARLINE, COLDLINE, STANDARD, and
+        // DURABLE_REDUCED_AVAILABILITY.
+        MatchesStorageClass []string `json:"matchesStorageClass,omitempty"`
+
+        // NumNewerVersions: Relevant only for versioned objects. If the value
+        // is N, this condition is satisfied when there are at least N versions
+        // (including the live version) newer than this version of the object.
+        NumNewerVersions int64 `json:"numNewerVersions,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "Age") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Age") to include in API
+        // requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *BucketLifecycleRuleCondition) MarshalJSON() ([]byte, error) {
+        type NoMethod BucketLifecycleRuleCondition
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// BucketLogging: The bucket's logging configuration, which defines the
+// destination bucket and optional name prefix for the current bucket's
+// logs.
+type BucketLogging struct {
+        // LogBucket: The destination bucket where the current bucket's logs
+        // should be placed.
+        LogBucket string `json:"logBucket,omitempty"`
+
+        // LogObjectPrefix: A prefix for log object names.
+        LogObjectPrefix string `json:"logObjectPrefix,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "LogBucket") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "LogBucket") to include in
+        // API requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *BucketLogging) MarshalJSON() ([]byte, error) {
+        type NoMethod BucketLogging
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// BucketOwner: The owner of the bucket. This is always the project
+// team's owner group.
+type BucketOwner struct {
+        // Entity: The entity, in the form project-owner-projectId.
+        Entity string `json:"entity,omitempty"`
+
+        // EntityId: The ID for the entity.
+        EntityId string `json:"entityId,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "Entity") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Entity") to include in API
+        // requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *BucketOwner) MarshalJSON() ([]byte, error) {
+        type NoMethod BucketOwner
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// BucketRetentionPolicy: The bucket's retention policy. The retention
+// policy enforces a minimum retention time for all objects contained in
+// the bucket, based on their creation time. Any attempt to overwrite or
+// delete objects younger than the retention period will result in a
+// PERMISSION_DENIED error. An unlocked retention policy can be modified
+// or removed from the bucket via a storage.buckets.update operation. A
+// locked retention policy cannot be removed or shortened in duration
+// for the lifetime of the bucket. Attempting to remove or decrease
+// period of a locked retention policy will result in a
+// PERMISSION_DENIED error.
+type BucketRetentionPolicy struct {
+        // EffectiveTime: Server-determined value that indicates the time from
+        // which policy was enforced and effective. This value is in RFC 3339
+        // format.
+        EffectiveTime string `json:"effectiveTime,omitempty"`
+
+        // IsLocked: Once locked, an object retention policy cannot be modified.
+        IsLocked bool `json:"isLocked,omitempty"`
+
+        // RetentionPeriod: The duration in seconds that objects need to be
+        // retained. Retention duration must be greater than zero and less than
+        // 100 years. Note that enforcement of retention periods less than a day
+        // is not guaranteed. Such periods should only be used for testing
+        // purposes.
+        RetentionPeriod int64 `json:"retentionPeriod,omitempty,string"`
+
+        // ForceSendFields is a list of field names (e.g. "EffectiveTime") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "EffectiveTime") to include
+        // in API requests with the JSON null value. By default, fields with
+        // empty values are omitted from API requests. However, any field with
+        // an empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *BucketRetentionPolicy) MarshalJSON() ([]byte, error) {
+        type NoMethod BucketRetentionPolicy
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// BucketVersioning: The bucket's versioning configuration.
+type BucketVersioning struct {
+        // Enabled: While set to true, versioning is fully enabled for this
+        // bucket.
+        Enabled bool `json:"enabled,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "Enabled") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Enabled") to include in
+        // API requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *BucketVersioning) MarshalJSON() ([]byte, error) {
+        type NoMethod BucketVersioning
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// BucketWebsite: The bucket's website configuration, controlling how
+// the service behaves when accessing bucket contents as a web site. See
+// the Static Website Examples for more information.
+type BucketWebsite struct {
+        // MainPageSuffix: If the requested object path is missing, the service
+        // will ensure the path has a trailing '/', append this suffix, and
+        // attempt to retrieve the resulting object. This allows the creation of
+        // index.html objects to represent directory pages.
+        MainPageSuffix string `json:"mainPageSuffix,omitempty"`
+
+        // NotFoundPage: If the requested object path is missing, and any
+        // mainPageSuffix object is missing, if applicable, the service will
+        // return the named object from this bucket as the content for a 404 Not
+        // Found result.
+        NotFoundPage string `json:"notFoundPage,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "MainPageSuffix") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "MainPageSuffix") to
+        // include in API requests with the JSON null value. By default, fields
+        // with empty values are omitted from API requests. However, any field
+        // with an empty value appearing in NullFields will be sent to the
+        // server as null. It is an error if a field in this list has a
+        // non-empty value. This may be used to include null fields in Patch
+        // requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *BucketWebsite) MarshalJSON() ([]byte, error) {
+        type NoMethod BucketWebsite
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// BucketAccessControl: An access-control entry.
+type BucketAccessControl struct {
+        // Bucket: The name of the bucket.
+        Bucket string `json:"bucket,omitempty"`
+
+        // Domain: The domain associated with the entity, if any.
+        Domain string `json:"domain,omitempty"`
+
+        // Email: The email address associated with the entity, if any.
+        Email string `json:"email,omitempty"`
+
+        // Entity: The entity holding the permission, in one of the following
+        // forms:
+        // - user-userId
+        // - user-email
+        // - group-groupId
+        // - group-email
+        // - domain-domain
+        // - project-team-projectId
+        // - allUsers
+        // - allAuthenticatedUsers Examples:
+        // - The user liz@example.com would be user-liz@example.com.
+        // - The group example@googlegroups.com would be
+        // group-example@googlegroups.com.
+        // - To refer to all members of the Google Apps for Business domain
+        // example.com, the entity would be domain-example.com.
+        Entity string `json:"entity,omitempty"`
+
+        // EntityId: The ID for the entity, if any.
+        EntityId string `json:"entityId,omitempty"`
+
+        // Etag: HTTP 1.1 Entity tag for the access-control entry.
+        Etag string `json:"etag,omitempty"`
+
+        // Id: The ID of the access-control entry.
+        Id string `json:"id,omitempty"`
+
+        // Kind: The kind of item this is. For bucket access control entries,
+        // this is always storage#bucketAccessControl.
+        Kind string `json:"kind,omitempty"`
+
+        // ProjectTeam: The project team associated with the entity, if any.
+        ProjectTeam *BucketAccessControlProjectTeam `json:"projectTeam,omitempty"`
+
+        // Role: The access permission for the entity.
+        Role string `json:"role,omitempty"`
+
+        // SelfLink: The link to this access-control entry.
+        SelfLink string `json:"selfLink,omitempty"`
+
+        // ServerResponse contains the HTTP response code and headers from the
+        // server.
+        googleapi.ServerResponse `json:"-"`
+
+        // ForceSendFields is a list of field names (e.g. "Bucket") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Bucket") to include in API
+        // requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *BucketAccessControl) MarshalJSON() ([]byte, error) {
+        type NoMethod BucketAccessControl
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// BucketAccessControlProjectTeam: The project team associated with the
+// entity, if any.
+type BucketAccessControlProjectTeam struct {
+        // ProjectNumber: The project number.
+        ProjectNumber string `json:"projectNumber,omitempty"`
+
+        // Team: The team.
+        Team string `json:"team,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "ProjectNumber") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "ProjectNumber") to include
+        // in API requests with the JSON null value. By default, fields with
+        // empty values are omitted from API requests. However, any field with
+        // an empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *BucketAccessControlProjectTeam) MarshalJSON() ([]byte, error) {
+        type NoMethod BucketAccessControlProjectTeam
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// BucketAccessControls: An access-control list.
+type BucketAccessControls struct {
+        // Items: The list of items.
+        Items []*BucketAccessControl `json:"items,omitempty"`
+
+        // Kind: The kind of item this is. For lists of bucket access control
+        // entries, this is always storage#bucketAccessControls.
+        Kind string `json:"kind,omitempty"`
+
+        // ServerResponse contains the HTTP response code and headers from the
+        // server.
+        googleapi.ServerResponse `json:"-"`
+
+        // ForceSendFields is a list of field names (e.g. "Items") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Items") to include in API
+        // requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *BucketAccessControls) MarshalJSON() ([]byte, error) {
+        type NoMethod BucketAccessControls
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// Buckets: A list of buckets.
+type Buckets struct {
+        // Items: The list of items.
+        Items []*Bucket `json:"items,omitempty"`
+
+        // Kind: The kind of item this is. For lists of buckets, this is always
+        // storage#buckets.
+        Kind string `json:"kind,omitempty"`
+
+        // NextPageToken: The continuation token, used to page through large
+        // result sets. Provide this value in a subsequent request to return the
+        // next page of results.
+        NextPageToken string `json:"nextPageToken,omitempty"`
+
+        // ServerResponse contains the HTTP response code and headers from the
+        // server.
+        googleapi.ServerResponse `json:"-"`
+
+        // ForceSendFields is a list of field names (e.g. "Items") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Items") to include in API
+        // requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *Buckets) MarshalJSON() ([]byte, error) {
+        type NoMethod Buckets
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// Channel: An notification channel used to watch for resource changes.
+type Channel struct {
+        // Address: The address where notifications are delivered for this
+        // channel.
+        Address string `json:"address,omitempty"`
+
+        // Expiration: Date and time of notification channel expiration,
+        // expressed as a Unix timestamp, in milliseconds. Optional.
+        Expiration int64 `json:"expiration,omitempty,string"`
+
+        // Id: A UUID or similar unique string that identifies this channel.
+        Id string `json:"id,omitempty"`
+
+        // Kind: Identifies this as a notification channel used to watch for
+        // changes to a resource. Value: the fixed string "api#channel".
+        Kind string `json:"kind,omitempty"`
+
+        // Params: Additional parameters controlling delivery channel behavior.
+        // Optional.
+        Params map[string]string `json:"params,omitempty"`
+
+        // Payload: A Boolean value to indicate whether payload is wanted.
+        // Optional.
+        Payload bool `json:"payload,omitempty"`
+
+        // ResourceId: An opaque ID that identifies the resource being watched
+        // on this channel. Stable across different API versions.
+        ResourceId string `json:"resourceId,omitempty"`
+
+        // ResourceUri: A version-specific identifier for the watched resource.
+        ResourceUri string `json:"resourceUri,omitempty"`
+
+        // Token: An arbitrary string delivered to the target address with each
+        // notification delivered over this channel. Optional.
+        Token string `json:"token,omitempty"`
+
+        // Type: The type of delivery mechanism used for this channel.
+        Type string `json:"type,omitempty"`
+
+        // ServerResponse contains the HTTP response code and headers from the
+        // server.
+        googleapi.ServerResponse `json:"-"`
+
+        // ForceSendFields is a list of field names (e.g. "Address") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Address") to include in
+        // API requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *Channel) MarshalJSON() ([]byte, error) {
+        type NoMethod Channel
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// ComposeRequest: A Compose request.
+type ComposeRequest struct {
+        // Destination: Properties of the resulting object.
+        Destination *Object `json:"destination,omitempty"`
+
+        // Kind: The kind of item this is.
+        Kind string `json:"kind,omitempty"`
+
+        // SourceObjects: The list of source objects that will be concatenated
+        // into a single object.
+        SourceObjects []*ComposeRequestSourceObjects `json:"sourceObjects,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "Destination") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Destination") to include
+        // in API requests with the JSON null value. By default, fields with
+        // empty values are omitted from API requests. However, any field with
+        // an empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *ComposeRequest) MarshalJSON() ([]byte, error) {
+        type NoMethod ComposeRequest
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+type ComposeRequestSourceObjects struct {
+        // Generation: The generation of this object to use as the source.
+        Generation int64 `json:"generation,omitempty,string"`
+
+        // Name: The source object's name. All source objects must reside in the
+        // same bucket.
+        Name string `json:"name,omitempty"`
+
+        // ObjectPreconditions: Conditions that must be met for this operation
+        // to execute.
+        ObjectPreconditions *ComposeRequestSourceObjectsObjectPreconditions `json:"objectPreconditions,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "Generation") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Generation") to include in
+        // API requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *ComposeRequestSourceObjects) MarshalJSON() ([]byte, error) {
+        type NoMethod ComposeRequestSourceObjects
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// ComposeRequestSourceObjectsObjectPreconditions: Conditions that must
+// be met for this operation to execute.
+type ComposeRequestSourceObjectsObjectPreconditions struct {
+        // IfGenerationMatch: Only perform the composition if the generation of
+        // the source object that would be used matches this value. If this
+        // value and a generation are both specified, they must be the same
+        // value or the call will fail.
+        IfGenerationMatch int64 `json:"ifGenerationMatch,omitempty,string"`
+
+        // ForceSendFields is a list of field names (e.g. "IfGenerationMatch")
+        // to unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "IfGenerationMatch") to
+        // include in API requests with the JSON null value. By default, fields
+        // with empty values are omitted from API requests. However, any field
+        // with an empty value appearing in NullFields will be sent to the
+        // server as null. It is an error if a field in this list has a
+        // non-empty value. This may be used to include null fields in Patch
+        // requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *ComposeRequestSourceObjectsObjectPreconditions) MarshalJSON() ([]byte, error) {
+        type NoMethod ComposeRequestSourceObjectsObjectPreconditions
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// Notification: A subscription to receive Google PubSub notifications.
+type Notification struct {
+        // CustomAttributes: An optional list of additional attributes to attach
+        // to each Cloud PubSub message published for this notification
+        // subscription.
+        CustomAttributes map[string]string `json:"custom_attributes,omitempty"`
+
+        // Etag: HTTP 1.1 Entity tag for this subscription notification.
+        Etag string `json:"etag,omitempty"`
+
+        // EventTypes: If present, only send notifications about listed event
+        // types. If empty, sent notifications for all event types.
+        EventTypes []string `json:"event_types,omitempty"`
+
+        // Id: The ID of the notification.
+        Id string `json:"id,omitempty"`
+
+        // Kind: The kind of item this is. For notifications, this is always
+        // storage#notification.
+        Kind string `json:"kind,omitempty"`
+
+        // ObjectNamePrefix: If present, only apply this notification
+        // configuration to object names that begin with this prefix.
+        ObjectNamePrefix string `json:"object_name_prefix,omitempty"`
+
+        // PayloadFormat: The desired content of the Payload.
+        PayloadFormat string `json:"payload_format,omitempty"`
+
+        // SelfLink: The canonical URL of this notification.
+        SelfLink string `json:"selfLink,omitempty"`
+
+        // Topic: The Cloud PubSub topic to which this subscription publishes.
+        // Formatted as:
+        // '//pubsub.googleapis.com/projects/{project-identifier}/topics/{my-topi
+        // c}'
+        Topic string `json:"topic,omitempty"`
+
+        // ServerResponse contains the HTTP response code and headers from the
+        // server.
+        googleapi.ServerResponse `json:"-"`
+
+        // ForceSendFields is a list of field names (e.g. "CustomAttributes") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "CustomAttributes") to
+        // include in API requests with the JSON null value. By default, fields
+        // with empty values are omitted from API requests. However, any field
+        // with an empty value appearing in NullFields will be sent to the
+        // server as null. It is an error if a field in this list has a
+        // non-empty value. This may be used to include null fields in Patch
+        // requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *Notification) MarshalJSON() ([]byte, error) {
+        type NoMethod Notification
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// Notifications: A list of notification subscriptions.
+type Notifications struct {
+        // Items: The list of items.
+        Items []*Notification `json:"items,omitempty"`
+
+        // Kind: The kind of item this is. For lists of notifications, this is
+        // always storage#notifications.
+        Kind string `json:"kind,omitempty"`
+
+        // ServerResponse contains the HTTP response code and headers from the
+        // server.
+        googleapi.ServerResponse `json:"-"`
+
+        // ForceSendFields is a list of field names (e.g. "Items") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Items") to include in API
+        // requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *Notifications) MarshalJSON() ([]byte, error) {
+        type NoMethod Notifications
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// Object: An object.
+type Object struct {
+        // Acl: Access controls on the object.
+        Acl []*ObjectAccessControl `json:"acl,omitempty"`
+
+        // Bucket: The name of the bucket containing this object.
+        Bucket string `json:"bucket,omitempty"`
+
+        // CacheControl: Cache-Control directive for the object data. If
+        // omitted, and the object is accessible to all anonymous users, the
+        // default will be public, max-age=3600.
+        CacheControl string `json:"cacheControl,omitempty"`
+
+        // ComponentCount: Number of underlying components that make up this
+        // object. Components are accumulated by compose operations.
+        ComponentCount int64 `json:"componentCount,omitempty"`
+
+        // ContentDisposition: Content-Disposition of the object data.
+        ContentDisposition string `json:"contentDisposition,omitempty"`
+
+        // ContentEncoding: Content-Encoding of the object data.
+        ContentEncoding string `json:"contentEncoding,omitempty"`
+
+        // ContentLanguage: Content-Language of the object data.
+        ContentLanguage string `json:"contentLanguage,omitempty"`
+
+        // ContentType: Content-Type of the object data. If an object is stored
+        // without a Content-Type, it is served as application/octet-stream.
+        ContentType string `json:"contentType,omitempty"`
+
+        // Crc32c: CRC32c checksum, as described in RFC 4960, Appendix B;
+        // encoded using base64 in big-endian byte order. For more information
+        // about using the CRC32c checksum, see Hashes and ETags: Best
+        // Practices.
+        Crc32c string `json:"crc32c,omitempty"`
+
+        // CustomerEncryption: Metadata of customer-supplied encryption key, if
+        // the object is encrypted by such a key.
+        CustomerEncryption *ObjectCustomerEncryption `json:"customerEncryption,omitempty"`
+
+        // Etag: HTTP 1.1 Entity tag for the object.
+        Etag string `json:"etag,omitempty"`
+
+        // EventBasedHold: Whether an object is under event-based hold.
+        // Event-based hold is a way to retain objects until an event occurs,
+        // which is signified by the hold's release (i.e. this value is set to
+        // false). After being released (set to false), such objects will be
+        // subject to bucket-level retention (if any). One sample use case of
+        // this flag is for banks to hold loan documents for at least 3 years
+        // after loan is paid in full. Here, bucket-level retention is 3 years
+        // and the event is the loan being paid in full. In this example, these
+        // objects will be held intact for any number of years until the event
+        // has occurred (event-based hold on the object is released) and then 3
+        // more years after that. That means retention duration of the objects
+        // begins from the moment event-based hold transitioned from true to
+        // false.
+        EventBasedHold bool `json:"eventBasedHold,omitempty"`
+
+        // Generation: The content generation of this object. Used for object
+        // versioning.
+        Generation int64 `json:"generation,omitempty,string"`
+
+        // Id: The ID of the object, including the bucket name, object name, and
+        // generation number.
+        Id string `json:"id,omitempty"`
+
+        // Kind: The kind of item this is. For objects, this is always
+        // storage#object.
+        Kind string `json:"kind,omitempty"`
+
+        // KmsKeyName: Cloud KMS Key used to encrypt this object, if the object
+        // is encrypted by such a key.
+        KmsKeyName string `json:"kmsKeyName,omitempty"`
+
+        // Md5Hash: MD5 hash of the data; encoded using base64. For more
+        // information about using the MD5 hash, see Hashes and ETags: Best
+        // Practices.
+        Md5Hash string `json:"md5Hash,omitempty"`
+
+        // MediaLink: Media download link.
+        MediaLink string `json:"mediaLink,omitempty"`
+
+        // Metadata: User-provided metadata, in key/value pairs.
+        Metadata map[string]string `json:"metadata,omitempty"`
+
+        // Metageneration: The version of the metadata for this object at this
+        // generation. Used for preconditions and for detecting changes in
+        // metadata. A metageneration number is only meaningful in the context
+        // of a particular generation of a particular object.
+        Metageneration int64 `json:"metageneration,omitempty,string"`
+
+        // Name: The name of the object. Required if not specified by URL
+        // parameter.
+        Name string `json:"name,omitempty"`
+
+        // Owner: The owner of the object. This will always be the uploader of
+        // the object.
+        Owner *ObjectOwner `json:"owner,omitempty"`
+
+        // RetentionExpirationTime: A server-determined value that specifies the
+        // earliest time that the object's retention period expires. This value
+        // is in RFC 3339 format. Note 1: This field is not provided for objects
+        // with an active event-based hold, since retention expiration is
+        // unknown until the hold is removed. Note 2: This value can be provided
+        // even when temporary hold is set (so that the user can reason about
+        // policy without having to first unset the temporary hold).
+        RetentionExpirationTime string `json:"retentionExpirationTime,omitempty"`
+
+        // SelfLink: The link to this object.
+        SelfLink string `json:"selfLink,omitempty"`
+
+        // Size: Content-Length of the data in bytes.
+        Size uint64 `json:"size,omitempty,string"`
+
+        // StorageClass: Storage class of the object.
+        StorageClass string `json:"storageClass,omitempty"`
+
+        // TemporaryHold: Whether an object is under temporary hold. While this
+        // flag is set to true, the object is protected against deletion and
+        // overwrites. A common use case of this flag is regulatory
+        // investigations where objects need to be retained while the
+        // investigation is ongoing. Note that unlike event-based hold,
+        // temporary hold does not impact retention expiration time of an
+        // object.
+        TemporaryHold bool `json:"temporaryHold,omitempty"`
+
+        // TimeCreated: The creation time of the object in RFC 3339 format.
+        TimeCreated string `json:"timeCreated,omitempty"`
+
+        // TimeDeleted: The deletion time of the object in RFC 3339 format. Will
+        // be returned if and only if this version of the object has been
+        // deleted.
+        TimeDeleted string `json:"timeDeleted,omitempty"`
+
+        // TimeStorageClassUpdated: The time at which the object's storage class
+        // was last changed. When the object is initially created, it will be
+        // set to timeCreated.
+        TimeStorageClassUpdated string `json:"timeStorageClassUpdated,omitempty"`
+
+        // Updated: The modification time of the object metadata in RFC 3339
+        // format.
+        Updated string `json:"updated,omitempty"`
+
+        // ServerResponse contains the HTTP response code and headers from the
+        // server.
+        googleapi.ServerResponse `json:"-"`
+
+        // ForceSendFields is a list of field names (e.g. "Acl") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Acl") to include in API
+        // requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *Object) MarshalJSON() ([]byte, error) {
+        type NoMethod Object
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// ObjectCustomerEncryption: Metadata of customer-supplied encryption
+// key, if the object is encrypted by such a key.
+type ObjectCustomerEncryption struct {
+        // EncryptionAlgorithm: The encryption algorithm.
+        EncryptionAlgorithm string `json:"encryptionAlgorithm,omitempty"`
+
+        // KeySha256: SHA256 hash value of the encryption key.
+        KeySha256 string `json:"keySha256,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "EncryptionAlgorithm")
+        // to unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "EncryptionAlgorithm") to
+        // include in API requests with the JSON null value. By default, fields
+        // with empty values are omitted from API requests. However, any field
+        // with an empty value appearing in NullFields will be sent to the
+        // server as null. It is an error if a field in this list has a
+        // non-empty value. This may be used to include null fields in Patch
+        // requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *ObjectCustomerEncryption) MarshalJSON() ([]byte, error) {
+        type NoMethod ObjectCustomerEncryption
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// ObjectOwner: The owner of the object. This will always be the
+// uploader of the object.
+type ObjectOwner struct {
+        // Entity: The entity, in the form user-userId.
+        Entity string `json:"entity,omitempty"`
+
+        // EntityId: The ID for the entity.
+        EntityId string `json:"entityId,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "Entity") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Entity") to include in API
+        // requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *ObjectOwner) MarshalJSON() ([]byte, error) {
+        type NoMethod ObjectOwner
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// ObjectAccessControl: An access-control entry.
+type ObjectAccessControl struct {
+        // Bucket: The name of the bucket.
+        Bucket string `json:"bucket,omitempty"`
+
+        // Domain: The domain associated with the entity, if any.
+        Domain string `json:"domain,omitempty"`
+
+        // Email: The email address associated with the entity, if any.
+        Email string `json:"email,omitempty"`
+
+        // Entity: The entity holding the permission, in one of the following
+        // forms:
+        // - user-userId
+        // - user-email
+        // - group-groupId
+        // - group-email
+        // - domain-domain
+        // - project-team-projectId
+        // - allUsers
+        // - allAuthenticatedUsers Examples:
+        // - The user liz@example.com would be user-liz@example.com.
+        // - The group example@googlegroups.com would be
+        // group-example@googlegroups.com.
+        // - To refer to all members of the Google Apps for Business domain
+        // example.com, the entity would be domain-example.com.
+        Entity string `json:"entity,omitempty"`
+
+        // EntityId: The ID for the entity, if any.
+        EntityId string `json:"entityId,omitempty"`
+
+        // Etag: HTTP 1.1 Entity tag for the access-control entry.
+        Etag string `json:"etag,omitempty"`
+
+        // Generation: The content generation of the object, if applied to an
+        // object.
+        Generation int64 `json:"generation,omitempty,string"`
+
+        // Id: The ID of the access-control entry.
+        Id string `json:"id,omitempty"`
+
+        // Kind: The kind of item this is. For object access control entries,
+        // this is always storage#objectAccessControl.
+        Kind string `json:"kind,omitempty"`
+
+        // Object: The name of the object, if applied to an object.
+        Object string `json:"object,omitempty"`
+
+        // ProjectTeam: The project team associated with the entity, if any.
+        ProjectTeam *ObjectAccessControlProjectTeam `json:"projectTeam,omitempty"`
+
+        // Role: The access permission for the entity.
+        Role string `json:"role,omitempty"`
+
+        // SelfLink: The link to this access-control entry.
+        SelfLink string `json:"selfLink,omitempty"`
+
+        // ServerResponse contains the HTTP response code and headers from the
+        // server.
+        googleapi.ServerResponse `json:"-"`
+
+        // ForceSendFields is a list of field names (e.g. "Bucket") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Bucket") to include in API
+        // requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *ObjectAccessControl) MarshalJSON() ([]byte, error) {
+        type NoMethod ObjectAccessControl
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// ObjectAccessControlProjectTeam: The project team associated with the
+// entity, if any.
+type ObjectAccessControlProjectTeam struct {
+        // ProjectNumber: The project number.
+        ProjectNumber string `json:"projectNumber,omitempty"`
+
+        // Team: The team.
+        Team string `json:"team,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "ProjectNumber") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "ProjectNumber") to include
+        // in API requests with the JSON null value. By default, fields with
+        // empty values are omitted from API requests. However, any field with
+        // an empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *ObjectAccessControlProjectTeam) MarshalJSON() ([]byte, error) {
+        type NoMethod ObjectAccessControlProjectTeam
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// ObjectAccessControls: An access-control list.
+type ObjectAccessControls struct {
+        // Items: The list of items.
+        Items []*ObjectAccessControl `json:"items,omitempty"`
+
+        // Kind: The kind of item this is. For lists of object access control
+        // entries, this is always storage#objectAccessControls.
+        Kind string `json:"kind,omitempty"`
+
+        // ServerResponse contains the HTTP response code and headers from the
+        // server.
+        googleapi.ServerResponse `json:"-"`
+
+        // ForceSendFields is a list of field names (e.g. "Items") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Items") to include in API
+        // requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *ObjectAccessControls) MarshalJSON() ([]byte, error) {
+        type NoMethod ObjectAccessControls
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// Objects: A list of objects.
+type Objects struct {
+        // Items: The list of items.
+        Items []*Object `json:"items,omitempty"`
+
+        // Kind: The kind of item this is. For lists of objects, this is always
+        // storage#objects.
+        Kind string `json:"kind,omitempty"`
+
+        // NextPageToken: The continuation token, used to page through large
+        // result sets. Provide this value in a subsequent request to return the
+        // next page of results.
+        NextPageToken string `json:"nextPageToken,omitempty"`
+
+        // Prefixes: The list of prefixes of objects matching-but-not-listed up
+        // to and including the requested delimiter.
+        Prefixes []string `json:"prefixes,omitempty"`
+
+        // ServerResponse contains the HTTP response code and headers from the
+        // server.
+        googleapi.ServerResponse `json:"-"`
+
+        // ForceSendFields is a list of field names (e.g. "Items") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Items") to include in API
+        // requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *Objects) MarshalJSON() ([]byte, error) {
+        type NoMethod Objects
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// Policy: A bucket/object IAM policy.
+type Policy struct {
+        // Bindings: An association between a role, which comes with a set of
+        // permissions, and members who may assume that role.
+        Bindings []*PolicyBindings `json:"bindings,omitempty"`
+
+        // Etag: HTTP 1.1  Entity tag for the policy.
+        Etag string `json:"etag,omitempty"`
+
+        // Kind: The kind of item this is. For policies, this is always
+        // storage#policy. This field is ignored on input.
+        Kind string `json:"kind,omitempty"`
+
+        // ResourceId: The ID of the resource to which this policy belongs. Will
+        // be of the form projects/_/buckets/bucket for buckets, and
+        // projects/_/buckets/bucket/objects/object for objects. A specific
+        // generation may be specified by appending #generationNumber to the end
+        // of the object name, e.g.
+        // projects/_/buckets/my-bucket/objects/data.txt#17. The current
+        // generation can be denoted with #0. This field is ignored on input.
+        ResourceId string `json:"resourceId,omitempty"`
+
+        // ServerResponse contains the HTTP response code and headers from the
+        // server.
+        googleapi.ServerResponse `json:"-"`
+
+        // ForceSendFields is a list of field names (e.g. "Bindings") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Bindings") to include in
+        // API requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *Policy) MarshalJSON() ([]byte, error) {
+        type NoMethod Policy
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+type PolicyBindings struct {
+        Condition interface{} `json:"condition,omitempty"`
+
+        // Members: A collection of identifiers for members who may assume the
+        // provided role. Recognized identifiers are as follows:
+        // - allUsers — A special identifier that represents anyone on the
+        // internet; with or without a Google account.
+        // - allAuthenticatedUsers — A special identifier that represents
+        // anyone who is authenticated with a Google account or a service
+        // account.
+        // - user:emailid — An email address that represents a specific
+        // account. For example, user:alice@gmail.com or user:joe@example.com.
+        //
+        // - serviceAccount:emailid — An email address that represents a
+        // service account. For example,
+        // serviceAccount:my-other-app@appspot.gserviceaccount.com .
+        // - group:emailid — An email address that represents a Google group.
+        // For example, group:admins@example.com.
+        // - domain:domain — A Google Apps domain name that represents all the
+        // users of that domain. For example, domain:google.com or
+        // domain:example.com.
+        // - projectOwner:projectid — Owners of the given project. For
+        // example, projectOwner:my-example-project
+        // - projectEditor:projectid — Editors of the given project. For
+        // example, projectEditor:my-example-project
+        // - projectViewer:projectid — Viewers of the given project. For
+        // example, projectViewer:my-example-project
+        Members []string `json:"members,omitempty"`
+
+        // Role: The role to which members belong. Two types of roles are
+        // supported: new IAM roles, which grant permissions that do not map
+        // directly to those provided by ACLs, and legacy IAM roles, which do
+        // map directly to ACL permissions. All roles are of the format
+        // roles/storage.specificRole.
+        // The new IAM roles are:
+        // - roles/storage.admin — Full control of Google Cloud Storage
+        // resources.
+        // - roles/storage.objectViewer — Read-Only access to Google Cloud
+        // Storage objects.
+        // - roles/storage.objectCreator — Access to create objects in Google
+        // Cloud Storage.
+        // - roles/storage.objectAdmin — Full control of Google Cloud Storage
+        // objects.   The legacy IAM roles are:
+        // - roles/storage.legacyObjectReader — Read-only access to objects
+        // without listing. Equivalent to an ACL entry on an object with the
+        // READER role.
+        // - roles/storage.legacyObjectOwner — Read/write access to existing
+        // objects without listing. Equivalent to an ACL entry on an object with
+        // the OWNER role.
+        // - roles/storage.legacyBucketReader — Read access to buckets with
+        // object listing. Equivalent to an ACL entry on a bucket with the
+        // READER role.
+        // - roles/storage.legacyBucketWriter — Read access to buckets with
+        // object listing/creation/deletion. Equivalent to an ACL entry on a
+        // bucket with the WRITER role.
+        // - roles/storage.legacyBucketOwner — Read and write access to
+        // existing buckets with object listing/creation/deletion. Equivalent to
+        // an ACL entry on a bucket with the OWNER role.
+        Role string `json:"role,omitempty"`
+
+        // ForceSendFields is a list of field names (e.g. "Condition") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Condition") to include in
+        // API requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *PolicyBindings) MarshalJSON() ([]byte, error) {
+        type NoMethod PolicyBindings
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// RewriteResponse: A rewrite response.
+type RewriteResponse struct {
+        // Done: true if the copy is finished; otherwise, false if the copy is
+        // in progress. This property is always present in the response.
+        Done bool `json:"done,omitempty"`
+
+        // Kind: The kind of item this is.
+        Kind string `json:"kind,omitempty"`
+
+        // ObjectSize: The total size of the object being copied in bytes. This
+        // property is always present in the response.
+        ObjectSize int64 `json:"objectSize,omitempty,string"`
+
+        // Resource: A resource containing the metadata for the copied-to
+        // object. This property is present in the response only when copying
+        // completes.
+        Resource *Object `json:"resource,omitempty"`
+
+        // RewriteToken: A token to use in subsequent requests to continue
+        // copying data. This token is present in the response only when there
+        // is more data to copy.
+        RewriteToken string `json:"rewriteToken,omitempty"`
+
+        // TotalBytesRewritten: The total bytes written so far, which can be
+        // used to provide a waiting user with a progress indicator. This
+        // property is always present in the response.
+        TotalBytesRewritten int64 `json:"totalBytesRewritten,omitempty,string"`
+
+        // ServerResponse contains the HTTP response code and headers from the
+        // server.
+        googleapi.ServerResponse `json:"-"`
+
+        // ForceSendFields is a list of field names (e.g. "Done") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Done") to include in API
+        // requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *RewriteResponse) MarshalJSON() ([]byte, error) {
+        type NoMethod RewriteResponse
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// ServiceAccount: A subscription to receive Google PubSub
+// notifications.
+type ServiceAccount struct {
+        // EmailAddress: The ID of the notification.
+        EmailAddress string `json:"email_address,omitempty"`
+
+        // Kind: The kind of item this is. For notifications, this is always
+        // storage#notification.
+        Kind string `json:"kind,omitempty"`
+
+        // ServerResponse contains the HTTP response code and headers from the
+        // server.
+        googleapi.ServerResponse `json:"-"`
+
+        // ForceSendFields is a list of field names (e.g. "EmailAddress") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "EmailAddress") to include
+        // in API requests with the JSON null value. By default, fields with
+        // empty values are omitted from API requests. However, any field with
+        // an empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *ServiceAccount) MarshalJSON() ([]byte, error) {
+        type NoMethod ServiceAccount
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// TestIamPermissionsResponse: A
+// storage.(buckets|objects).testIamPermissions response.
+type TestIamPermissionsResponse struct {
+        // Kind: The kind of item this is.
+        Kind string `json:"kind,omitempty"`
+
+        // Permissions: The permissions held by the caller. Permissions are
+        // always of the format storage.resource.capability, where resource is
+        // one of buckets or objects. The supported permissions are as follows:
+        //
+        // - storage.buckets.delete — Delete bucket.
+        // - storage.buckets.get — Read bucket metadata.
+        // - storage.buckets.getIamPolicy — Read bucket IAM policy.
+        // - storage.buckets.create — Create bucket.
+        // - storage.buckets.list — List buckets.
+        // - storage.buckets.setIamPolicy — Update bucket IAM policy.
+        // - storage.buckets.update — Update bucket metadata.
+        // - storage.objects.delete — Delete object.
+        // - storage.objects.get — Read object data and metadata.
+        // - storage.objects.getIamPolicy — Read object IAM policy.
+        // - storage.objects.create — Create object.
+        // - storage.objects.list — List objects.
+        // - storage.objects.setIamPolicy — Update object IAM policy.
+        // - storage.objects.update — Update object metadata.
+        Permissions []string `json:"permissions,omitempty"`
+
+        // ServerResponse contains the HTTP response code and headers from the
+        // server.
+        googleapi.ServerResponse `json:"-"`
+
+        // ForceSendFields is a list of field names (e.g. "Kind") to
+        // unconditionally include in API requests. By default, fields with
+        // empty values are omitted from API requests. However, any non-pointer,
+        // non-interface field appearing in ForceSendFields will be sent to the
+        // server regardless of whether the field is empty or not. This may be
+        // used to include empty fields in Patch requests.
+        ForceSendFields []string `json:"-"`
+
+        // NullFields is a list of field names (e.g. "Kind") to include in API
+        // requests with the JSON null value. By default, fields with empty
+        // values are omitted from API requests. However, any field with an
+        // empty value appearing in NullFields will be sent to the server as
+        // null. It is an error if a field in this list has a non-empty value.
+        // This may be used to include null fields in Patch requests.
+        NullFields []string `json:"-"`
+}
+
+func (s *TestIamPermissionsResponse) MarshalJSON() ([]byte, error) {
+        type NoMethod TestIamPermissionsResponse
+        raw := NoMethod(*s)
+        return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
+}
+
+// method id "storage.bucketAccessControls.delete":
+
+type BucketAccessControlsDeleteCall struct {
+        s          *Service
+        bucket     string
+        entity     string
+        urlParams_ gensupport.URLParams
+        ctx_       context.Context
+        header_    http.Header
+}
+
+// Delete: Permanently deletes the ACL entry for the specified entity on
+// the specified bucket.
+func (r *BucketAccessControlsService) Delete(bucket string, entity string) *BucketAccessControlsDeleteCall {
+        c := &BucketAccessControlsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.entity = entity
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *BucketAccessControlsDeleteCall) UserProject(userProject string) *BucketAccessControlsDeleteCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *BucketAccessControlsDeleteCall) Fields(s ...googleapi.Field) *BucketAccessControlsDeleteCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *BucketAccessControlsDeleteCall) Context(ctx context.Context) *BucketAccessControlsDeleteCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *BucketAccessControlsDeleteCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *BucketAccessControlsDeleteCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/acl/{entity}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("DELETE", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "entity": c.entity,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.bucketAccessControls.delete" call.
+func (c *BucketAccessControlsDeleteCall) Do(opts ...googleapi.CallOption) error {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if err != nil {
+                return err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return err
+        }
+        return nil
+        // {
+        //   "description": "Permanently deletes the ACL entry for the specified entity on the specified bucket.",
+        //   "httpMethod": "DELETE",
+        //   "id": "storage.bucketAccessControls.delete",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "entity"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "entity": {
+        //       "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/acl/{entity}",
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.bucketAccessControls.get":
+
+type BucketAccessControlsGetCall struct {
+        s            *Service
+        bucket       string
+        entity       string
+        urlParams_   gensupport.URLParams
+        ifNoneMatch_ string
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// Get: Returns the ACL entry for the specified entity on the specified
+// bucket.
+func (r *BucketAccessControlsService) Get(bucket string, entity string) *BucketAccessControlsGetCall {
+        c := &BucketAccessControlsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.entity = entity
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *BucketAccessControlsGetCall) UserProject(userProject string) *BucketAccessControlsGetCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *BucketAccessControlsGetCall) Fields(s ...googleapi.Field) *BucketAccessControlsGetCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// IfNoneMatch sets the optional parameter which makes the operation
+// fail if the object's ETag matches the given value. This is useful for
+// getting updates only after the object has changed since the last
+// request. Use googleapi.IsNotModified to check whether the response
+// error from Do is the result of In-None-Match.
+func (c *BucketAccessControlsGetCall) IfNoneMatch(entityTag string) *BucketAccessControlsGetCall {
+        c.ifNoneMatch_ = entityTag
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *BucketAccessControlsGetCall) Context(ctx context.Context) *BucketAccessControlsGetCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *BucketAccessControlsGetCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *BucketAccessControlsGetCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        if c.ifNoneMatch_ != "" {
+                reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
+        }
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/acl/{entity}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("GET", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "entity": c.entity,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.bucketAccessControls.get" call.
+// Exactly one of *BucketAccessControl or error will be non-nil. Any
+// non-2xx status code is an error. Response headers are in either
+// *BucketAccessControl.ServerResponse.Header or (if a response was
+// returned at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *BucketAccessControlsGetCall) Do(opts ...googleapi.CallOption) (*BucketAccessControl, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &BucketAccessControl{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Returns the ACL entry for the specified entity on the specified bucket.",
+        //   "httpMethod": "GET",
+        //   "id": "storage.bucketAccessControls.get",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "entity"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "entity": {
+        //       "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/acl/{entity}",
+        //   "response": {
+        //     "$ref": "BucketAccessControl"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.bucketAccessControls.insert":
+
+type BucketAccessControlsInsertCall struct {
+        s                   *Service
+        bucket              string
+        bucketaccesscontrol *BucketAccessControl
+        urlParams_          gensupport.URLParams
+        ctx_                context.Context
+        header_             http.Header
+}
+
+// Insert: Creates a new ACL entry on the specified bucket.
+func (r *BucketAccessControlsService) Insert(bucket string, bucketaccesscontrol *BucketAccessControl) *BucketAccessControlsInsertCall {
+        c := &BucketAccessControlsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.bucketaccesscontrol = bucketaccesscontrol
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *BucketAccessControlsInsertCall) UserProject(userProject string) *BucketAccessControlsInsertCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *BucketAccessControlsInsertCall) Fields(s ...googleapi.Field) *BucketAccessControlsInsertCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *BucketAccessControlsInsertCall) Context(ctx context.Context) *BucketAccessControlsInsertCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *BucketAccessControlsInsertCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *BucketAccessControlsInsertCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.bucketaccesscontrol)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/acl")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("POST", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.bucketAccessControls.insert" call.
+// Exactly one of *BucketAccessControl or error will be non-nil. Any
+// non-2xx status code is an error. Response headers are in either
+// *BucketAccessControl.ServerResponse.Header or (if a response was
+// returned at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *BucketAccessControlsInsertCall) Do(opts ...googleapi.CallOption) (*BucketAccessControl, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &BucketAccessControl{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Creates a new ACL entry on the specified bucket.",
+        //   "httpMethod": "POST",
+        //   "id": "storage.bucketAccessControls.insert",
+        //   "parameterOrder": [
+        //     "bucket"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/acl",
+        //   "request": {
+        //     "$ref": "BucketAccessControl"
+        //   },
+        //   "response": {
+        //     "$ref": "BucketAccessControl"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.bucketAccessControls.list":
+
+type BucketAccessControlsListCall struct {
+        s            *Service
+        bucket       string
+        urlParams_   gensupport.URLParams
+        ifNoneMatch_ string
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// List: Retrieves ACL entries on the specified bucket.
+func (r *BucketAccessControlsService) List(bucket string) *BucketAccessControlsListCall {
+        c := &BucketAccessControlsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *BucketAccessControlsListCall) UserProject(userProject string) *BucketAccessControlsListCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *BucketAccessControlsListCall) Fields(s ...googleapi.Field) *BucketAccessControlsListCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// IfNoneMatch sets the optional parameter which makes the operation
+// fail if the object's ETag matches the given value. This is useful for
+// getting updates only after the object has changed since the last
+// request. Use googleapi.IsNotModified to check whether the response
+// error from Do is the result of In-None-Match.
+func (c *BucketAccessControlsListCall) IfNoneMatch(entityTag string) *BucketAccessControlsListCall {
+        c.ifNoneMatch_ = entityTag
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *BucketAccessControlsListCall) Context(ctx context.Context) *BucketAccessControlsListCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *BucketAccessControlsListCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *BucketAccessControlsListCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        if c.ifNoneMatch_ != "" {
+                reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
+        }
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/acl")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("GET", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.bucketAccessControls.list" call.
+// Exactly one of *BucketAccessControls or error will be non-nil. Any
+// non-2xx status code is an error. Response headers are in either
+// *BucketAccessControls.ServerResponse.Header or (if a response was
+// returned at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *BucketAccessControlsListCall) Do(opts ...googleapi.CallOption) (*BucketAccessControls, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &BucketAccessControls{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Retrieves ACL entries on the specified bucket.",
+        //   "httpMethod": "GET",
+        //   "id": "storage.bucketAccessControls.list",
+        //   "parameterOrder": [
+        //     "bucket"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/acl",
+        //   "response": {
+        //     "$ref": "BucketAccessControls"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.bucketAccessControls.patch":
+
+type BucketAccessControlsPatchCall struct {
+        s                   *Service
+        bucket              string
+        entity              string
+        bucketaccesscontrol *BucketAccessControl
+        urlParams_          gensupport.URLParams
+        ctx_                context.Context
+        header_             http.Header
+}
+
+// Patch: Patches an ACL entry on the specified bucket.
+func (r *BucketAccessControlsService) Patch(bucket string, entity string, bucketaccesscontrol *BucketAccessControl) *BucketAccessControlsPatchCall {
+        c := &BucketAccessControlsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.entity = entity
+        c.bucketaccesscontrol = bucketaccesscontrol
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *BucketAccessControlsPatchCall) UserProject(userProject string) *BucketAccessControlsPatchCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *BucketAccessControlsPatchCall) Fields(s ...googleapi.Field) *BucketAccessControlsPatchCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *BucketAccessControlsPatchCall) Context(ctx context.Context) *BucketAccessControlsPatchCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *BucketAccessControlsPatchCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *BucketAccessControlsPatchCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.bucketaccesscontrol)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/acl/{entity}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("PATCH", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "entity": c.entity,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.bucketAccessControls.patch" call.
+// Exactly one of *BucketAccessControl or error will be non-nil. Any
+// non-2xx status code is an error. Response headers are in either
+// *BucketAccessControl.ServerResponse.Header or (if a response was
+// returned at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *BucketAccessControlsPatchCall) Do(opts ...googleapi.CallOption) (*BucketAccessControl, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &BucketAccessControl{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Patches an ACL entry on the specified bucket.",
+        //   "httpMethod": "PATCH",
+        //   "id": "storage.bucketAccessControls.patch",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "entity"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "entity": {
+        //       "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/acl/{entity}",
+        //   "request": {
+        //     "$ref": "BucketAccessControl"
+        //   },
+        //   "response": {
+        //     "$ref": "BucketAccessControl"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.bucketAccessControls.update":
+
+type BucketAccessControlsUpdateCall struct {
+        s                   *Service
+        bucket              string
+        entity              string
+        bucketaccesscontrol *BucketAccessControl
+        urlParams_          gensupport.URLParams
+        ctx_                context.Context
+        header_             http.Header
+}
+
+// Update: Updates an ACL entry on the specified bucket.
+func (r *BucketAccessControlsService) Update(bucket string, entity string, bucketaccesscontrol *BucketAccessControl) *BucketAccessControlsUpdateCall {
+        c := &BucketAccessControlsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.entity = entity
+        c.bucketaccesscontrol = bucketaccesscontrol
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *BucketAccessControlsUpdateCall) UserProject(userProject string) *BucketAccessControlsUpdateCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *BucketAccessControlsUpdateCall) Fields(s ...googleapi.Field) *BucketAccessControlsUpdateCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *BucketAccessControlsUpdateCall) Context(ctx context.Context) *BucketAccessControlsUpdateCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *BucketAccessControlsUpdateCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *BucketAccessControlsUpdateCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.bucketaccesscontrol)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/acl/{entity}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("PUT", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "entity": c.entity,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.bucketAccessControls.update" call.
+// Exactly one of *BucketAccessControl or error will be non-nil. Any
+// non-2xx status code is an error. Response headers are in either
+// *BucketAccessControl.ServerResponse.Header or (if a response was
+// returned at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *BucketAccessControlsUpdateCall) Do(opts ...googleapi.CallOption) (*BucketAccessControl, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &BucketAccessControl{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Updates an ACL entry on the specified bucket.",
+        //   "httpMethod": "PUT",
+        //   "id": "storage.bucketAccessControls.update",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "entity"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "entity": {
+        //       "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/acl/{entity}",
+        //   "request": {
+        //     "$ref": "BucketAccessControl"
+        //   },
+        //   "response": {
+        //     "$ref": "BucketAccessControl"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.buckets.delete":
+
+type BucketsDeleteCall struct {
+        s          *Service
+        bucket     string
+        urlParams_ gensupport.URLParams
+        ctx_       context.Context
+        header_    http.Header
+}
+
+// Delete: Permanently deletes an empty bucket.
+func (r *BucketsService) Delete(bucket string) *BucketsDeleteCall {
+        c := &BucketsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        return c
+}
+
+// IfMetagenerationMatch sets the optional parameter
+// "ifMetagenerationMatch": If set, only deletes the bucket if its
+// metageneration matches this value.
+func (c *BucketsDeleteCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *BucketsDeleteCall {
+        c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch))
+        return c
+}
+
+// IfMetagenerationNotMatch sets the optional parameter
+// "ifMetagenerationNotMatch": If set, only deletes the bucket if its
+// metageneration does not match this value.
+func (c *BucketsDeleteCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *BucketsDeleteCall {
+        c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch))
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *BucketsDeleteCall) UserProject(userProject string) *BucketsDeleteCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *BucketsDeleteCall) Fields(s ...googleapi.Field) *BucketsDeleteCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *BucketsDeleteCall) Context(ctx context.Context) *BucketsDeleteCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *BucketsDeleteCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *BucketsDeleteCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("DELETE", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.buckets.delete" call.
+func (c *BucketsDeleteCall) Do(opts ...googleapi.CallOption) error {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if err != nil {
+                return err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return err
+        }
+        return nil
+        // {
+        //   "description": "Permanently deletes an empty bucket.",
+        //   "httpMethod": "DELETE",
+        //   "id": "storage.buckets.delete",
+        //   "parameterOrder": [
+        //     "bucket"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationMatch": {
+        //       "description": "If set, only deletes the bucket if its metageneration matches this value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationNotMatch": {
+        //       "description": "If set, only deletes the bucket if its metageneration does not match this value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}",
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.buckets.get":
+
+type BucketsGetCall struct {
+        s            *Service
+        bucket       string
+        urlParams_   gensupport.URLParams
+        ifNoneMatch_ string
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// Get: Returns metadata for the specified bucket.
+func (r *BucketsService) Get(bucket string) *BucketsGetCall {
+        c := &BucketsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        return c
+}
+
+// IfMetagenerationMatch sets the optional parameter
+// "ifMetagenerationMatch": Makes the return of the bucket metadata
+// conditional on whether the bucket's current metageneration matches
+// the given value.
+func (c *BucketsGetCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *BucketsGetCall {
+        c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch))
+        return c
+}
+
+// IfMetagenerationNotMatch sets the optional parameter
+// "ifMetagenerationNotMatch": Makes the return of the bucket metadata
+// conditional on whether the bucket's current metageneration does not
+// match the given value.
+func (c *BucketsGetCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *BucketsGetCall {
+        c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch))
+        return c
+}
+
+// Projection sets the optional parameter "projection": Set of
+// properties to return. Defaults to noAcl.
+//
+// Possible values:
+//   "full" - Include all properties.
+//   "noAcl" - Omit owner, acl and defaultObjectAcl properties.
+func (c *BucketsGetCall) Projection(projection string) *BucketsGetCall {
+        c.urlParams_.Set("projection", projection)
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *BucketsGetCall) UserProject(userProject string) *BucketsGetCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *BucketsGetCall) Fields(s ...googleapi.Field) *BucketsGetCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// IfNoneMatch sets the optional parameter which makes the operation
+// fail if the object's ETag matches the given value. This is useful for
+// getting updates only after the object has changed since the last
+// request. Use googleapi.IsNotModified to check whether the response
+// error from Do is the result of In-None-Match.
+func (c *BucketsGetCall) IfNoneMatch(entityTag string) *BucketsGetCall {
+        c.ifNoneMatch_ = entityTag
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *BucketsGetCall) Context(ctx context.Context) *BucketsGetCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *BucketsGetCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *BucketsGetCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        if c.ifNoneMatch_ != "" {
+                reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
+        }
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("GET", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.buckets.get" call.
+// Exactly one of *Bucket or error will be non-nil. Any non-2xx status
+// code is an error. Response headers are in either
+// *Bucket.ServerResponse.Header or (if a response was returned at all)
+// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
+// check whether the returned error was because http.StatusNotModified
+// was returned.
+func (c *BucketsGetCall) Do(opts ...googleapi.CallOption) (*Bucket, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Bucket{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Returns metadata for the specified bucket.",
+        //   "httpMethod": "GET",
+        //   "id": "storage.buckets.get",
+        //   "parameterOrder": [
+        //     "bucket"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationMatch": {
+        //       "description": "Makes the return of the bucket metadata conditional on whether the bucket's current metageneration matches the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationNotMatch": {
+        //       "description": "Makes the return of the bucket metadata conditional on whether the bucket's current metageneration does not match the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "projection": {
+        //       "description": "Set of properties to return. Defaults to noAcl.",
+        //       "enum": [
+        //         "full",
+        //         "noAcl"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Include all properties.",
+        //         "Omit owner, acl and defaultObjectAcl properties."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}",
+        //   "response": {
+        //     "$ref": "Bucket"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/cloud-platform.read-only",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_only",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.buckets.getIamPolicy":
+
+type BucketsGetIamPolicyCall struct {
+        s            *Service
+        bucket       string
+        urlParams_   gensupport.URLParams
+        ifNoneMatch_ string
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// GetIamPolicy: Returns an IAM policy for the specified bucket.
+func (r *BucketsService) GetIamPolicy(bucket string) *BucketsGetIamPolicyCall {
+        c := &BucketsGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *BucketsGetIamPolicyCall) UserProject(userProject string) *BucketsGetIamPolicyCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *BucketsGetIamPolicyCall) Fields(s ...googleapi.Field) *BucketsGetIamPolicyCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// IfNoneMatch sets the optional parameter which makes the operation
+// fail if the object's ETag matches the given value. This is useful for
+// getting updates only after the object has changed since the last
+// request. Use googleapi.IsNotModified to check whether the response
+// error from Do is the result of In-None-Match.
+func (c *BucketsGetIamPolicyCall) IfNoneMatch(entityTag string) *BucketsGetIamPolicyCall {
+        c.ifNoneMatch_ = entityTag
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *BucketsGetIamPolicyCall) Context(ctx context.Context) *BucketsGetIamPolicyCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *BucketsGetIamPolicyCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *BucketsGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        if c.ifNoneMatch_ != "" {
+                reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
+        }
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/iam")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("GET", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.buckets.getIamPolicy" call.
+// Exactly one of *Policy or error will be non-nil. Any non-2xx status
+// code is an error. Response headers are in either
+// *Policy.ServerResponse.Header or (if a response was returned at all)
+// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
+// check whether the returned error was because http.StatusNotModified
+// was returned.
+func (c *BucketsGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Policy{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Returns an IAM policy for the specified bucket.",
+        //   "httpMethod": "GET",
+        //   "id": "storage.buckets.getIamPolicy",
+        //   "parameterOrder": [
+        //     "bucket"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/iam",
+        //   "response": {
+        //     "$ref": "Policy"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/cloud-platform.read-only",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_only",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.buckets.insert":
+
+type BucketsInsertCall struct {
+        s          *Service
+        bucket     *Bucket
+        urlParams_ gensupport.URLParams
+        ctx_       context.Context
+        header_    http.Header
+}
+
+// Insert: Creates a new bucket.
+func (r *BucketsService) Insert(projectid string, bucket *Bucket) *BucketsInsertCall {
+        c := &BucketsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.urlParams_.Set("project", projectid)
+        c.bucket = bucket
+        return c
+}
+
+// PredefinedAcl sets the optional parameter "predefinedAcl": Apply a
+// predefined set of access controls to this bucket.
+//
+// Possible values:
+//   "authenticatedRead" - Project team owners get OWNER access, and
+// allAuthenticatedUsers get READER access.
+//   "private" - Project team owners get OWNER access.
+//   "projectPrivate" - Project team members get access according to
+// their roles.
+//   "publicRead" - Project team owners get OWNER access, and allUsers
+// get READER access.
+//   "publicReadWrite" - Project team owners get OWNER access, and
+// allUsers get WRITER access.
+func (c *BucketsInsertCall) PredefinedAcl(predefinedAcl string) *BucketsInsertCall {
+        c.urlParams_.Set("predefinedAcl", predefinedAcl)
+        return c
+}
+
+// PredefinedDefaultObjectAcl sets the optional parameter
+// "predefinedDefaultObjectAcl": Apply a predefined set of default
+// object access controls to this bucket.
+//
+// Possible values:
+//   "authenticatedRead" - Object owner gets OWNER access, and
+// allAuthenticatedUsers get READER access.
+//   "bucketOwnerFullControl" - Object owner gets OWNER access, and
+// project team owners get OWNER access.
+//   "bucketOwnerRead" - Object owner gets OWNER access, and project
+// team owners get READER access.
+//   "private" - Object owner gets OWNER access.
+//   "projectPrivate" - Object owner gets OWNER access, and project team
+// members get access according to their roles.
+//   "publicRead" - Object owner gets OWNER access, and allUsers get
+// READER access.
+func (c *BucketsInsertCall) PredefinedDefaultObjectAcl(predefinedDefaultObjectAcl string) *BucketsInsertCall {
+        c.urlParams_.Set("predefinedDefaultObjectAcl", predefinedDefaultObjectAcl)
+        return c
+}
+
+// Projection sets the optional parameter "projection": Set of
+// properties to return. Defaults to noAcl, unless the bucket resource
+// specifies acl or defaultObjectAcl properties, when it defaults to
+// full.
+//
+// Possible values:
+//   "full" - Include all properties.
+//   "noAcl" - Omit owner, acl and defaultObjectAcl properties.
+func (c *BucketsInsertCall) Projection(projection string) *BucketsInsertCall {
+        c.urlParams_.Set("projection", projection)
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request.
+func (c *BucketsInsertCall) UserProject(userProject string) *BucketsInsertCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *BucketsInsertCall) Fields(s ...googleapi.Field) *BucketsInsertCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *BucketsInsertCall) Context(ctx context.Context) *BucketsInsertCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *BucketsInsertCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *BucketsInsertCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.bucket)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("POST", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.buckets.insert" call.
+// Exactly one of *Bucket or error will be non-nil. Any non-2xx status
+// code is an error. Response headers are in either
+// *Bucket.ServerResponse.Header or (if a response was returned at all)
+// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
+// check whether the returned error was because http.StatusNotModified
+// was returned.
+func (c *BucketsInsertCall) Do(opts ...googleapi.CallOption) (*Bucket, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Bucket{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Creates a new bucket.",
+        //   "httpMethod": "POST",
+        //   "id": "storage.buckets.insert",
+        //   "parameterOrder": [
+        //     "project"
+        //   ],
+        //   "parameters": {
+        //     "predefinedAcl": {
+        //       "description": "Apply a predefined set of access controls to this bucket.",
+        //       "enum": [
+        //         "authenticatedRead",
+        //         "private",
+        //         "projectPrivate",
+        //         "publicRead",
+        //         "publicReadWrite"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Project team owners get OWNER access, and allAuthenticatedUsers get READER access.",
+        //         "Project team owners get OWNER access.",
+        //         "Project team members get access according to their roles.",
+        //         "Project team owners get OWNER access, and allUsers get READER access.",
+        //         "Project team owners get OWNER access, and allUsers get WRITER access."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "predefinedDefaultObjectAcl": {
+        //       "description": "Apply a predefined set of default object access controls to this bucket.",
+        //       "enum": [
+        //         "authenticatedRead",
+        //         "bucketOwnerFullControl",
+        //         "bucketOwnerRead",
+        //         "private",
+        //         "projectPrivate",
+        //         "publicRead"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.",
+        //         "Object owner gets OWNER access, and project team owners get OWNER access.",
+        //         "Object owner gets OWNER access, and project team owners get READER access.",
+        //         "Object owner gets OWNER access.",
+        //         "Object owner gets OWNER access, and project team members get access according to their roles.",
+        //         "Object owner gets OWNER access, and allUsers get READER access."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "project": {
+        //       "description": "A valid API project identifier.",
+        //       "location": "query",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "projection": {
+        //       "description": "Set of properties to return. Defaults to noAcl, unless the bucket resource specifies acl or defaultObjectAcl properties, when it defaults to full.",
+        //       "enum": [
+        //         "full",
+        //         "noAcl"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Include all properties.",
+        //         "Omit owner, acl and defaultObjectAcl properties."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b",
+        //   "request": {
+        //     "$ref": "Bucket"
+        //   },
+        //   "response": {
+        //     "$ref": "Bucket"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.buckets.list":
+
+type BucketsListCall struct {
+        s            *Service
+        urlParams_   gensupport.URLParams
+        ifNoneMatch_ string
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// List: Retrieves a list of buckets for a given project.
+func (r *BucketsService) List(projectid string) *BucketsListCall {
+        c := &BucketsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.urlParams_.Set("project", projectid)
+        return c
+}
+
+// MaxResults sets the optional parameter "maxResults": Maximum number
+// of buckets to return in a single response. The service will use this
+// parameter or 1,000 items, whichever is smaller.
+func (c *BucketsListCall) MaxResults(maxResults int64) *BucketsListCall {
+        c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
+        return c
+}
+
+// PageToken sets the optional parameter "pageToken": A
+// previously-returned page token representing part of the larger set of
+// results to view.
+func (c *BucketsListCall) PageToken(pageToken string) *BucketsListCall {
+        c.urlParams_.Set("pageToken", pageToken)
+        return c
+}
+
+// Prefix sets the optional parameter "prefix": Filter results to
+// buckets whose names begin with this prefix.
+func (c *BucketsListCall) Prefix(prefix string) *BucketsListCall {
+        c.urlParams_.Set("prefix", prefix)
+        return c
+}
+
+// Projection sets the optional parameter "projection": Set of
+// properties to return. Defaults to noAcl.
+//
+// Possible values:
+//   "full" - Include all properties.
+//   "noAcl" - Omit owner, acl and defaultObjectAcl properties.
+func (c *BucketsListCall) Projection(projection string) *BucketsListCall {
+        c.urlParams_.Set("projection", projection)
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request.
+func (c *BucketsListCall) UserProject(userProject string) *BucketsListCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *BucketsListCall) Fields(s ...googleapi.Field) *BucketsListCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// IfNoneMatch sets the optional parameter which makes the operation
+// fail if the object's ETag matches the given value. This is useful for
+// getting updates only after the object has changed since the last
+// request. Use googleapi.IsNotModified to check whether the response
+// error from Do is the result of In-None-Match.
+func (c *BucketsListCall) IfNoneMatch(entityTag string) *BucketsListCall {
+        c.ifNoneMatch_ = entityTag
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *BucketsListCall) Context(ctx context.Context) *BucketsListCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *BucketsListCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *BucketsListCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        if c.ifNoneMatch_ != "" {
+                reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
+        }
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("GET", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.buckets.list" call.
+// Exactly one of *Buckets or error will be non-nil. Any non-2xx status
+// code is an error. Response headers are in either
+// *Buckets.ServerResponse.Header or (if a response was returned at all)
+// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
+// check whether the returned error was because http.StatusNotModified
+// was returned.
+func (c *BucketsListCall) Do(opts ...googleapi.CallOption) (*Buckets, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Buckets{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Retrieves a list of buckets for a given project.",
+        //   "httpMethod": "GET",
+        //   "id": "storage.buckets.list",
+        //   "parameterOrder": [
+        //     "project"
+        //   ],
+        //   "parameters": {
+        //     "maxResults": {
+        //       "default": "1000",
+        //       "description": "Maximum number of buckets to return in a single response. The service will use this parameter or 1,000 items, whichever is smaller.",
+        //       "format": "uint32",
+        //       "location": "query",
+        //       "minimum": "0",
+        //       "type": "integer"
+        //     },
+        //     "pageToken": {
+        //       "description": "A previously-returned page token representing part of the larger set of results to view.",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "prefix": {
+        //       "description": "Filter results to buckets whose names begin with this prefix.",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "project": {
+        //       "description": "A valid API project identifier.",
+        //       "location": "query",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "projection": {
+        //       "description": "Set of properties to return. Defaults to noAcl.",
+        //       "enum": [
+        //         "full",
+        //         "noAcl"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Include all properties.",
+        //         "Omit owner, acl and defaultObjectAcl properties."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b",
+        //   "response": {
+        //     "$ref": "Buckets"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/cloud-platform.read-only",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_only",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// Pages invokes f for each page of results.
+// A non-nil error returned from f will halt the iteration.
+// The provided context supersedes any context provided to the Context method.
+func (c *BucketsListCall) Pages(ctx context.Context, f func(*Buckets) error) error {
+        c.ctx_ = ctx
+        defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point
+        for {
+                x, err := c.Do()
+                if err != nil {
+                        return err
+                }
+                if err := f(x); err != nil {
+                        return err
+                }
+                if x.NextPageToken == "" {
+                        return nil
+                }
+                c.PageToken(x.NextPageToken)
+        }
+}
+
+// method id "storage.buckets.lockRetentionPolicy":
+
+type BucketsLockRetentionPolicyCall struct {
+        s          *Service
+        bucket     string
+        urlParams_ gensupport.URLParams
+        ctx_       context.Context
+        header_    http.Header
+}
+
+// LockRetentionPolicy: Locks retention policy on a bucket.
+func (r *BucketsService) LockRetentionPolicy(bucket string, ifMetagenerationMatch int64) *BucketsLockRetentionPolicyCall {
+        c := &BucketsLockRetentionPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch))
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *BucketsLockRetentionPolicyCall) UserProject(userProject string) *BucketsLockRetentionPolicyCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *BucketsLockRetentionPolicyCall) Fields(s ...googleapi.Field) *BucketsLockRetentionPolicyCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *BucketsLockRetentionPolicyCall) Context(ctx context.Context) *BucketsLockRetentionPolicyCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *BucketsLockRetentionPolicyCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *BucketsLockRetentionPolicyCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/lockRetentionPolicy")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("POST", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.buckets.lockRetentionPolicy" call.
+// Exactly one of *Bucket or error will be non-nil. Any non-2xx status
+// code is an error. Response headers are in either
+// *Bucket.ServerResponse.Header or (if a response was returned at all)
+// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
+// check whether the returned error was because http.StatusNotModified
+// was returned.
+func (c *BucketsLockRetentionPolicyCall) Do(opts ...googleapi.CallOption) (*Bucket, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Bucket{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Locks retention policy on a bucket.",
+        //   "httpMethod": "POST",
+        //   "id": "storage.buckets.lockRetentionPolicy",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "ifMetagenerationMatch"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationMatch": {
+        //       "description": "Makes the operation conditional on whether bucket's current metageneration matches the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/lockRetentionPolicy",
+        //   "response": {
+        //     "$ref": "Bucket"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.buckets.patch":
+
+type BucketsPatchCall struct {
+        s          *Service
+        bucket     string
+        bucket2    *Bucket
+        urlParams_ gensupport.URLParams
+        ctx_       context.Context
+        header_    http.Header
+}
+
+// Patch: Patches a bucket. Changes to the bucket will be readable
+// immediately after writing, but configuration changes may take time to
+// propagate.
+func (r *BucketsService) Patch(bucket string, bucket2 *Bucket) *BucketsPatchCall {
+        c := &BucketsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.bucket2 = bucket2
+        return c
+}
+
+// IfMetagenerationMatch sets the optional parameter
+// "ifMetagenerationMatch": Makes the return of the bucket metadata
+// conditional on whether the bucket's current metageneration matches
+// the given value.
+func (c *BucketsPatchCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *BucketsPatchCall {
+        c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch))
+        return c
+}
+
+// IfMetagenerationNotMatch sets the optional parameter
+// "ifMetagenerationNotMatch": Makes the return of the bucket metadata
+// conditional on whether the bucket's current metageneration does not
+// match the given value.
+func (c *BucketsPatchCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *BucketsPatchCall {
+        c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch))
+        return c
+}
+
+// PredefinedAcl sets the optional parameter "predefinedAcl": Apply a
+// predefined set of access controls to this bucket.
+//
+// Possible values:
+//   "authenticatedRead" - Project team owners get OWNER access, and
+// allAuthenticatedUsers get READER access.
+//   "private" - Project team owners get OWNER access.
+//   "projectPrivate" - Project team members get access according to
+// their roles.
+//   "publicRead" - Project team owners get OWNER access, and allUsers
+// get READER access.
+//   "publicReadWrite" - Project team owners get OWNER access, and
+// allUsers get WRITER access.
+func (c *BucketsPatchCall) PredefinedAcl(predefinedAcl string) *BucketsPatchCall {
+        c.urlParams_.Set("predefinedAcl", predefinedAcl)
+        return c
+}
+
+// PredefinedDefaultObjectAcl sets the optional parameter
+// "predefinedDefaultObjectAcl": Apply a predefined set of default
+// object access controls to this bucket.
+//
+// Possible values:
+//   "authenticatedRead" - Object owner gets OWNER access, and
+// allAuthenticatedUsers get READER access.
+//   "bucketOwnerFullControl" - Object owner gets OWNER access, and
+// project team owners get OWNER access.
+//   "bucketOwnerRead" - Object owner gets OWNER access, and project
+// team owners get READER access.
+//   "private" - Object owner gets OWNER access.
+//   "projectPrivate" - Object owner gets OWNER access, and project team
+// members get access according to their roles.
+//   "publicRead" - Object owner gets OWNER access, and allUsers get
+// READER access.
+func (c *BucketsPatchCall) PredefinedDefaultObjectAcl(predefinedDefaultObjectAcl string) *BucketsPatchCall {
+        c.urlParams_.Set("predefinedDefaultObjectAcl", predefinedDefaultObjectAcl)
+        return c
+}
+
+// Projection sets the optional parameter "projection": Set of
+// properties to return. Defaults to full.
+//
+// Possible values:
+//   "full" - Include all properties.
+//   "noAcl" - Omit owner, acl and defaultObjectAcl properties.
+func (c *BucketsPatchCall) Projection(projection string) *BucketsPatchCall {
+        c.urlParams_.Set("projection", projection)
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *BucketsPatchCall) UserProject(userProject string) *BucketsPatchCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *BucketsPatchCall) Fields(s ...googleapi.Field) *BucketsPatchCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *BucketsPatchCall) Context(ctx context.Context) *BucketsPatchCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *BucketsPatchCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *BucketsPatchCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.bucket2)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("PATCH", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.buckets.patch" call.
+// Exactly one of *Bucket or error will be non-nil. Any non-2xx status
+// code is an error. Response headers are in either
+// *Bucket.ServerResponse.Header or (if a response was returned at all)
+// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
+// check whether the returned error was because http.StatusNotModified
+// was returned.
+func (c *BucketsPatchCall) Do(opts ...googleapi.CallOption) (*Bucket, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Bucket{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Patches a bucket. Changes to the bucket will be readable immediately after writing, but configuration changes may take time to propagate.",
+        //   "httpMethod": "PATCH",
+        //   "id": "storage.buckets.patch",
+        //   "parameterOrder": [
+        //     "bucket"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationMatch": {
+        //       "description": "Makes the return of the bucket metadata conditional on whether the bucket's current metageneration matches the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationNotMatch": {
+        //       "description": "Makes the return of the bucket metadata conditional on whether the bucket's current metageneration does not match the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "predefinedAcl": {
+        //       "description": "Apply a predefined set of access controls to this bucket.",
+        //       "enum": [
+        //         "authenticatedRead",
+        //         "private",
+        //         "projectPrivate",
+        //         "publicRead",
+        //         "publicReadWrite"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Project team owners get OWNER access, and allAuthenticatedUsers get READER access.",
+        //         "Project team owners get OWNER access.",
+        //         "Project team members get access according to their roles.",
+        //         "Project team owners get OWNER access, and allUsers get READER access.",
+        //         "Project team owners get OWNER access, and allUsers get WRITER access."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "predefinedDefaultObjectAcl": {
+        //       "description": "Apply a predefined set of default object access controls to this bucket.",
+        //       "enum": [
+        //         "authenticatedRead",
+        //         "bucketOwnerFullControl",
+        //         "bucketOwnerRead",
+        //         "private",
+        //         "projectPrivate",
+        //         "publicRead"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.",
+        //         "Object owner gets OWNER access, and project team owners get OWNER access.",
+        //         "Object owner gets OWNER access, and project team owners get READER access.",
+        //         "Object owner gets OWNER access.",
+        //         "Object owner gets OWNER access, and project team members get access according to their roles.",
+        //         "Object owner gets OWNER access, and allUsers get READER access."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "projection": {
+        //       "description": "Set of properties to return. Defaults to full.",
+        //       "enum": [
+        //         "full",
+        //         "noAcl"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Include all properties.",
+        //         "Omit owner, acl and defaultObjectAcl properties."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}",
+        //   "request": {
+        //     "$ref": "Bucket"
+        //   },
+        //   "response": {
+        //     "$ref": "Bucket"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.buckets.setIamPolicy":
+
+type BucketsSetIamPolicyCall struct {
+        s          *Service
+        bucket     string
+        policy     *Policy
+        urlParams_ gensupport.URLParams
+        ctx_       context.Context
+        header_    http.Header
+}
+
+// SetIamPolicy: Updates an IAM policy for the specified bucket.
+func (r *BucketsService) SetIamPolicy(bucket string, policy *Policy) *BucketsSetIamPolicyCall {
+        c := &BucketsSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.policy = policy
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *BucketsSetIamPolicyCall) UserProject(userProject string) *BucketsSetIamPolicyCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *BucketsSetIamPolicyCall) Fields(s ...googleapi.Field) *BucketsSetIamPolicyCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *BucketsSetIamPolicyCall) Context(ctx context.Context) *BucketsSetIamPolicyCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *BucketsSetIamPolicyCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *BucketsSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.policy)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/iam")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("PUT", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.buckets.setIamPolicy" call.
+// Exactly one of *Policy or error will be non-nil. Any non-2xx status
+// code is an error. Response headers are in either
+// *Policy.ServerResponse.Header or (if a response was returned at all)
+// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
+// check whether the returned error was because http.StatusNotModified
+// was returned.
+func (c *BucketsSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Policy{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Updates an IAM policy for the specified bucket.",
+        //   "httpMethod": "PUT",
+        //   "id": "storage.buckets.setIamPolicy",
+        //   "parameterOrder": [
+        //     "bucket"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/iam",
+        //   "request": {
+        //     "$ref": "Policy"
+        //   },
+        //   "response": {
+        //     "$ref": "Policy"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.buckets.testIamPermissions":
+
+type BucketsTestIamPermissionsCall struct {
+        s            *Service
+        bucket       string
+        urlParams_   gensupport.URLParams
+        ifNoneMatch_ string
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// TestIamPermissions: Tests a set of permissions on the given bucket to
+// see which, if any, are held by the caller.
+func (r *BucketsService) TestIamPermissions(bucket string, permissions []string) *BucketsTestIamPermissionsCall {
+        c := &BucketsTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.urlParams_.SetMulti("permissions", append([]string{}, permissions...))
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *BucketsTestIamPermissionsCall) UserProject(userProject string) *BucketsTestIamPermissionsCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *BucketsTestIamPermissionsCall) Fields(s ...googleapi.Field) *BucketsTestIamPermissionsCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// IfNoneMatch sets the optional parameter which makes the operation
+// fail if the object's ETag matches the given value. This is useful for
+// getting updates only after the object has changed since the last
+// request. Use googleapi.IsNotModified to check whether the response
+// error from Do is the result of In-None-Match.
+func (c *BucketsTestIamPermissionsCall) IfNoneMatch(entityTag string) *BucketsTestIamPermissionsCall {
+        c.ifNoneMatch_ = entityTag
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *BucketsTestIamPermissionsCall) Context(ctx context.Context) *BucketsTestIamPermissionsCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *BucketsTestIamPermissionsCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *BucketsTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        if c.ifNoneMatch_ != "" {
+                reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
+        }
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/iam/testPermissions")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("GET", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.buckets.testIamPermissions" call.
+// Exactly one of *TestIamPermissionsResponse or error will be non-nil.
+// Any non-2xx status code is an error. Response headers are in either
+// *TestIamPermissionsResponse.ServerResponse.Header or (if a response
+// was returned at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *BucketsTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &TestIamPermissionsResponse{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Tests a set of permissions on the given bucket to see which, if any, are held by the caller.",
+        //   "httpMethod": "GET",
+        //   "id": "storage.buckets.testIamPermissions",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "permissions"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "permissions": {
+        //       "description": "Permissions to test.",
+        //       "location": "query",
+        //       "repeated": true,
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/iam/testPermissions",
+        //   "response": {
+        //     "$ref": "TestIamPermissionsResponse"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/cloud-platform.read-only",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_only",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.buckets.update":
+
+type BucketsUpdateCall struct {
+        s          *Service
+        bucket     string
+        bucket2    *Bucket
+        urlParams_ gensupport.URLParams
+        ctx_       context.Context
+        header_    http.Header
+}
+
+// Update: Updates a bucket. Changes to the bucket will be readable
+// immediately after writing, but configuration changes may take time to
+// propagate.
+func (r *BucketsService) Update(bucket string, bucket2 *Bucket) *BucketsUpdateCall {
+        c := &BucketsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.bucket2 = bucket2
+        return c
+}
+
+// IfMetagenerationMatch sets the optional parameter
+// "ifMetagenerationMatch": Makes the return of the bucket metadata
+// conditional on whether the bucket's current metageneration matches
+// the given value.
+func (c *BucketsUpdateCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *BucketsUpdateCall {
+        c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch))
+        return c
+}
+
+// IfMetagenerationNotMatch sets the optional parameter
+// "ifMetagenerationNotMatch": Makes the return of the bucket metadata
+// conditional on whether the bucket's current metageneration does not
+// match the given value.
+func (c *BucketsUpdateCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *BucketsUpdateCall {
+        c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch))
+        return c
+}
+
+// PredefinedAcl sets the optional parameter "predefinedAcl": Apply a
+// predefined set of access controls to this bucket.
+//
+// Possible values:
+//   "authenticatedRead" - Project team owners get OWNER access, and
+// allAuthenticatedUsers get READER access.
+//   "private" - Project team owners get OWNER access.
+//   "projectPrivate" - Project team members get access according to
+// their roles.
+//   "publicRead" - Project team owners get OWNER access, and allUsers
+// get READER access.
+//   "publicReadWrite" - Project team owners get OWNER access, and
+// allUsers get WRITER access.
+func (c *BucketsUpdateCall) PredefinedAcl(predefinedAcl string) *BucketsUpdateCall {
+        c.urlParams_.Set("predefinedAcl", predefinedAcl)
+        return c
+}
+
+// PredefinedDefaultObjectAcl sets the optional parameter
+// "predefinedDefaultObjectAcl": Apply a predefined set of default
+// object access controls to this bucket.
+//
+// Possible values:
+//   "authenticatedRead" - Object owner gets OWNER access, and
+// allAuthenticatedUsers get READER access.
+//   "bucketOwnerFullControl" - Object owner gets OWNER access, and
+// project team owners get OWNER access.
+//   "bucketOwnerRead" - Object owner gets OWNER access, and project
+// team owners get READER access.
+//   "private" - Object owner gets OWNER access.
+//   "projectPrivate" - Object owner gets OWNER access, and project team
+// members get access according to their roles.
+//   "publicRead" - Object owner gets OWNER access, and allUsers get
+// READER access.
+func (c *BucketsUpdateCall) PredefinedDefaultObjectAcl(predefinedDefaultObjectAcl string) *BucketsUpdateCall {
+        c.urlParams_.Set("predefinedDefaultObjectAcl", predefinedDefaultObjectAcl)
+        return c
+}
+
+// Projection sets the optional parameter "projection": Set of
+// properties to return. Defaults to full.
+//
+// Possible values:
+//   "full" - Include all properties.
+//   "noAcl" - Omit owner, acl and defaultObjectAcl properties.
+func (c *BucketsUpdateCall) Projection(projection string) *BucketsUpdateCall {
+        c.urlParams_.Set("projection", projection)
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *BucketsUpdateCall) UserProject(userProject string) *BucketsUpdateCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *BucketsUpdateCall) Fields(s ...googleapi.Field) *BucketsUpdateCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *BucketsUpdateCall) Context(ctx context.Context) *BucketsUpdateCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *BucketsUpdateCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *BucketsUpdateCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.bucket2)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("PUT", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.buckets.update" call.
+// Exactly one of *Bucket or error will be non-nil. Any non-2xx status
+// code is an error. Response headers are in either
+// *Bucket.ServerResponse.Header or (if a response was returned at all)
+// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
+// check whether the returned error was because http.StatusNotModified
+// was returned.
+func (c *BucketsUpdateCall) Do(opts ...googleapi.CallOption) (*Bucket, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Bucket{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Updates a bucket. Changes to the bucket will be readable immediately after writing, but configuration changes may take time to propagate.",
+        //   "httpMethod": "PUT",
+        //   "id": "storage.buckets.update",
+        //   "parameterOrder": [
+        //     "bucket"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationMatch": {
+        //       "description": "Makes the return of the bucket metadata conditional on whether the bucket's current metageneration matches the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationNotMatch": {
+        //       "description": "Makes the return of the bucket metadata conditional on whether the bucket's current metageneration does not match the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "predefinedAcl": {
+        //       "description": "Apply a predefined set of access controls to this bucket.",
+        //       "enum": [
+        //         "authenticatedRead",
+        //         "private",
+        //         "projectPrivate",
+        //         "publicRead",
+        //         "publicReadWrite"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Project team owners get OWNER access, and allAuthenticatedUsers get READER access.",
+        //         "Project team owners get OWNER access.",
+        //         "Project team members get access according to their roles.",
+        //         "Project team owners get OWNER access, and allUsers get READER access.",
+        //         "Project team owners get OWNER access, and allUsers get WRITER access."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "predefinedDefaultObjectAcl": {
+        //       "description": "Apply a predefined set of default object access controls to this bucket.",
+        //       "enum": [
+        //         "authenticatedRead",
+        //         "bucketOwnerFullControl",
+        //         "bucketOwnerRead",
+        //         "private",
+        //         "projectPrivate",
+        //         "publicRead"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.",
+        //         "Object owner gets OWNER access, and project team owners get OWNER access.",
+        //         "Object owner gets OWNER access, and project team owners get READER access.",
+        //         "Object owner gets OWNER access.",
+        //         "Object owner gets OWNER access, and project team members get access according to their roles.",
+        //         "Object owner gets OWNER access, and allUsers get READER access."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "projection": {
+        //       "description": "Set of properties to return. Defaults to full.",
+        //       "enum": [
+        //         "full",
+        //         "noAcl"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Include all properties.",
+        //         "Omit owner, acl and defaultObjectAcl properties."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}",
+        //   "request": {
+        //     "$ref": "Bucket"
+        //   },
+        //   "response": {
+        //     "$ref": "Bucket"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.channels.stop":
+
+type ChannelsStopCall struct {
+        s          *Service
+        channel    *Channel
+        urlParams_ gensupport.URLParams
+        ctx_       context.Context
+        header_    http.Header
+}
+
+// Stop: Stop watching resources through this channel
+func (r *ChannelsService) Stop(channel *Channel) *ChannelsStopCall {
+        c := &ChannelsStopCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.channel = channel
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ChannelsStopCall) Fields(s ...googleapi.Field) *ChannelsStopCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ChannelsStopCall) Context(ctx context.Context) *ChannelsStopCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ChannelsStopCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ChannelsStopCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.channel)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "channels/stop")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("POST", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.channels.stop" call.
+func (c *ChannelsStopCall) Do(opts ...googleapi.CallOption) error {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if err != nil {
+                return err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return err
+        }
+        return nil
+        // {
+        //   "description": "Stop watching resources through this channel",
+        //   "httpMethod": "POST",
+        //   "id": "storage.channels.stop",
+        //   "path": "channels/stop",
+        //   "request": {
+        //     "$ref": "Channel",
+        //     "parameterName": "resource"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/cloud-platform.read-only",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_only",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.defaultObjectAccessControls.delete":
+
+type DefaultObjectAccessControlsDeleteCall struct {
+        s          *Service
+        bucket     string
+        entity     string
+        urlParams_ gensupport.URLParams
+        ctx_       context.Context
+        header_    http.Header
+}
+
+// Delete: Permanently deletes the default object ACL entry for the
+// specified entity on the specified bucket.
+func (r *DefaultObjectAccessControlsService) Delete(bucket string, entity string) *DefaultObjectAccessControlsDeleteCall {
+        c := &DefaultObjectAccessControlsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.entity = entity
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *DefaultObjectAccessControlsDeleteCall) UserProject(userProject string) *DefaultObjectAccessControlsDeleteCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *DefaultObjectAccessControlsDeleteCall) Fields(s ...googleapi.Field) *DefaultObjectAccessControlsDeleteCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *DefaultObjectAccessControlsDeleteCall) Context(ctx context.Context) *DefaultObjectAccessControlsDeleteCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *DefaultObjectAccessControlsDeleteCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *DefaultObjectAccessControlsDeleteCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/defaultObjectAcl/{entity}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("DELETE", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "entity": c.entity,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.defaultObjectAccessControls.delete" call.
+func (c *DefaultObjectAccessControlsDeleteCall) Do(opts ...googleapi.CallOption) error {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if err != nil {
+                return err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return err
+        }
+        return nil
+        // {
+        //   "description": "Permanently deletes the default object ACL entry for the specified entity on the specified bucket.",
+        //   "httpMethod": "DELETE",
+        //   "id": "storage.defaultObjectAccessControls.delete",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "entity"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "entity": {
+        //       "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/defaultObjectAcl/{entity}",
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.defaultObjectAccessControls.get":
+
+type DefaultObjectAccessControlsGetCall struct {
+        s            *Service
+        bucket       string
+        entity       string
+        urlParams_   gensupport.URLParams
+        ifNoneMatch_ string
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// Get: Returns the default object ACL entry for the specified entity on
+// the specified bucket.
+func (r *DefaultObjectAccessControlsService) Get(bucket string, entity string) *DefaultObjectAccessControlsGetCall {
+        c := &DefaultObjectAccessControlsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.entity = entity
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *DefaultObjectAccessControlsGetCall) UserProject(userProject string) *DefaultObjectAccessControlsGetCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *DefaultObjectAccessControlsGetCall) Fields(s ...googleapi.Field) *DefaultObjectAccessControlsGetCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// IfNoneMatch sets the optional parameter which makes the operation
+// fail if the object's ETag matches the given value. This is useful for
+// getting updates only after the object has changed since the last
+// request. Use googleapi.IsNotModified to check whether the response
+// error from Do is the result of In-None-Match.
+func (c *DefaultObjectAccessControlsGetCall) IfNoneMatch(entityTag string) *DefaultObjectAccessControlsGetCall {
+        c.ifNoneMatch_ = entityTag
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *DefaultObjectAccessControlsGetCall) Context(ctx context.Context) *DefaultObjectAccessControlsGetCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *DefaultObjectAccessControlsGetCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *DefaultObjectAccessControlsGetCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        if c.ifNoneMatch_ != "" {
+                reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
+        }
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/defaultObjectAcl/{entity}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("GET", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "entity": c.entity,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.defaultObjectAccessControls.get" call.
+// Exactly one of *ObjectAccessControl or error will be non-nil. Any
+// non-2xx status code is an error. Response headers are in either
+// *ObjectAccessControl.ServerResponse.Header or (if a response was
+// returned at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *DefaultObjectAccessControlsGetCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControl, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &ObjectAccessControl{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Returns the default object ACL entry for the specified entity on the specified bucket.",
+        //   "httpMethod": "GET",
+        //   "id": "storage.defaultObjectAccessControls.get",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "entity"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "entity": {
+        //       "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/defaultObjectAcl/{entity}",
+        //   "response": {
+        //     "$ref": "ObjectAccessControl"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.defaultObjectAccessControls.insert":
+
+type DefaultObjectAccessControlsInsertCall struct {
+        s                   *Service
+        bucket              string
+        objectaccesscontrol *ObjectAccessControl
+        urlParams_          gensupport.URLParams
+        ctx_                context.Context
+        header_             http.Header
+}
+
+// Insert: Creates a new default object ACL entry on the specified
+// bucket.
+func (r *DefaultObjectAccessControlsService) Insert(bucket string, objectaccesscontrol *ObjectAccessControl) *DefaultObjectAccessControlsInsertCall {
+        c := &DefaultObjectAccessControlsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.objectaccesscontrol = objectaccesscontrol
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *DefaultObjectAccessControlsInsertCall) UserProject(userProject string) *DefaultObjectAccessControlsInsertCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *DefaultObjectAccessControlsInsertCall) Fields(s ...googleapi.Field) *DefaultObjectAccessControlsInsertCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *DefaultObjectAccessControlsInsertCall) Context(ctx context.Context) *DefaultObjectAccessControlsInsertCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *DefaultObjectAccessControlsInsertCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *DefaultObjectAccessControlsInsertCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.objectaccesscontrol)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/defaultObjectAcl")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("POST", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.defaultObjectAccessControls.insert" call.
+// Exactly one of *ObjectAccessControl or error will be non-nil. Any
+// non-2xx status code is an error. Response headers are in either
+// *ObjectAccessControl.ServerResponse.Header or (if a response was
+// returned at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *DefaultObjectAccessControlsInsertCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControl, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &ObjectAccessControl{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Creates a new default object ACL entry on the specified bucket.",
+        //   "httpMethod": "POST",
+        //   "id": "storage.defaultObjectAccessControls.insert",
+        //   "parameterOrder": [
+        //     "bucket"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/defaultObjectAcl",
+        //   "request": {
+        //     "$ref": "ObjectAccessControl"
+        //   },
+        //   "response": {
+        //     "$ref": "ObjectAccessControl"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.defaultObjectAccessControls.list":
+
+type DefaultObjectAccessControlsListCall struct {
+        s            *Service
+        bucket       string
+        urlParams_   gensupport.URLParams
+        ifNoneMatch_ string
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// List: Retrieves default object ACL entries on the specified bucket.
+func (r *DefaultObjectAccessControlsService) List(bucket string) *DefaultObjectAccessControlsListCall {
+        c := &DefaultObjectAccessControlsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        return c
+}
+
+// IfMetagenerationMatch sets the optional parameter
+// "ifMetagenerationMatch": If present, only return default ACL listing
+// if the bucket's current metageneration matches this value.
+func (c *DefaultObjectAccessControlsListCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *DefaultObjectAccessControlsListCall {
+        c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch))
+        return c
+}
+
+// IfMetagenerationNotMatch sets the optional parameter
+// "ifMetagenerationNotMatch": If present, only return default ACL
+// listing if the bucket's current metageneration does not match the
+// given value.
+func (c *DefaultObjectAccessControlsListCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *DefaultObjectAccessControlsListCall {
+        c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch))
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *DefaultObjectAccessControlsListCall) UserProject(userProject string) *DefaultObjectAccessControlsListCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *DefaultObjectAccessControlsListCall) Fields(s ...googleapi.Field) *DefaultObjectAccessControlsListCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// IfNoneMatch sets the optional parameter which makes the operation
+// fail if the object's ETag matches the given value. This is useful for
+// getting updates only after the object has changed since the last
+// request. Use googleapi.IsNotModified to check whether the response
+// error from Do is the result of In-None-Match.
+func (c *DefaultObjectAccessControlsListCall) IfNoneMatch(entityTag string) *DefaultObjectAccessControlsListCall {
+        c.ifNoneMatch_ = entityTag
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *DefaultObjectAccessControlsListCall) Context(ctx context.Context) *DefaultObjectAccessControlsListCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *DefaultObjectAccessControlsListCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *DefaultObjectAccessControlsListCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        if c.ifNoneMatch_ != "" {
+                reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
+        }
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/defaultObjectAcl")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("GET", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.defaultObjectAccessControls.list" call.
+// Exactly one of *ObjectAccessControls or error will be non-nil. Any
+// non-2xx status code is an error. Response headers are in either
+// *ObjectAccessControls.ServerResponse.Header or (if a response was
+// returned at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *DefaultObjectAccessControlsListCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControls, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &ObjectAccessControls{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Retrieves default object ACL entries on the specified bucket.",
+        //   "httpMethod": "GET",
+        //   "id": "storage.defaultObjectAccessControls.list",
+        //   "parameterOrder": [
+        //     "bucket"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationMatch": {
+        //       "description": "If present, only return default ACL listing if the bucket's current metageneration matches this value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationNotMatch": {
+        //       "description": "If present, only return default ACL listing if the bucket's current metageneration does not match the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/defaultObjectAcl",
+        //   "response": {
+        //     "$ref": "ObjectAccessControls"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.defaultObjectAccessControls.patch":
+
+type DefaultObjectAccessControlsPatchCall struct {
+        s                   *Service
+        bucket              string
+        entity              string
+        objectaccesscontrol *ObjectAccessControl
+        urlParams_          gensupport.URLParams
+        ctx_                context.Context
+        header_             http.Header
+}
+
+// Patch: Patches a default object ACL entry on the specified bucket.
+func (r *DefaultObjectAccessControlsService) Patch(bucket string, entity string, objectaccesscontrol *ObjectAccessControl) *DefaultObjectAccessControlsPatchCall {
+        c := &DefaultObjectAccessControlsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.entity = entity
+        c.objectaccesscontrol = objectaccesscontrol
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *DefaultObjectAccessControlsPatchCall) UserProject(userProject string) *DefaultObjectAccessControlsPatchCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *DefaultObjectAccessControlsPatchCall) Fields(s ...googleapi.Field) *DefaultObjectAccessControlsPatchCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *DefaultObjectAccessControlsPatchCall) Context(ctx context.Context) *DefaultObjectAccessControlsPatchCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *DefaultObjectAccessControlsPatchCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *DefaultObjectAccessControlsPatchCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.objectaccesscontrol)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/defaultObjectAcl/{entity}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("PATCH", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "entity": c.entity,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.defaultObjectAccessControls.patch" call.
+// Exactly one of *ObjectAccessControl or error will be non-nil. Any
+// non-2xx status code is an error. Response headers are in either
+// *ObjectAccessControl.ServerResponse.Header or (if a response was
+// returned at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *DefaultObjectAccessControlsPatchCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControl, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &ObjectAccessControl{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Patches a default object ACL entry on the specified bucket.",
+        //   "httpMethod": "PATCH",
+        //   "id": "storage.defaultObjectAccessControls.patch",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "entity"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "entity": {
+        //       "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/defaultObjectAcl/{entity}",
+        //   "request": {
+        //     "$ref": "ObjectAccessControl"
+        //   },
+        //   "response": {
+        //     "$ref": "ObjectAccessControl"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.defaultObjectAccessControls.update":
+
+type DefaultObjectAccessControlsUpdateCall struct {
+        s                   *Service
+        bucket              string
+        entity              string
+        objectaccesscontrol *ObjectAccessControl
+        urlParams_          gensupport.URLParams
+        ctx_                context.Context
+        header_             http.Header
+}
+
+// Update: Updates a default object ACL entry on the specified bucket.
+func (r *DefaultObjectAccessControlsService) Update(bucket string, entity string, objectaccesscontrol *ObjectAccessControl) *DefaultObjectAccessControlsUpdateCall {
+        c := &DefaultObjectAccessControlsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.entity = entity
+        c.objectaccesscontrol = objectaccesscontrol
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *DefaultObjectAccessControlsUpdateCall) UserProject(userProject string) *DefaultObjectAccessControlsUpdateCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *DefaultObjectAccessControlsUpdateCall) Fields(s ...googleapi.Field) *DefaultObjectAccessControlsUpdateCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *DefaultObjectAccessControlsUpdateCall) Context(ctx context.Context) *DefaultObjectAccessControlsUpdateCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *DefaultObjectAccessControlsUpdateCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *DefaultObjectAccessControlsUpdateCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.objectaccesscontrol)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/defaultObjectAcl/{entity}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("PUT", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "entity": c.entity,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.defaultObjectAccessControls.update" call.
+// Exactly one of *ObjectAccessControl or error will be non-nil. Any
+// non-2xx status code is an error. Response headers are in either
+// *ObjectAccessControl.ServerResponse.Header or (if a response was
+// returned at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *DefaultObjectAccessControlsUpdateCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControl, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &ObjectAccessControl{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Updates a default object ACL entry on the specified bucket.",
+        //   "httpMethod": "PUT",
+        //   "id": "storage.defaultObjectAccessControls.update",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "entity"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "entity": {
+        //       "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/defaultObjectAcl/{entity}",
+        //   "request": {
+        //     "$ref": "ObjectAccessControl"
+        //   },
+        //   "response": {
+        //     "$ref": "ObjectAccessControl"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.notifications.delete":
+
+type NotificationsDeleteCall struct {
+        s            *Service
+        bucket       string
+        notification string
+        urlParams_   gensupport.URLParams
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// Delete: Permanently deletes a notification subscription.
+func (r *NotificationsService) Delete(bucket string, notification string) *NotificationsDeleteCall {
+        c := &NotificationsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.notification = notification
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *NotificationsDeleteCall) UserProject(userProject string) *NotificationsDeleteCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *NotificationsDeleteCall) Fields(s ...googleapi.Field) *NotificationsDeleteCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *NotificationsDeleteCall) Context(ctx context.Context) *NotificationsDeleteCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *NotificationsDeleteCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *NotificationsDeleteCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/notificationConfigs/{notification}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("DELETE", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket":       c.bucket,
+                "notification": c.notification,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.notifications.delete" call.
+func (c *NotificationsDeleteCall) Do(opts ...googleapi.CallOption) error {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if err != nil {
+                return err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return err
+        }
+        return nil
+        // {
+        //   "description": "Permanently deletes a notification subscription.",
+        //   "httpMethod": "DELETE",
+        //   "id": "storage.notifications.delete",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "notification"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "The parent bucket of the notification.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "notification": {
+        //       "description": "ID of the notification to delete.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/notificationConfigs/{notification}",
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.notifications.get":
+
+type NotificationsGetCall struct {
+        s            *Service
+        bucket       string
+        notification string
+        urlParams_   gensupport.URLParams
+        ifNoneMatch_ string
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// Get: View a notification configuration.
+func (r *NotificationsService) Get(bucket string, notification string) *NotificationsGetCall {
+        c := &NotificationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.notification = notification
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *NotificationsGetCall) UserProject(userProject string) *NotificationsGetCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *NotificationsGetCall) Fields(s ...googleapi.Field) *NotificationsGetCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// IfNoneMatch sets the optional parameter which makes the operation
+// fail if the object's ETag matches the given value. This is useful for
+// getting updates only after the object has changed since the last
+// request. Use googleapi.IsNotModified to check whether the response
+// error from Do is the result of In-None-Match.
+func (c *NotificationsGetCall) IfNoneMatch(entityTag string) *NotificationsGetCall {
+        c.ifNoneMatch_ = entityTag
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *NotificationsGetCall) Context(ctx context.Context) *NotificationsGetCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *NotificationsGetCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *NotificationsGetCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        if c.ifNoneMatch_ != "" {
+                reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
+        }
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/notificationConfigs/{notification}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("GET", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket":       c.bucket,
+                "notification": c.notification,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.notifications.get" call.
+// Exactly one of *Notification or error will be non-nil. Any non-2xx
+// status code is an error. Response headers are in either
+// *Notification.ServerResponse.Header or (if a response was returned at
+// all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified
+// to check whether the returned error was because
+// http.StatusNotModified was returned.
+func (c *NotificationsGetCall) Do(opts ...googleapi.CallOption) (*Notification, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Notification{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "View a notification configuration.",
+        //   "httpMethod": "GET",
+        //   "id": "storage.notifications.get",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "notification"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "The parent bucket of the notification.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "notification": {
+        //       "description": "Notification ID",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/notificationConfigs/{notification}",
+        //   "response": {
+        //     "$ref": "Notification"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/cloud-platform.read-only",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_only",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.notifications.insert":
+
+type NotificationsInsertCall struct {
+        s            *Service
+        bucket       string
+        notification *Notification
+        urlParams_   gensupport.URLParams
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// Insert: Creates a notification subscription for a given bucket.
+func (r *NotificationsService) Insert(bucket string, notification *Notification) *NotificationsInsertCall {
+        c := &NotificationsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.notification = notification
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *NotificationsInsertCall) UserProject(userProject string) *NotificationsInsertCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *NotificationsInsertCall) Fields(s ...googleapi.Field) *NotificationsInsertCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *NotificationsInsertCall) Context(ctx context.Context) *NotificationsInsertCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *NotificationsInsertCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *NotificationsInsertCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.notification)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/notificationConfigs")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("POST", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.notifications.insert" call.
+// Exactly one of *Notification or error will be non-nil. Any non-2xx
+// status code is an error. Response headers are in either
+// *Notification.ServerResponse.Header or (if a response was returned at
+// all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified
+// to check whether the returned error was because
+// http.StatusNotModified was returned.
+func (c *NotificationsInsertCall) Do(opts ...googleapi.CallOption) (*Notification, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Notification{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Creates a notification subscription for a given bucket.",
+        //   "httpMethod": "POST",
+        //   "id": "storage.notifications.insert",
+        //   "parameterOrder": [
+        //     "bucket"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "The parent bucket of the notification.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/notificationConfigs",
+        //   "request": {
+        //     "$ref": "Notification"
+        //   },
+        //   "response": {
+        //     "$ref": "Notification"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.notifications.list":
+
+type NotificationsListCall struct {
+        s            *Service
+        bucket       string
+        urlParams_   gensupport.URLParams
+        ifNoneMatch_ string
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// List: Retrieves a list of notification subscriptions for a given
+// bucket.
+func (r *NotificationsService) List(bucket string) *NotificationsListCall {
+        c := &NotificationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *NotificationsListCall) UserProject(userProject string) *NotificationsListCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *NotificationsListCall) Fields(s ...googleapi.Field) *NotificationsListCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// IfNoneMatch sets the optional parameter which makes the operation
+// fail if the object's ETag matches the given value. This is useful for
+// getting updates only after the object has changed since the last
+// request. Use googleapi.IsNotModified to check whether the response
+// error from Do is the result of In-None-Match.
+func (c *NotificationsListCall) IfNoneMatch(entityTag string) *NotificationsListCall {
+        c.ifNoneMatch_ = entityTag
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *NotificationsListCall) Context(ctx context.Context) *NotificationsListCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *NotificationsListCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *NotificationsListCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        if c.ifNoneMatch_ != "" {
+                reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
+        }
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/notificationConfigs")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("GET", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.notifications.list" call.
+// Exactly one of *Notifications or error will be non-nil. Any non-2xx
+// status code is an error. Response headers are in either
+// *Notifications.ServerResponse.Header or (if a response was returned
+// at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *NotificationsListCall) Do(opts ...googleapi.CallOption) (*Notifications, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Notifications{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Retrieves a list of notification subscriptions for a given bucket.",
+        //   "httpMethod": "GET",
+        //   "id": "storage.notifications.list",
+        //   "parameterOrder": [
+        //     "bucket"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a Google Cloud Storage bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/notificationConfigs",
+        //   "response": {
+        //     "$ref": "Notifications"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/cloud-platform.read-only",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_only",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.objectAccessControls.delete":
+
+type ObjectAccessControlsDeleteCall struct {
+        s          *Service
+        bucket     string
+        object     string
+        entity     string
+        urlParams_ gensupport.URLParams
+        ctx_       context.Context
+        header_    http.Header
+}
+
+// Delete: Permanently deletes the ACL entry for the specified entity on
+// the specified object.
+func (r *ObjectAccessControlsService) Delete(bucket string, object string, entity string) *ObjectAccessControlsDeleteCall {
+        c := &ObjectAccessControlsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.object = object
+        c.entity = entity
+        return c
+}
+
+// Generation sets the optional parameter "generation": If present,
+// selects a specific revision of this object (as opposed to the latest
+// version, the default).
+func (c *ObjectAccessControlsDeleteCall) Generation(generation int64) *ObjectAccessControlsDeleteCall {
+        c.urlParams_.Set("generation", fmt.Sprint(generation))
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *ObjectAccessControlsDeleteCall) UserProject(userProject string) *ObjectAccessControlsDeleteCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectAccessControlsDeleteCall) Fields(s ...googleapi.Field) *ObjectAccessControlsDeleteCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ObjectAccessControlsDeleteCall) Context(ctx context.Context) *ObjectAccessControlsDeleteCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectAccessControlsDeleteCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectAccessControlsDeleteCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}/acl/{entity}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("DELETE", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "object": c.object,
+                "entity": c.entity,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.objectAccessControls.delete" call.
+func (c *ObjectAccessControlsDeleteCall) Do(opts ...googleapi.CallOption) error {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if err != nil {
+                return err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return err
+        }
+        return nil
+        // {
+        //   "description": "Permanently deletes the ACL entry for the specified entity on the specified object.",
+        //   "httpMethod": "DELETE",
+        //   "id": "storage.objectAccessControls.delete",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "object",
+        //     "entity"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "entity": {
+        //       "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "generation": {
+        //       "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "object": {
+        //       "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/o/{object}/acl/{entity}",
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.objectAccessControls.get":
+
+type ObjectAccessControlsGetCall struct {
+        s            *Service
+        bucket       string
+        object       string
+        entity       string
+        urlParams_   gensupport.URLParams
+        ifNoneMatch_ string
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// Get: Returns the ACL entry for the specified entity on the specified
+// object.
+func (r *ObjectAccessControlsService) Get(bucket string, object string, entity string) *ObjectAccessControlsGetCall {
+        c := &ObjectAccessControlsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.object = object
+        c.entity = entity
+        return c
+}
+
+// Generation sets the optional parameter "generation": If present,
+// selects a specific revision of this object (as opposed to the latest
+// version, the default).
+func (c *ObjectAccessControlsGetCall) Generation(generation int64) *ObjectAccessControlsGetCall {
+        c.urlParams_.Set("generation", fmt.Sprint(generation))
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *ObjectAccessControlsGetCall) UserProject(userProject string) *ObjectAccessControlsGetCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectAccessControlsGetCall) Fields(s ...googleapi.Field) *ObjectAccessControlsGetCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// IfNoneMatch sets the optional parameter which makes the operation
+// fail if the object's ETag matches the given value. This is useful for
+// getting updates only after the object has changed since the last
+// request. Use googleapi.IsNotModified to check whether the response
+// error from Do is the result of In-None-Match.
+func (c *ObjectAccessControlsGetCall) IfNoneMatch(entityTag string) *ObjectAccessControlsGetCall {
+        c.ifNoneMatch_ = entityTag
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ObjectAccessControlsGetCall) Context(ctx context.Context) *ObjectAccessControlsGetCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectAccessControlsGetCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectAccessControlsGetCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        if c.ifNoneMatch_ != "" {
+                reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
+        }
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}/acl/{entity}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("GET", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "object": c.object,
+                "entity": c.entity,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.objectAccessControls.get" call.
+// Exactly one of *ObjectAccessControl or error will be non-nil. Any
+// non-2xx status code is an error. Response headers are in either
+// *ObjectAccessControl.ServerResponse.Header or (if a response was
+// returned at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *ObjectAccessControlsGetCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControl, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &ObjectAccessControl{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Returns the ACL entry for the specified entity on the specified object.",
+        //   "httpMethod": "GET",
+        //   "id": "storage.objectAccessControls.get",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "object",
+        //     "entity"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "entity": {
+        //       "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "generation": {
+        //       "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "object": {
+        //       "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/o/{object}/acl/{entity}",
+        //   "response": {
+        //     "$ref": "ObjectAccessControl"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.objectAccessControls.insert":
+
+type ObjectAccessControlsInsertCall struct {
+        s                   *Service
+        bucket              string
+        object              string
+        objectaccesscontrol *ObjectAccessControl
+        urlParams_          gensupport.URLParams
+        ctx_                context.Context
+        header_             http.Header
+}
+
+// Insert: Creates a new ACL entry on the specified object.
+func (r *ObjectAccessControlsService) Insert(bucket string, object string, objectaccesscontrol *ObjectAccessControl) *ObjectAccessControlsInsertCall {
+        c := &ObjectAccessControlsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.object = object
+        c.objectaccesscontrol = objectaccesscontrol
+        return c
+}
+
+// Generation sets the optional parameter "generation": If present,
+// selects a specific revision of this object (as opposed to the latest
+// version, the default).
+func (c *ObjectAccessControlsInsertCall) Generation(generation int64) *ObjectAccessControlsInsertCall {
+        c.urlParams_.Set("generation", fmt.Sprint(generation))
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *ObjectAccessControlsInsertCall) UserProject(userProject string) *ObjectAccessControlsInsertCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectAccessControlsInsertCall) Fields(s ...googleapi.Field) *ObjectAccessControlsInsertCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ObjectAccessControlsInsertCall) Context(ctx context.Context) *ObjectAccessControlsInsertCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectAccessControlsInsertCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectAccessControlsInsertCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.objectaccesscontrol)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}/acl")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("POST", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "object": c.object,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.objectAccessControls.insert" call.
+// Exactly one of *ObjectAccessControl or error will be non-nil. Any
+// non-2xx status code is an error. Response headers are in either
+// *ObjectAccessControl.ServerResponse.Header or (if a response was
+// returned at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *ObjectAccessControlsInsertCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControl, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &ObjectAccessControl{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Creates a new ACL entry on the specified object.",
+        //   "httpMethod": "POST",
+        //   "id": "storage.objectAccessControls.insert",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "object"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "generation": {
+        //       "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "object": {
+        //       "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/o/{object}/acl",
+        //   "request": {
+        //     "$ref": "ObjectAccessControl"
+        //   },
+        //   "response": {
+        //     "$ref": "ObjectAccessControl"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.objectAccessControls.list":
+
+type ObjectAccessControlsListCall struct {
+        s            *Service
+        bucket       string
+        object       string
+        urlParams_   gensupport.URLParams
+        ifNoneMatch_ string
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// List: Retrieves ACL entries on the specified object.
+func (r *ObjectAccessControlsService) List(bucket string, object string) *ObjectAccessControlsListCall {
+        c := &ObjectAccessControlsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.object = object
+        return c
+}
+
+// Generation sets the optional parameter "generation": If present,
+// selects a specific revision of this object (as opposed to the latest
+// version, the default).
+func (c *ObjectAccessControlsListCall) Generation(generation int64) *ObjectAccessControlsListCall {
+        c.urlParams_.Set("generation", fmt.Sprint(generation))
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *ObjectAccessControlsListCall) UserProject(userProject string) *ObjectAccessControlsListCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectAccessControlsListCall) Fields(s ...googleapi.Field) *ObjectAccessControlsListCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// IfNoneMatch sets the optional parameter which makes the operation
+// fail if the object's ETag matches the given value. This is useful for
+// getting updates only after the object has changed since the last
+// request. Use googleapi.IsNotModified to check whether the response
+// error from Do is the result of In-None-Match.
+func (c *ObjectAccessControlsListCall) IfNoneMatch(entityTag string) *ObjectAccessControlsListCall {
+        c.ifNoneMatch_ = entityTag
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ObjectAccessControlsListCall) Context(ctx context.Context) *ObjectAccessControlsListCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectAccessControlsListCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectAccessControlsListCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        if c.ifNoneMatch_ != "" {
+                reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
+        }
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}/acl")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("GET", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "object": c.object,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.objectAccessControls.list" call.
+// Exactly one of *ObjectAccessControls or error will be non-nil. Any
+// non-2xx status code is an error. Response headers are in either
+// *ObjectAccessControls.ServerResponse.Header or (if a response was
+// returned at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *ObjectAccessControlsListCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControls, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &ObjectAccessControls{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Retrieves ACL entries on the specified object.",
+        //   "httpMethod": "GET",
+        //   "id": "storage.objectAccessControls.list",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "object"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "generation": {
+        //       "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "object": {
+        //       "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/o/{object}/acl",
+        //   "response": {
+        //     "$ref": "ObjectAccessControls"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.objectAccessControls.patch":
+
+type ObjectAccessControlsPatchCall struct {
+        s                   *Service
+        bucket              string
+        object              string
+        entity              string
+        objectaccesscontrol *ObjectAccessControl
+        urlParams_          gensupport.URLParams
+        ctx_                context.Context
+        header_             http.Header
+}
+
+// Patch: Patches an ACL entry on the specified object.
+func (r *ObjectAccessControlsService) Patch(bucket string, object string, entity string, objectaccesscontrol *ObjectAccessControl) *ObjectAccessControlsPatchCall {
+        c := &ObjectAccessControlsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.object = object
+        c.entity = entity
+        c.objectaccesscontrol = objectaccesscontrol
+        return c
+}
+
+// Generation sets the optional parameter "generation": If present,
+// selects a specific revision of this object (as opposed to the latest
+// version, the default).
+func (c *ObjectAccessControlsPatchCall) Generation(generation int64) *ObjectAccessControlsPatchCall {
+        c.urlParams_.Set("generation", fmt.Sprint(generation))
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *ObjectAccessControlsPatchCall) UserProject(userProject string) *ObjectAccessControlsPatchCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectAccessControlsPatchCall) Fields(s ...googleapi.Field) *ObjectAccessControlsPatchCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ObjectAccessControlsPatchCall) Context(ctx context.Context) *ObjectAccessControlsPatchCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectAccessControlsPatchCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectAccessControlsPatchCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.objectaccesscontrol)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}/acl/{entity}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("PATCH", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "object": c.object,
+                "entity": c.entity,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.objectAccessControls.patch" call.
+// Exactly one of *ObjectAccessControl or error will be non-nil. Any
+// non-2xx status code is an error. Response headers are in either
+// *ObjectAccessControl.ServerResponse.Header or (if a response was
+// returned at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *ObjectAccessControlsPatchCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControl, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &ObjectAccessControl{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Patches an ACL entry on the specified object.",
+        //   "httpMethod": "PATCH",
+        //   "id": "storage.objectAccessControls.patch",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "object",
+        //     "entity"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "entity": {
+        //       "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "generation": {
+        //       "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "object": {
+        //       "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/o/{object}/acl/{entity}",
+        //   "request": {
+        //     "$ref": "ObjectAccessControl"
+        //   },
+        //   "response": {
+        //     "$ref": "ObjectAccessControl"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.objectAccessControls.update":
+
+type ObjectAccessControlsUpdateCall struct {
+        s                   *Service
+        bucket              string
+        object              string
+        entity              string
+        objectaccesscontrol *ObjectAccessControl
+        urlParams_          gensupport.URLParams
+        ctx_                context.Context
+        header_             http.Header
+}
+
+// Update: Updates an ACL entry on the specified object.
+func (r *ObjectAccessControlsService) Update(bucket string, object string, entity string, objectaccesscontrol *ObjectAccessControl) *ObjectAccessControlsUpdateCall {
+        c := &ObjectAccessControlsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.object = object
+        c.entity = entity
+        c.objectaccesscontrol = objectaccesscontrol
+        return c
+}
+
+// Generation sets the optional parameter "generation": If present,
+// selects a specific revision of this object (as opposed to the latest
+// version, the default).
+func (c *ObjectAccessControlsUpdateCall) Generation(generation int64) *ObjectAccessControlsUpdateCall {
+        c.urlParams_.Set("generation", fmt.Sprint(generation))
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *ObjectAccessControlsUpdateCall) UserProject(userProject string) *ObjectAccessControlsUpdateCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectAccessControlsUpdateCall) Fields(s ...googleapi.Field) *ObjectAccessControlsUpdateCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ObjectAccessControlsUpdateCall) Context(ctx context.Context) *ObjectAccessControlsUpdateCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectAccessControlsUpdateCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectAccessControlsUpdateCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.objectaccesscontrol)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}/acl/{entity}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("PUT", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "object": c.object,
+                "entity": c.entity,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.objectAccessControls.update" call.
+// Exactly one of *ObjectAccessControl or error will be non-nil. Any
+// non-2xx status code is an error. Response headers are in either
+// *ObjectAccessControl.ServerResponse.Header or (if a response was
+// returned at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *ObjectAccessControlsUpdateCall) Do(opts ...googleapi.CallOption) (*ObjectAccessControl, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &ObjectAccessControl{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Updates an ACL entry on the specified object.",
+        //   "httpMethod": "PUT",
+        //   "id": "storage.objectAccessControls.update",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "object",
+        //     "entity"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of a bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "entity": {
+        //       "description": "The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "generation": {
+        //       "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "object": {
+        //       "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/o/{object}/acl/{entity}",
+        //   "request": {
+        //     "$ref": "ObjectAccessControl"
+        //   },
+        //   "response": {
+        //     "$ref": "ObjectAccessControl"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.objects.compose":
+
+type ObjectsComposeCall struct {
+        s                 *Service
+        destinationBucket string
+        destinationObject string
+        composerequest    *ComposeRequest
+        urlParams_        gensupport.URLParams
+        ctx_              context.Context
+        header_           http.Header
+}
+
+// Compose: Concatenates a list of existing objects into a new object in
+// the same bucket.
+func (r *ObjectsService) Compose(destinationBucket string, destinationObject string, composerequest *ComposeRequest) *ObjectsComposeCall {
+        c := &ObjectsComposeCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.destinationBucket = destinationBucket
+        c.destinationObject = destinationObject
+        c.composerequest = composerequest
+        return c
+}
+
+// DestinationPredefinedAcl sets the optional parameter
+// "destinationPredefinedAcl": Apply a predefined set of access controls
+// to the destination object.
+//
+// Possible values:
+//   "authenticatedRead" - Object owner gets OWNER access, and
+// allAuthenticatedUsers get READER access.
+//   "bucketOwnerFullControl" - Object owner gets OWNER access, and
+// project team owners get OWNER access.
+//   "bucketOwnerRead" - Object owner gets OWNER access, and project
+// team owners get READER access.
+//   "private" - Object owner gets OWNER access.
+//   "projectPrivate" - Object owner gets OWNER access, and project team
+// members get access according to their roles.
+//   "publicRead" - Object owner gets OWNER access, and allUsers get
+// READER access.
+func (c *ObjectsComposeCall) DestinationPredefinedAcl(destinationPredefinedAcl string) *ObjectsComposeCall {
+        c.urlParams_.Set("destinationPredefinedAcl", destinationPredefinedAcl)
+        return c
+}
+
+// IfGenerationMatch sets the optional parameter "ifGenerationMatch":
+// Makes the operation conditional on whether the object's current
+// generation matches the given value. Setting to 0 makes the operation
+// succeed only if there are no live versions of the object.
+func (c *ObjectsComposeCall) IfGenerationMatch(ifGenerationMatch int64) *ObjectsComposeCall {
+        c.urlParams_.Set("ifGenerationMatch", fmt.Sprint(ifGenerationMatch))
+        return c
+}
+
+// IfMetagenerationMatch sets the optional parameter
+// "ifMetagenerationMatch": Makes the operation conditional on whether
+// the object's current metageneration matches the given value.
+func (c *ObjectsComposeCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *ObjectsComposeCall {
+        c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch))
+        return c
+}
+
+// KmsKeyName sets the optional parameter "kmsKeyName": Resource name of
+// the Cloud KMS key, of the form
+// projects/my-project/locations/global/keyRings/my-kr/cryptoKeys/my-key,
+//  that will be used to encrypt the object. Overrides the object
+// metadata's kms_key_name value, if any.
+func (c *ObjectsComposeCall) KmsKeyName(kmsKeyName string) *ObjectsComposeCall {
+        c.urlParams_.Set("kmsKeyName", kmsKeyName)
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *ObjectsComposeCall) UserProject(userProject string) *ObjectsComposeCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectsComposeCall) Fields(s ...googleapi.Field) *ObjectsComposeCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ObjectsComposeCall) Context(ctx context.Context) *ObjectsComposeCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectsComposeCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectsComposeCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.composerequest)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{destinationBucket}/o/{destinationObject}/compose")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("POST", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "destinationBucket": c.destinationBucket,
+                "destinationObject": c.destinationObject,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.objects.compose" call.
+// Exactly one of *Object or error will be non-nil. Any non-2xx status
+// code is an error. Response headers are in either
+// *Object.ServerResponse.Header or (if a response was returned at all)
+// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
+// check whether the returned error was because http.StatusNotModified
+// was returned.
+func (c *ObjectsComposeCall) Do(opts ...googleapi.CallOption) (*Object, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Object{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Concatenates a list of existing objects into a new object in the same bucket.",
+        //   "httpMethod": "POST",
+        //   "id": "storage.objects.compose",
+        //   "parameterOrder": [
+        //     "destinationBucket",
+        //     "destinationObject"
+        //   ],
+        //   "parameters": {
+        //     "destinationBucket": {
+        //       "description": "Name of the bucket containing the source objects. The destination object is stored in this bucket.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "destinationObject": {
+        //       "description": "Name of the new object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "destinationPredefinedAcl": {
+        //       "description": "Apply a predefined set of access controls to the destination object.",
+        //       "enum": [
+        //         "authenticatedRead",
+        //         "bucketOwnerFullControl",
+        //         "bucketOwnerRead",
+        //         "private",
+        //         "projectPrivate",
+        //         "publicRead"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.",
+        //         "Object owner gets OWNER access, and project team owners get OWNER access.",
+        //         "Object owner gets OWNER access, and project team owners get READER access.",
+        //         "Object owner gets OWNER access.",
+        //         "Object owner gets OWNER access, and project team members get access according to their roles.",
+        //         "Object owner gets OWNER access, and allUsers get READER access."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifGenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current metageneration matches the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "kmsKeyName": {
+        //       "description": "Resource name of the Cloud KMS key, of the form projects/my-project/locations/global/keyRings/my-kr/cryptoKeys/my-key, that will be used to encrypt the object. Overrides the object metadata's kms_key_name value, if any.",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{destinationBucket}/o/{destinationObject}/compose",
+        //   "request": {
+        //     "$ref": "ComposeRequest"
+        //   },
+        //   "response": {
+        //     "$ref": "Object"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.objects.copy":
+
+type ObjectsCopyCall struct {
+        s                 *Service
+        sourceBucket      string
+        sourceObject      string
+        destinationBucket string
+        destinationObject string
+        object            *Object
+        urlParams_        gensupport.URLParams
+        ctx_              context.Context
+        header_           http.Header
+}
+
+// Copy: Copies a source object to a destination object. Optionally
+// overrides metadata.
+func (r *ObjectsService) Copy(sourceBucket string, sourceObject string, destinationBucket string, destinationObject string, object *Object) *ObjectsCopyCall {
+        c := &ObjectsCopyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.sourceBucket = sourceBucket
+        c.sourceObject = sourceObject
+        c.destinationBucket = destinationBucket
+        c.destinationObject = destinationObject
+        c.object = object
+        return c
+}
+
+// DestinationPredefinedAcl sets the optional parameter
+// "destinationPredefinedAcl": Apply a predefined set of access controls
+// to the destination object.
+//
+// Possible values:
+//   "authenticatedRead" - Object owner gets OWNER access, and
+// allAuthenticatedUsers get READER access.
+//   "bucketOwnerFullControl" - Object owner gets OWNER access, and
+// project team owners get OWNER access.
+//   "bucketOwnerRead" - Object owner gets OWNER access, and project
+// team owners get READER access.
+//   "private" - Object owner gets OWNER access.
+//   "projectPrivate" - Object owner gets OWNER access, and project team
+// members get access according to their roles.
+//   "publicRead" - Object owner gets OWNER access, and allUsers get
+// READER access.
+func (c *ObjectsCopyCall) DestinationPredefinedAcl(destinationPredefinedAcl string) *ObjectsCopyCall {
+        c.urlParams_.Set("destinationPredefinedAcl", destinationPredefinedAcl)
+        return c
+}
+
+// IfGenerationMatch sets the optional parameter "ifGenerationMatch":
+// Makes the operation conditional on whether the destination object's
+// current generation matches the given value. Setting to 0 makes the
+// operation succeed only if there are no live versions of the object.
+func (c *ObjectsCopyCall) IfGenerationMatch(ifGenerationMatch int64) *ObjectsCopyCall {
+        c.urlParams_.Set("ifGenerationMatch", fmt.Sprint(ifGenerationMatch))
+        return c
+}
+
+// IfGenerationNotMatch sets the optional parameter
+// "ifGenerationNotMatch": Makes the operation conditional on whether
+// the destination object's current generation does not match the given
+// value. If no live object exists, the precondition fails. Setting to 0
+// makes the operation succeed only if there is a live version of the
+// object.
+func (c *ObjectsCopyCall) IfGenerationNotMatch(ifGenerationNotMatch int64) *ObjectsCopyCall {
+        c.urlParams_.Set("ifGenerationNotMatch", fmt.Sprint(ifGenerationNotMatch))
+        return c
+}
+
+// IfMetagenerationMatch sets the optional parameter
+// "ifMetagenerationMatch": Makes the operation conditional on whether
+// the destination object's current metageneration matches the given
+// value.
+func (c *ObjectsCopyCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *ObjectsCopyCall {
+        c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch))
+        return c
+}
+
+// IfMetagenerationNotMatch sets the optional parameter
+// "ifMetagenerationNotMatch": Makes the operation conditional on
+// whether the destination object's current metageneration does not
+// match the given value.
+func (c *ObjectsCopyCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *ObjectsCopyCall {
+        c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch))
+        return c
+}
+
+// IfSourceGenerationMatch sets the optional parameter
+// "ifSourceGenerationMatch": Makes the operation conditional on whether
+// the source object's current generation matches the given value.
+func (c *ObjectsCopyCall) IfSourceGenerationMatch(ifSourceGenerationMatch int64) *ObjectsCopyCall {
+        c.urlParams_.Set("ifSourceGenerationMatch", fmt.Sprint(ifSourceGenerationMatch))
+        return c
+}
+
+// IfSourceGenerationNotMatch sets the optional parameter
+// "ifSourceGenerationNotMatch": Makes the operation conditional on
+// whether the source object's current generation does not match the
+// given value.
+func (c *ObjectsCopyCall) IfSourceGenerationNotMatch(ifSourceGenerationNotMatch int64) *ObjectsCopyCall {
+        c.urlParams_.Set("ifSourceGenerationNotMatch", fmt.Sprint(ifSourceGenerationNotMatch))
+        return c
+}
+
+// IfSourceMetagenerationMatch sets the optional parameter
+// "ifSourceMetagenerationMatch": Makes the operation conditional on
+// whether the source object's current metageneration matches the given
+// value.
+func (c *ObjectsCopyCall) IfSourceMetagenerationMatch(ifSourceMetagenerationMatch int64) *ObjectsCopyCall {
+        c.urlParams_.Set("ifSourceMetagenerationMatch", fmt.Sprint(ifSourceMetagenerationMatch))
+        return c
+}
+
+// IfSourceMetagenerationNotMatch sets the optional parameter
+// "ifSourceMetagenerationNotMatch": Makes the operation conditional on
+// whether the source object's current metageneration does not match the
+// given value.
+func (c *ObjectsCopyCall) IfSourceMetagenerationNotMatch(ifSourceMetagenerationNotMatch int64) *ObjectsCopyCall {
+        c.urlParams_.Set("ifSourceMetagenerationNotMatch", fmt.Sprint(ifSourceMetagenerationNotMatch))
+        return c
+}
+
+// Projection sets the optional parameter "projection": Set of
+// properties to return. Defaults to noAcl, unless the object resource
+// specifies the acl property, when it defaults to full.
+//
+// Possible values:
+//   "full" - Include all properties.
+//   "noAcl" - Omit the owner, acl property.
+func (c *ObjectsCopyCall) Projection(projection string) *ObjectsCopyCall {
+        c.urlParams_.Set("projection", projection)
+        return c
+}
+
+// SourceGeneration sets the optional parameter "sourceGeneration": If
+// present, selects a specific revision of the source object (as opposed
+// to the latest version, the default).
+func (c *ObjectsCopyCall) SourceGeneration(sourceGeneration int64) *ObjectsCopyCall {
+        c.urlParams_.Set("sourceGeneration", fmt.Sprint(sourceGeneration))
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *ObjectsCopyCall) UserProject(userProject string) *ObjectsCopyCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectsCopyCall) Fields(s ...googleapi.Field) *ObjectsCopyCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ObjectsCopyCall) Context(ctx context.Context) *ObjectsCopyCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectsCopyCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectsCopyCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.object)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{sourceBucket}/o/{sourceObject}/copyTo/b/{destinationBucket}/o/{destinationObject}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("POST", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "sourceBucket":      c.sourceBucket,
+                "sourceObject":      c.sourceObject,
+                "destinationBucket": c.destinationBucket,
+                "destinationObject": c.destinationObject,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.objects.copy" call.
+// Exactly one of *Object or error will be non-nil. Any non-2xx status
+// code is an error. Response headers are in either
+// *Object.ServerResponse.Header or (if a response was returned at all)
+// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
+// check whether the returned error was because http.StatusNotModified
+// was returned.
+func (c *ObjectsCopyCall) Do(opts ...googleapi.CallOption) (*Object, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Object{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Copies a source object to a destination object. Optionally overrides metadata.",
+        //   "httpMethod": "POST",
+        //   "id": "storage.objects.copy",
+        //   "parameterOrder": [
+        //     "sourceBucket",
+        //     "sourceObject",
+        //     "destinationBucket",
+        //     "destinationObject"
+        //   ],
+        //   "parameters": {
+        //     "destinationBucket": {
+        //       "description": "Name of the bucket in which to store the new object. Overrides the provided object metadata's bucket value, if any.For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "destinationObject": {
+        //       "description": "Name of the new object. Required when the object metadata is not otherwise provided. Overrides the object metadata's name value, if any.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "destinationPredefinedAcl": {
+        //       "description": "Apply a predefined set of access controls to the destination object.",
+        //       "enum": [
+        //         "authenticatedRead",
+        //         "bucketOwnerFullControl",
+        //         "bucketOwnerRead",
+        //         "private",
+        //         "projectPrivate",
+        //         "publicRead"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.",
+        //         "Object owner gets OWNER access, and project team owners get OWNER access.",
+        //         "Object owner gets OWNER access, and project team owners get READER access.",
+        //         "Object owner gets OWNER access.",
+        //         "Object owner gets OWNER access, and project team members get access according to their roles.",
+        //         "Object owner gets OWNER access, and allUsers get READER access."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifGenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the destination object's current generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifGenerationNotMatch": {
+        //       "description": "Makes the operation conditional on whether the destination object's current generation does not match the given value. If no live object exists, the precondition fails. Setting to 0 makes the operation succeed only if there is a live version of the object.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the destination object's current metageneration matches the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationNotMatch": {
+        //       "description": "Makes the operation conditional on whether the destination object's current metageneration does not match the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifSourceGenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the source object's current generation matches the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifSourceGenerationNotMatch": {
+        //       "description": "Makes the operation conditional on whether the source object's current generation does not match the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifSourceMetagenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the source object's current metageneration matches the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifSourceMetagenerationNotMatch": {
+        //       "description": "Makes the operation conditional on whether the source object's current metageneration does not match the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "projection": {
+        //       "description": "Set of properties to return. Defaults to noAcl, unless the object resource specifies the acl property, when it defaults to full.",
+        //       "enum": [
+        //         "full",
+        //         "noAcl"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Include all properties.",
+        //         "Omit the owner, acl property."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "sourceBucket": {
+        //       "description": "Name of the bucket in which to find the source object.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "sourceGeneration": {
+        //       "description": "If present, selects a specific revision of the source object (as opposed to the latest version, the default).",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "sourceObject": {
+        //       "description": "Name of the source object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{sourceBucket}/o/{sourceObject}/copyTo/b/{destinationBucket}/o/{destinationObject}",
+        //   "request": {
+        //     "$ref": "Object"
+        //   },
+        //   "response": {
+        //     "$ref": "Object"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.objects.delete":
+
+type ObjectsDeleteCall struct {
+        s          *Service
+        bucket     string
+        object     string
+        urlParams_ gensupport.URLParams
+        ctx_       context.Context
+        header_    http.Header
+}
+
+// Delete: Deletes an object and its metadata. Deletions are permanent
+// if versioning is not enabled for the bucket, or if the generation
+// parameter is used.
+func (r *ObjectsService) Delete(bucket string, object string) *ObjectsDeleteCall {
+        c := &ObjectsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.object = object
+        return c
+}
+
+// Generation sets the optional parameter "generation": If present,
+// permanently deletes a specific revision of this object (as opposed to
+// the latest version, the default).
+func (c *ObjectsDeleteCall) Generation(generation int64) *ObjectsDeleteCall {
+        c.urlParams_.Set("generation", fmt.Sprint(generation))
+        return c
+}
+
+// IfGenerationMatch sets the optional parameter "ifGenerationMatch":
+// Makes the operation conditional on whether the object's current
+// generation matches the given value. Setting to 0 makes the operation
+// succeed only if there are no live versions of the object.
+func (c *ObjectsDeleteCall) IfGenerationMatch(ifGenerationMatch int64) *ObjectsDeleteCall {
+        c.urlParams_.Set("ifGenerationMatch", fmt.Sprint(ifGenerationMatch))
+        return c
+}
+
+// IfGenerationNotMatch sets the optional parameter
+// "ifGenerationNotMatch": Makes the operation conditional on whether
+// the object's current generation does not match the given value. If no
+// live object exists, the precondition fails. Setting to 0 makes the
+// operation succeed only if there is a live version of the object.
+func (c *ObjectsDeleteCall) IfGenerationNotMatch(ifGenerationNotMatch int64) *ObjectsDeleteCall {
+        c.urlParams_.Set("ifGenerationNotMatch", fmt.Sprint(ifGenerationNotMatch))
+        return c
+}
+
+// IfMetagenerationMatch sets the optional parameter
+// "ifMetagenerationMatch": Makes the operation conditional on whether
+// the object's current metageneration matches the given value.
+func (c *ObjectsDeleteCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *ObjectsDeleteCall {
+        c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch))
+        return c
+}
+
+// IfMetagenerationNotMatch sets the optional parameter
+// "ifMetagenerationNotMatch": Makes the operation conditional on
+// whether the object's current metageneration does not match the given
+// value.
+func (c *ObjectsDeleteCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *ObjectsDeleteCall {
+        c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch))
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *ObjectsDeleteCall) UserProject(userProject string) *ObjectsDeleteCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectsDeleteCall) Fields(s ...googleapi.Field) *ObjectsDeleteCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ObjectsDeleteCall) Context(ctx context.Context) *ObjectsDeleteCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectsDeleteCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectsDeleteCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("DELETE", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "object": c.object,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.objects.delete" call.
+func (c *ObjectsDeleteCall) Do(opts ...googleapi.CallOption) error {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if err != nil {
+                return err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return err
+        }
+        return nil
+        // {
+        //   "description": "Deletes an object and its metadata. Deletions are permanent if versioning is not enabled for the bucket, or if the generation parameter is used.",
+        //   "httpMethod": "DELETE",
+        //   "id": "storage.objects.delete",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "object"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of the bucket in which the object resides.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "generation": {
+        //       "description": "If present, permanently deletes a specific revision of this object (as opposed to the latest version, the default).",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifGenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifGenerationNotMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current generation does not match the given value. If no live object exists, the precondition fails. Setting to 0 makes the operation succeed only if there is a live version of the object.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current metageneration matches the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationNotMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current metageneration does not match the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "object": {
+        //       "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/o/{object}",
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.objects.get":
+
+type ObjectsGetCall struct {
+        s            *Service
+        bucket       string
+        object       string
+        urlParams_   gensupport.URLParams
+        ifNoneMatch_ string
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// Get: Retrieves an object or its metadata.
+func (r *ObjectsService) Get(bucket string, object string) *ObjectsGetCall {
+        c := &ObjectsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.object = object
+        return c
+}
+
+// Generation sets the optional parameter "generation": If present,
+// selects a specific revision of this object (as opposed to the latest
+// version, the default).
+func (c *ObjectsGetCall) Generation(generation int64) *ObjectsGetCall {
+        c.urlParams_.Set("generation", fmt.Sprint(generation))
+        return c
+}
+
+// IfGenerationMatch sets the optional parameter "ifGenerationMatch":
+// Makes the operation conditional on whether the object's current
+// generation matches the given value. Setting to 0 makes the operation
+// succeed only if there are no live versions of the object.
+func (c *ObjectsGetCall) IfGenerationMatch(ifGenerationMatch int64) *ObjectsGetCall {
+        c.urlParams_.Set("ifGenerationMatch", fmt.Sprint(ifGenerationMatch))
+        return c
+}
+
+// IfGenerationNotMatch sets the optional parameter
+// "ifGenerationNotMatch": Makes the operation conditional on whether
+// the object's current generation does not match the given value. If no
+// live object exists, the precondition fails. Setting to 0 makes the
+// operation succeed only if there is a live version of the object.
+func (c *ObjectsGetCall) IfGenerationNotMatch(ifGenerationNotMatch int64) *ObjectsGetCall {
+        c.urlParams_.Set("ifGenerationNotMatch", fmt.Sprint(ifGenerationNotMatch))
+        return c
+}
+
+// IfMetagenerationMatch sets the optional parameter
+// "ifMetagenerationMatch": Makes the operation conditional on whether
+// the object's current metageneration matches the given value.
+func (c *ObjectsGetCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *ObjectsGetCall {
+        c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch))
+        return c
+}
+
+// IfMetagenerationNotMatch sets the optional parameter
+// "ifMetagenerationNotMatch": Makes the operation conditional on
+// whether the object's current metageneration does not match the given
+// value.
+func (c *ObjectsGetCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *ObjectsGetCall {
+        c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch))
+        return c
+}
+
+// Projection sets the optional parameter "projection": Set of
+// properties to return. Defaults to noAcl.
+//
+// Possible values:
+//   "full" - Include all properties.
+//   "noAcl" - Omit the owner, acl property.
+func (c *ObjectsGetCall) Projection(projection string) *ObjectsGetCall {
+        c.urlParams_.Set("projection", projection)
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *ObjectsGetCall) UserProject(userProject string) *ObjectsGetCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectsGetCall) Fields(s ...googleapi.Field) *ObjectsGetCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// IfNoneMatch sets the optional parameter which makes the operation
+// fail if the object's ETag matches the given value. This is useful for
+// getting updates only after the object has changed since the last
+// request. Use googleapi.IsNotModified to check whether the response
+// error from Do is the result of In-None-Match.
+func (c *ObjectsGetCall) IfNoneMatch(entityTag string) *ObjectsGetCall {
+        c.ifNoneMatch_ = entityTag
+        return c
+}
+
+// Context sets the context to be used in this call's Do and Download
+// methods. Any pending HTTP request will be aborted if the provided
+// context is canceled.
+func (c *ObjectsGetCall) Context(ctx context.Context) *ObjectsGetCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectsGetCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectsGetCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        if c.ifNoneMatch_ != "" {
+                reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
+        }
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("GET", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "object": c.object,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Download fetches the API endpoint's "media" value, instead of the normal
+// API response value. If the returned error is nil, the Response is guaranteed to
+// have a 2xx status code. Callers must close the Response.Body as usual.
+func (c *ObjectsGetCall) Download(opts ...googleapi.CallOption) (*http.Response, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("media")
+        if err != nil {
+                return nil, err
+        }
+        if err := googleapi.CheckMediaResponse(res); err != nil {
+                res.Body.Close()
+                return nil, err
+        }
+        return res, nil
+}
+
+// Do executes the "storage.objects.get" call.
+// Exactly one of *Object or error will be non-nil. Any non-2xx status
+// code is an error. Response headers are in either
+// *Object.ServerResponse.Header or (if a response was returned at all)
+// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
+// check whether the returned error was because http.StatusNotModified
+// was returned.
+func (c *ObjectsGetCall) Do(opts ...googleapi.CallOption) (*Object, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Object{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Retrieves an object or its metadata.",
+        //   "httpMethod": "GET",
+        //   "id": "storage.objects.get",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "object"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of the bucket in which the object resides.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "generation": {
+        //       "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifGenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifGenerationNotMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current generation does not match the given value. If no live object exists, the precondition fails. Setting to 0 makes the operation succeed only if there is a live version of the object.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current metageneration matches the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationNotMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current metageneration does not match the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "object": {
+        //       "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "projection": {
+        //       "description": "Set of properties to return. Defaults to noAcl.",
+        //       "enum": [
+        //         "full",
+        //         "noAcl"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Include all properties.",
+        //         "Omit the owner, acl property."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/o/{object}",
+        //   "response": {
+        //     "$ref": "Object"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/cloud-platform.read-only",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_only",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ],
+        //   "supportsMediaDownload": true,
+        //   "useMediaDownloadService": true
+        // }
+
+}
+
+// method id "storage.objects.getIamPolicy":
+
+type ObjectsGetIamPolicyCall struct {
+        s            *Service
+        bucket       string
+        object       string
+        urlParams_   gensupport.URLParams
+        ifNoneMatch_ string
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// GetIamPolicy: Returns an IAM policy for the specified object.
+func (r *ObjectsService) GetIamPolicy(bucket string, object string) *ObjectsGetIamPolicyCall {
+        c := &ObjectsGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.object = object
+        return c
+}
+
+// Generation sets the optional parameter "generation": If present,
+// selects a specific revision of this object (as opposed to the latest
+// version, the default).
+func (c *ObjectsGetIamPolicyCall) Generation(generation int64) *ObjectsGetIamPolicyCall {
+        c.urlParams_.Set("generation", fmt.Sprint(generation))
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *ObjectsGetIamPolicyCall) UserProject(userProject string) *ObjectsGetIamPolicyCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectsGetIamPolicyCall) Fields(s ...googleapi.Field) *ObjectsGetIamPolicyCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// IfNoneMatch sets the optional parameter which makes the operation
+// fail if the object's ETag matches the given value. This is useful for
+// getting updates only after the object has changed since the last
+// request. Use googleapi.IsNotModified to check whether the response
+// error from Do is the result of In-None-Match.
+func (c *ObjectsGetIamPolicyCall) IfNoneMatch(entityTag string) *ObjectsGetIamPolicyCall {
+        c.ifNoneMatch_ = entityTag
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ObjectsGetIamPolicyCall) Context(ctx context.Context) *ObjectsGetIamPolicyCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectsGetIamPolicyCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectsGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        if c.ifNoneMatch_ != "" {
+                reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
+        }
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}/iam")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("GET", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "object": c.object,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.objects.getIamPolicy" call.
+// Exactly one of *Policy or error will be non-nil. Any non-2xx status
+// code is an error. Response headers are in either
+// *Policy.ServerResponse.Header or (if a response was returned at all)
+// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
+// check whether the returned error was because http.StatusNotModified
+// was returned.
+func (c *ObjectsGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Policy{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Returns an IAM policy for the specified object.",
+        //   "httpMethod": "GET",
+        //   "id": "storage.objects.getIamPolicy",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "object"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of the bucket in which the object resides.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "generation": {
+        //       "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "object": {
+        //       "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/o/{object}/iam",
+        //   "response": {
+        //     "$ref": "Policy"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/cloud-platform.read-only",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_only",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.objects.insert":
+
+type ObjectsInsertCall struct {
+        s          *Service
+        bucket     string
+        object     *Object
+        urlParams_ gensupport.URLParams
+        mediaInfo_ *gensupport.MediaInfo
+        ctx_       context.Context
+        header_    http.Header
+}
+
+// Insert: Stores a new object and metadata.
+func (r *ObjectsService) Insert(bucket string, object *Object) *ObjectsInsertCall {
+        c := &ObjectsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.object = object
+        return c
+}
+
+// ContentEncoding sets the optional parameter "contentEncoding": If
+// set, sets the contentEncoding property of the final object to this
+// value. Setting this parameter is equivalent to setting the
+// contentEncoding metadata property. This can be useful when uploading
+// an object with uploadType=media to indicate the encoding of the
+// content being uploaded.
+func (c *ObjectsInsertCall) ContentEncoding(contentEncoding string) *ObjectsInsertCall {
+        c.urlParams_.Set("contentEncoding", contentEncoding)
+        return c
+}
+
+// IfGenerationMatch sets the optional parameter "ifGenerationMatch":
+// Makes the operation conditional on whether the object's current
+// generation matches the given value. Setting to 0 makes the operation
+// succeed only if there are no live versions of the object.
+func (c *ObjectsInsertCall) IfGenerationMatch(ifGenerationMatch int64) *ObjectsInsertCall {
+        c.urlParams_.Set("ifGenerationMatch", fmt.Sprint(ifGenerationMatch))
+        return c
+}
+
+// IfGenerationNotMatch sets the optional parameter
+// "ifGenerationNotMatch": Makes the operation conditional on whether
+// the object's current generation does not match the given value. If no
+// live object exists, the precondition fails. Setting to 0 makes the
+// operation succeed only if there is a live version of the object.
+func (c *ObjectsInsertCall) IfGenerationNotMatch(ifGenerationNotMatch int64) *ObjectsInsertCall {
+        c.urlParams_.Set("ifGenerationNotMatch", fmt.Sprint(ifGenerationNotMatch))
+        return c
+}
+
+// IfMetagenerationMatch sets the optional parameter
+// "ifMetagenerationMatch": Makes the operation conditional on whether
+// the object's current metageneration matches the given value.
+func (c *ObjectsInsertCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *ObjectsInsertCall {
+        c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch))
+        return c
+}
+
+// IfMetagenerationNotMatch sets the optional parameter
+// "ifMetagenerationNotMatch": Makes the operation conditional on
+// whether the object's current metageneration does not match the given
+// value.
+func (c *ObjectsInsertCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *ObjectsInsertCall {
+        c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch))
+        return c
+}
+
+// KmsKeyName sets the optional parameter "kmsKeyName": Resource name of
+// the Cloud KMS key, of the form
+// projects/my-project/locations/global/keyRings/my-kr/cryptoKeys/my-key,
+//  that will be used to encrypt the object. Overrides the object
+// metadata's kms_key_name value, if any.
+func (c *ObjectsInsertCall) KmsKeyName(kmsKeyName string) *ObjectsInsertCall {
+        c.urlParams_.Set("kmsKeyName", kmsKeyName)
+        return c
+}
+
+// Name sets the optional parameter "name": Name of the object. Required
+// when the object metadata is not otherwise provided. Overrides the
+// object metadata's name value, if any. For information about how to
+// URL encode object names to be path safe, see Encoding URI Path Parts.
+func (c *ObjectsInsertCall) Name(name string) *ObjectsInsertCall {
+        c.urlParams_.Set("name", name)
+        return c
+}
+
+// PredefinedAcl sets the optional parameter "predefinedAcl": Apply a
+// predefined set of access controls to this object.
+//
+// Possible values:
+//   "authenticatedRead" - Object owner gets OWNER access, and
+// allAuthenticatedUsers get READER access.
+//   "bucketOwnerFullControl" - Object owner gets OWNER access, and
+// project team owners get OWNER access.
+//   "bucketOwnerRead" - Object owner gets OWNER access, and project
+// team owners get READER access.
+//   "private" - Object owner gets OWNER access.
+//   "projectPrivate" - Object owner gets OWNER access, and project team
+// members get access according to their roles.
+//   "publicRead" - Object owner gets OWNER access, and allUsers get
+// READER access.
+func (c *ObjectsInsertCall) PredefinedAcl(predefinedAcl string) *ObjectsInsertCall {
+        c.urlParams_.Set("predefinedAcl", predefinedAcl)
+        return c
+}
+
+// Projection sets the optional parameter "projection": Set of
+// properties to return. Defaults to noAcl, unless the object resource
+// specifies the acl property, when it defaults to full.
+//
+// Possible values:
+//   "full" - Include all properties.
+//   "noAcl" - Omit the owner, acl property.
+func (c *ObjectsInsertCall) Projection(projection string) *ObjectsInsertCall {
+        c.urlParams_.Set("projection", projection)
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *ObjectsInsertCall) UserProject(userProject string) *ObjectsInsertCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Media specifies the media to upload in one or more chunks. The chunk
+// size may be controlled by supplying a MediaOption generated by
+// googleapi.ChunkSize. The chunk size defaults to
+// googleapi.DefaultUploadChunkSize.The Content-Type header used in the
+// upload request will be determined by sniffing the contents of r,
+// unless a MediaOption generated by googleapi.ContentType is
+// supplied.
+// At most one of Media and ResumableMedia may be set.
+func (c *ObjectsInsertCall) Media(r io.Reader, options ...googleapi.MediaOption) *ObjectsInsertCall {
+        if ct := c.object.ContentType; ct != "" {
+                options = append([]googleapi.MediaOption{googleapi.ContentType(ct)}, options...)
+        }
+        c.mediaInfo_ = gensupport.NewInfoFromMedia(r, options)
+        return c
+}
+
+// ResumableMedia specifies the media to upload in chunks and can be
+// canceled with ctx.
+//
+// Deprecated: use Media instead.
+//
+// At most one of Media and ResumableMedia may be set. mediaType
+// identifies the MIME media type of the upload, such as "image/png". If
+// mediaType is "", it will be auto-detected. The provided ctx will
+// supersede any context previously provided to the Context method.
+func (c *ObjectsInsertCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *ObjectsInsertCall {
+        c.ctx_ = ctx
+        c.mediaInfo_ = gensupport.NewInfoFromResumableMedia(r, size, mediaType)
+        return c
+}
+
+// ProgressUpdater provides a callback function that will be called
+// after every chunk. It should be a low-latency function in order to
+// not slow down the upload operation. This should only be called when
+// using ResumableMedia (as opposed to Media).
+func (c *ObjectsInsertCall) ProgressUpdater(pu googleapi.ProgressUpdater) *ObjectsInsertCall {
+        c.mediaInfo_.SetProgressUpdater(pu)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectsInsertCall) Fields(s ...googleapi.Field) *ObjectsInsertCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+// This context will supersede any context previously provided to the
+// ResumableMedia method.
+func (c *ObjectsInsertCall) Context(ctx context.Context) *ObjectsInsertCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectsInsertCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectsInsertCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.object)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o")
+        if c.mediaInfo_ != nil {
+                urls = strings.Replace(urls, "https://www.googleapis.com/", "https://www.googleapis.com/upload/", 1)
+                c.urlParams_.Set("uploadType", c.mediaInfo_.UploadType())
+        }
+        if body == nil {
+                body = new(bytes.Buffer)
+                reqHeaders.Set("Content-Type", "application/json")
+        }
+        body, getBody, cleanup := c.mediaInfo_.UploadRequest(reqHeaders, body)
+        defer cleanup()
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("POST", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        gensupport.SetGetBody(req, getBody)
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.objects.insert" call.
+// Exactly one of *Object or error will be non-nil. Any non-2xx status
+// code is an error. Response headers are in either
+// *Object.ServerResponse.Header or (if a response was returned at all)
+// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
+// check whether the returned error was because http.StatusNotModified
+// was returned.
+func (c *ObjectsInsertCall) Do(opts ...googleapi.CallOption) (*Object, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        rx := c.mediaInfo_.ResumableUpload(res.Header.Get("Location"))
+        if rx != nil {
+                rx.Client = c.s.client
+                rx.UserAgent = c.s.userAgent()
+                ctx := c.ctx_
+                if ctx == nil {
+                        ctx = context.TODO()
+                }
+                res, err = rx.Upload(ctx)
+                if err != nil {
+                        return nil, err
+                }
+                defer res.Body.Close()
+                if err := googleapi.CheckResponse(res); err != nil {
+                        return nil, err
+                }
+        }
+        ret := &Object{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Stores a new object and metadata.",
+        //   "httpMethod": "POST",
+        //   "id": "storage.objects.insert",
+        //   "mediaUpload": {
+        //     "accept": [
+        //       "*/*"
+        //     ],
+        //     "protocols": {
+        //       "resumable": {
+        //         "multipart": true,
+        //         "path": "/resumable/upload/storage/v1/b/{bucket}/o"
+        //       },
+        //       "simple": {
+        //         "multipart": true,
+        //         "path": "/upload/storage/v1/b/{bucket}/o"
+        //       }
+        //     }
+        //   },
+        //   "parameterOrder": [
+        //     "bucket"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of the bucket in which to store the new object. Overrides the provided object metadata's bucket value, if any.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "contentEncoding": {
+        //       "description": "If set, sets the contentEncoding property of the final object to this value. Setting this parameter is equivalent to setting the contentEncoding metadata property. This can be useful when uploading an object with uploadType=media to indicate the encoding of the content being uploaded.",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifGenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifGenerationNotMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current generation does not match the given value. If no live object exists, the precondition fails. Setting to 0 makes the operation succeed only if there is a live version of the object.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current metageneration matches the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationNotMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current metageneration does not match the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "kmsKeyName": {
+        //       "description": "Resource name of the Cloud KMS key, of the form projects/my-project/locations/global/keyRings/my-kr/cryptoKeys/my-key, that will be used to encrypt the object. Overrides the object metadata's kms_key_name value, if any.",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "name": {
+        //       "description": "Name of the object. Required when the object metadata is not otherwise provided. Overrides the object metadata's name value, if any. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "predefinedAcl": {
+        //       "description": "Apply a predefined set of access controls to this object.",
+        //       "enum": [
+        //         "authenticatedRead",
+        //         "bucketOwnerFullControl",
+        //         "bucketOwnerRead",
+        //         "private",
+        //         "projectPrivate",
+        //         "publicRead"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.",
+        //         "Object owner gets OWNER access, and project team owners get OWNER access.",
+        //         "Object owner gets OWNER access, and project team owners get READER access.",
+        //         "Object owner gets OWNER access.",
+        //         "Object owner gets OWNER access, and project team members get access according to their roles.",
+        //         "Object owner gets OWNER access, and allUsers get READER access."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "projection": {
+        //       "description": "Set of properties to return. Defaults to noAcl, unless the object resource specifies the acl property, when it defaults to full.",
+        //       "enum": [
+        //         "full",
+        //         "noAcl"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Include all properties.",
+        //         "Omit the owner, acl property."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/o",
+        //   "request": {
+        //     "$ref": "Object"
+        //   },
+        //   "response": {
+        //     "$ref": "Object"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ],
+        //   "supportsMediaUpload": true
+        // }
+
+}
+
+// method id "storage.objects.list":
+
+type ObjectsListCall struct {
+        s            *Service
+        bucket       string
+        urlParams_   gensupport.URLParams
+        ifNoneMatch_ string
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// List: Retrieves a list of objects matching the criteria.
+func (r *ObjectsService) List(bucket string) *ObjectsListCall {
+        c := &ObjectsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        return c
+}
+
+// Delimiter sets the optional parameter "delimiter": Returns results in
+// a directory-like mode. items will contain only objects whose names,
+// aside from the prefix, do not contain delimiter. Objects whose names,
+// aside from the prefix, contain delimiter will have their name,
+// truncated after the delimiter, returned in prefixes. Duplicate
+// prefixes are omitted.
+func (c *ObjectsListCall) Delimiter(delimiter string) *ObjectsListCall {
+        c.urlParams_.Set("delimiter", delimiter)
+        return c
+}
+
+// IncludeTrailingDelimiter sets the optional parameter
+// "includeTrailingDelimiter": If true, objects that end in exactly one
+// instance of delimiter will have their metadata included in items in
+// addition to prefixes.
+func (c *ObjectsListCall) IncludeTrailingDelimiter(includeTrailingDelimiter bool) *ObjectsListCall {
+        c.urlParams_.Set("includeTrailingDelimiter", fmt.Sprint(includeTrailingDelimiter))
+        return c
+}
+
+// MaxResults sets the optional parameter "maxResults": Maximum number
+// of items plus prefixes to return in a single page of responses. As
+// duplicate prefixes are omitted, fewer total results may be returned
+// than requested. The service will use this parameter or 1,000 items,
+// whichever is smaller.
+func (c *ObjectsListCall) MaxResults(maxResults int64) *ObjectsListCall {
+        c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
+        return c
+}
+
+// PageToken sets the optional parameter "pageToken": A
+// previously-returned page token representing part of the larger set of
+// results to view.
+func (c *ObjectsListCall) PageToken(pageToken string) *ObjectsListCall {
+        c.urlParams_.Set("pageToken", pageToken)
+        return c
+}
+
+// Prefix sets the optional parameter "prefix": Filter results to
+// objects whose names begin with this prefix.
+func (c *ObjectsListCall) Prefix(prefix string) *ObjectsListCall {
+        c.urlParams_.Set("prefix", prefix)
+        return c
+}
+
+// Projection sets the optional parameter "projection": Set of
+// properties to return. Defaults to noAcl.
+//
+// Possible values:
+//   "full" - Include all properties.
+//   "noAcl" - Omit the owner, acl property.
+func (c *ObjectsListCall) Projection(projection string) *ObjectsListCall {
+        c.urlParams_.Set("projection", projection)
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *ObjectsListCall) UserProject(userProject string) *ObjectsListCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Versions sets the optional parameter "versions": If true, lists all
+// versions of an object as distinct results. The default is false. For
+// more information, see Object Versioning.
+func (c *ObjectsListCall) Versions(versions bool) *ObjectsListCall {
+        c.urlParams_.Set("versions", fmt.Sprint(versions))
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectsListCall) Fields(s ...googleapi.Field) *ObjectsListCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// IfNoneMatch sets the optional parameter which makes the operation
+// fail if the object's ETag matches the given value. This is useful for
+// getting updates only after the object has changed since the last
+// request. Use googleapi.IsNotModified to check whether the response
+// error from Do is the result of In-None-Match.
+func (c *ObjectsListCall) IfNoneMatch(entityTag string) *ObjectsListCall {
+        c.ifNoneMatch_ = entityTag
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ObjectsListCall) Context(ctx context.Context) *ObjectsListCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectsListCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectsListCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        if c.ifNoneMatch_ != "" {
+                reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
+        }
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("GET", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.objects.list" call.
+// Exactly one of *Objects or error will be non-nil. Any non-2xx status
+// code is an error. Response headers are in either
+// *Objects.ServerResponse.Header or (if a response was returned at all)
+// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
+// check whether the returned error was because http.StatusNotModified
+// was returned.
+func (c *ObjectsListCall) Do(opts ...googleapi.CallOption) (*Objects, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Objects{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Retrieves a list of objects matching the criteria.",
+        //   "httpMethod": "GET",
+        //   "id": "storage.objects.list",
+        //   "parameterOrder": [
+        //     "bucket"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of the bucket in which to look for objects.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "delimiter": {
+        //       "description": "Returns results in a directory-like mode. items will contain only objects whose names, aside from the prefix, do not contain delimiter. Objects whose names, aside from the prefix, contain delimiter will have their name, truncated after the delimiter, returned in prefixes. Duplicate prefixes are omitted.",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "includeTrailingDelimiter": {
+        //       "description": "If true, objects that end in exactly one instance of delimiter will have their metadata included in items in addition to prefixes.",
+        //       "location": "query",
+        //       "type": "boolean"
+        //     },
+        //     "maxResults": {
+        //       "default": "1000",
+        //       "description": "Maximum number of items plus prefixes to return in a single page of responses. As duplicate prefixes are omitted, fewer total results may be returned than requested. The service will use this parameter or 1,000 items, whichever is smaller.",
+        //       "format": "uint32",
+        //       "location": "query",
+        //       "minimum": "0",
+        //       "type": "integer"
+        //     },
+        //     "pageToken": {
+        //       "description": "A previously-returned page token representing part of the larger set of results to view.",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "prefix": {
+        //       "description": "Filter results to objects whose names begin with this prefix.",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "projection": {
+        //       "description": "Set of properties to return. Defaults to noAcl.",
+        //       "enum": [
+        //         "full",
+        //         "noAcl"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Include all properties.",
+        //         "Omit the owner, acl property."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "versions": {
+        //       "description": "If true, lists all versions of an object as distinct results. The default is false. For more information, see Object Versioning.",
+        //       "location": "query",
+        //       "type": "boolean"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/o",
+        //   "response": {
+        //     "$ref": "Objects"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/cloud-platform.read-only",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_only",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ],
+        //   "supportsSubscription": true
+        // }
+
+}
+
+// Pages invokes f for each page of results.
+// A non-nil error returned from f will halt the iteration.
+// The provided context supersedes any context provided to the Context method.
+func (c *ObjectsListCall) Pages(ctx context.Context, f func(*Objects) error) error {
+        c.ctx_ = ctx
+        defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point
+        for {
+                x, err := c.Do()
+                if err != nil {
+                        return err
+                }
+                if err := f(x); err != nil {
+                        return err
+                }
+                if x.NextPageToken == "" {
+                        return nil
+                }
+                c.PageToken(x.NextPageToken)
+        }
+}
+
+// method id "storage.objects.patch":
+
+type ObjectsPatchCall struct {
+        s          *Service
+        bucket     string
+        object     string
+        object2    *Object
+        urlParams_ gensupport.URLParams
+        ctx_       context.Context
+        header_    http.Header
+}
+
+// Patch: Patches an object's metadata.
+func (r *ObjectsService) Patch(bucket string, object string, object2 *Object) *ObjectsPatchCall {
+        c := &ObjectsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.object = object
+        c.object2 = object2
+        return c
+}
+
+// Generation sets the optional parameter "generation": If present,
+// selects a specific revision of this object (as opposed to the latest
+// version, the default).
+func (c *ObjectsPatchCall) Generation(generation int64) *ObjectsPatchCall {
+        c.urlParams_.Set("generation", fmt.Sprint(generation))
+        return c
+}
+
+// IfGenerationMatch sets the optional parameter "ifGenerationMatch":
+// Makes the operation conditional on whether the object's current
+// generation matches the given value. Setting to 0 makes the operation
+// succeed only if there are no live versions of the object.
+func (c *ObjectsPatchCall) IfGenerationMatch(ifGenerationMatch int64) *ObjectsPatchCall {
+        c.urlParams_.Set("ifGenerationMatch", fmt.Sprint(ifGenerationMatch))
+        return c
+}
+
+// IfGenerationNotMatch sets the optional parameter
+// "ifGenerationNotMatch": Makes the operation conditional on whether
+// the object's current generation does not match the given value. If no
+// live object exists, the precondition fails. Setting to 0 makes the
+// operation succeed only if there is a live version of the object.
+func (c *ObjectsPatchCall) IfGenerationNotMatch(ifGenerationNotMatch int64) *ObjectsPatchCall {
+        c.urlParams_.Set("ifGenerationNotMatch", fmt.Sprint(ifGenerationNotMatch))
+        return c
+}
+
+// IfMetagenerationMatch sets the optional parameter
+// "ifMetagenerationMatch": Makes the operation conditional on whether
+// the object's current metageneration matches the given value.
+func (c *ObjectsPatchCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *ObjectsPatchCall {
+        c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch))
+        return c
+}
+
+// IfMetagenerationNotMatch sets the optional parameter
+// "ifMetagenerationNotMatch": Makes the operation conditional on
+// whether the object's current metageneration does not match the given
+// value.
+func (c *ObjectsPatchCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *ObjectsPatchCall {
+        c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch))
+        return c
+}
+
+// PredefinedAcl sets the optional parameter "predefinedAcl": Apply a
+// predefined set of access controls to this object.
+//
+// Possible values:
+//   "authenticatedRead" - Object owner gets OWNER access, and
+// allAuthenticatedUsers get READER access.
+//   "bucketOwnerFullControl" - Object owner gets OWNER access, and
+// project team owners get OWNER access.
+//   "bucketOwnerRead" - Object owner gets OWNER access, and project
+// team owners get READER access.
+//   "private" - Object owner gets OWNER access.
+//   "projectPrivate" - Object owner gets OWNER access, and project team
+// members get access according to their roles.
+//   "publicRead" - Object owner gets OWNER access, and allUsers get
+// READER access.
+func (c *ObjectsPatchCall) PredefinedAcl(predefinedAcl string) *ObjectsPatchCall {
+        c.urlParams_.Set("predefinedAcl", predefinedAcl)
+        return c
+}
+
+// Projection sets the optional parameter "projection": Set of
+// properties to return. Defaults to full.
+//
+// Possible values:
+//   "full" - Include all properties.
+//   "noAcl" - Omit the owner, acl property.
+func (c *ObjectsPatchCall) Projection(projection string) *ObjectsPatchCall {
+        c.urlParams_.Set("projection", projection)
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request, for Requester Pays buckets.
+func (c *ObjectsPatchCall) UserProject(userProject string) *ObjectsPatchCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectsPatchCall) Fields(s ...googleapi.Field) *ObjectsPatchCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ObjectsPatchCall) Context(ctx context.Context) *ObjectsPatchCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectsPatchCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectsPatchCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.object2)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("PATCH", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "object": c.object,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.objects.patch" call.
+// Exactly one of *Object or error will be non-nil. Any non-2xx status
+// code is an error. Response headers are in either
+// *Object.ServerResponse.Header or (if a response was returned at all)
+// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
+// check whether the returned error was because http.StatusNotModified
+// was returned.
+func (c *ObjectsPatchCall) Do(opts ...googleapi.CallOption) (*Object, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Object{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Patches an object's metadata.",
+        //   "httpMethod": "PATCH",
+        //   "id": "storage.objects.patch",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "object"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of the bucket in which the object resides.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "generation": {
+        //       "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifGenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifGenerationNotMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current generation does not match the given value. If no live object exists, the precondition fails. Setting to 0 makes the operation succeed only if there is a live version of the object.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current metageneration matches the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationNotMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current metageneration does not match the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "object": {
+        //       "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "predefinedAcl": {
+        //       "description": "Apply a predefined set of access controls to this object.",
+        //       "enum": [
+        //         "authenticatedRead",
+        //         "bucketOwnerFullControl",
+        //         "bucketOwnerRead",
+        //         "private",
+        //         "projectPrivate",
+        //         "publicRead"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.",
+        //         "Object owner gets OWNER access, and project team owners get OWNER access.",
+        //         "Object owner gets OWNER access, and project team owners get READER access.",
+        //         "Object owner gets OWNER access.",
+        //         "Object owner gets OWNER access, and project team members get access according to their roles.",
+        //         "Object owner gets OWNER access, and allUsers get READER access."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "projection": {
+        //       "description": "Set of properties to return. Defaults to full.",
+        //       "enum": [
+        //         "full",
+        //         "noAcl"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Include all properties.",
+        //         "Omit the owner, acl property."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request, for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/o/{object}",
+        //   "request": {
+        //     "$ref": "Object"
+        //   },
+        //   "response": {
+        //     "$ref": "Object"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.objects.rewrite":
+
+type ObjectsRewriteCall struct {
+        s                 *Service
+        sourceBucket      string
+        sourceObject      string
+        destinationBucket string
+        destinationObject string
+        object            *Object
+        urlParams_        gensupport.URLParams
+        ctx_              context.Context
+        header_           http.Header
+}
+
+// Rewrite: Rewrites a source object to a destination object. Optionally
+// overrides metadata.
+func (r *ObjectsService) Rewrite(sourceBucket string, sourceObject string, destinationBucket string, destinationObject string, object *Object) *ObjectsRewriteCall {
+        c := &ObjectsRewriteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.sourceBucket = sourceBucket
+        c.sourceObject = sourceObject
+        c.destinationBucket = destinationBucket
+        c.destinationObject = destinationObject
+        c.object = object
+        return c
+}
+
+// DestinationKmsKeyName sets the optional parameter
+// "destinationKmsKeyName": Resource name of the Cloud KMS key, of the
+// form
+// projects/my-project/locations/global/keyRings/my-kr/cryptoKeys/my-key,
+//  that will be used to encrypt the object. Overrides the object
+// metadata's kms_key_name value, if any.
+func (c *ObjectsRewriteCall) DestinationKmsKeyName(destinationKmsKeyName string) *ObjectsRewriteCall {
+        c.urlParams_.Set("destinationKmsKeyName", destinationKmsKeyName)
+        return c
+}
+
+// DestinationPredefinedAcl sets the optional parameter
+// "destinationPredefinedAcl": Apply a predefined set of access controls
+// to the destination object.
+//
+// Possible values:
+//   "authenticatedRead" - Object owner gets OWNER access, and
+// allAuthenticatedUsers get READER access.
+//   "bucketOwnerFullControl" - Object owner gets OWNER access, and
+// project team owners get OWNER access.
+//   "bucketOwnerRead" - Object owner gets OWNER access, and project
+// team owners get READER access.
+//   "private" - Object owner gets OWNER access.
+//   "projectPrivate" - Object owner gets OWNER access, and project team
+// members get access according to their roles.
+//   "publicRead" - Object owner gets OWNER access, and allUsers get
+// READER access.
+func (c *ObjectsRewriteCall) DestinationPredefinedAcl(destinationPredefinedAcl string) *ObjectsRewriteCall {
+        c.urlParams_.Set("destinationPredefinedAcl", destinationPredefinedAcl)
+        return c
+}
+
+// IfGenerationMatch sets the optional parameter "ifGenerationMatch":
+// Makes the operation conditional on whether the object's current
+// generation matches the given value. Setting to 0 makes the operation
+// succeed only if there are no live versions of the object.
+func (c *ObjectsRewriteCall) IfGenerationMatch(ifGenerationMatch int64) *ObjectsRewriteCall {
+        c.urlParams_.Set("ifGenerationMatch", fmt.Sprint(ifGenerationMatch))
+        return c
+}
+
+// IfGenerationNotMatch sets the optional parameter
+// "ifGenerationNotMatch": Makes the operation conditional on whether
+// the object's current generation does not match the given value. If no
+// live object exists, the precondition fails. Setting to 0 makes the
+// operation succeed only if there is a live version of the object.
+func (c *ObjectsRewriteCall) IfGenerationNotMatch(ifGenerationNotMatch int64) *ObjectsRewriteCall {
+        c.urlParams_.Set("ifGenerationNotMatch", fmt.Sprint(ifGenerationNotMatch))
+        return c
+}
+
+// IfMetagenerationMatch sets the optional parameter
+// "ifMetagenerationMatch": Makes the operation conditional on whether
+// the destination object's current metageneration matches the given
+// value.
+func (c *ObjectsRewriteCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *ObjectsRewriteCall {
+        c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch))
+        return c
+}
+
+// IfMetagenerationNotMatch sets the optional parameter
+// "ifMetagenerationNotMatch": Makes the operation conditional on
+// whether the destination object's current metageneration does not
+// match the given value.
+func (c *ObjectsRewriteCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *ObjectsRewriteCall {
+        c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch))
+        return c
+}
+
+// IfSourceGenerationMatch sets the optional parameter
+// "ifSourceGenerationMatch": Makes the operation conditional on whether
+// the source object's current generation matches the given value.
+func (c *ObjectsRewriteCall) IfSourceGenerationMatch(ifSourceGenerationMatch int64) *ObjectsRewriteCall {
+        c.urlParams_.Set("ifSourceGenerationMatch", fmt.Sprint(ifSourceGenerationMatch))
+        return c
+}
+
+// IfSourceGenerationNotMatch sets the optional parameter
+// "ifSourceGenerationNotMatch": Makes the operation conditional on
+// whether the source object's current generation does not match the
+// given value.
+func (c *ObjectsRewriteCall) IfSourceGenerationNotMatch(ifSourceGenerationNotMatch int64) *ObjectsRewriteCall {
+        c.urlParams_.Set("ifSourceGenerationNotMatch", fmt.Sprint(ifSourceGenerationNotMatch))
+        return c
+}
+
+// IfSourceMetagenerationMatch sets the optional parameter
+// "ifSourceMetagenerationMatch": Makes the operation conditional on
+// whether the source object's current metageneration matches the given
+// value.
+func (c *ObjectsRewriteCall) IfSourceMetagenerationMatch(ifSourceMetagenerationMatch int64) *ObjectsRewriteCall {
+        c.urlParams_.Set("ifSourceMetagenerationMatch", fmt.Sprint(ifSourceMetagenerationMatch))
+        return c
+}
+
+// IfSourceMetagenerationNotMatch sets the optional parameter
+// "ifSourceMetagenerationNotMatch": Makes the operation conditional on
+// whether the source object's current metageneration does not match the
+// given value.
+func (c *ObjectsRewriteCall) IfSourceMetagenerationNotMatch(ifSourceMetagenerationNotMatch int64) *ObjectsRewriteCall {
+        c.urlParams_.Set("ifSourceMetagenerationNotMatch", fmt.Sprint(ifSourceMetagenerationNotMatch))
+        return c
+}
+
+// MaxBytesRewrittenPerCall sets the optional parameter
+// "maxBytesRewrittenPerCall": The maximum number of bytes that will be
+// rewritten per rewrite request. Most callers shouldn't need to specify
+// this parameter - it is primarily in place to support testing. If
+// specified the value must be an integral multiple of 1 MiB (1048576).
+// Also, this only applies to requests where the source and destination
+// span locations and/or storage classes. Finally, this value must not
+// change across rewrite calls else you'll get an error that the
+// rewriteToken is invalid.
+func (c *ObjectsRewriteCall) MaxBytesRewrittenPerCall(maxBytesRewrittenPerCall int64) *ObjectsRewriteCall {
+        c.urlParams_.Set("maxBytesRewrittenPerCall", fmt.Sprint(maxBytesRewrittenPerCall))
+        return c
+}
+
+// Projection sets the optional parameter "projection": Set of
+// properties to return. Defaults to noAcl, unless the object resource
+// specifies the acl property, when it defaults to full.
+//
+// Possible values:
+//   "full" - Include all properties.
+//   "noAcl" - Omit the owner, acl property.
+func (c *ObjectsRewriteCall) Projection(projection string) *ObjectsRewriteCall {
+        c.urlParams_.Set("projection", projection)
+        return c
+}
+
+// RewriteToken sets the optional parameter "rewriteToken": Include this
+// field (from the previous rewrite response) on each rewrite request
+// after the first one, until the rewrite response 'done' flag is true.
+// Calls that provide a rewriteToken can omit all other request fields,
+// but if included those fields must match the values provided in the
+// first rewrite request.
+func (c *ObjectsRewriteCall) RewriteToken(rewriteToken string) *ObjectsRewriteCall {
+        c.urlParams_.Set("rewriteToken", rewriteToken)
+        return c
+}
+
+// SourceGeneration sets the optional parameter "sourceGeneration": If
+// present, selects a specific revision of the source object (as opposed
+// to the latest version, the default).
+func (c *ObjectsRewriteCall) SourceGeneration(sourceGeneration int64) *ObjectsRewriteCall {
+        c.urlParams_.Set("sourceGeneration", fmt.Sprint(sourceGeneration))
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *ObjectsRewriteCall) UserProject(userProject string) *ObjectsRewriteCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectsRewriteCall) Fields(s ...googleapi.Field) *ObjectsRewriteCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ObjectsRewriteCall) Context(ctx context.Context) *ObjectsRewriteCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectsRewriteCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectsRewriteCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.object)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{sourceBucket}/o/{sourceObject}/rewriteTo/b/{destinationBucket}/o/{destinationObject}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("POST", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "sourceBucket":      c.sourceBucket,
+                "sourceObject":      c.sourceObject,
+                "destinationBucket": c.destinationBucket,
+                "destinationObject": c.destinationObject,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.objects.rewrite" call.
+// Exactly one of *RewriteResponse or error will be non-nil. Any non-2xx
+// status code is an error. Response headers are in either
+// *RewriteResponse.ServerResponse.Header or (if a response was returned
+// at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *ObjectsRewriteCall) Do(opts ...googleapi.CallOption) (*RewriteResponse, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &RewriteResponse{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Rewrites a source object to a destination object. Optionally overrides metadata.",
+        //   "httpMethod": "POST",
+        //   "id": "storage.objects.rewrite",
+        //   "parameterOrder": [
+        //     "sourceBucket",
+        //     "sourceObject",
+        //     "destinationBucket",
+        //     "destinationObject"
+        //   ],
+        //   "parameters": {
+        //     "destinationBucket": {
+        //       "description": "Name of the bucket in which to store the new object. Overrides the provided object metadata's bucket value, if any.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "destinationKmsKeyName": {
+        //       "description": "Resource name of the Cloud KMS key, of the form projects/my-project/locations/global/keyRings/my-kr/cryptoKeys/my-key, that will be used to encrypt the object. Overrides the object metadata's kms_key_name value, if any.",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "destinationObject": {
+        //       "description": "Name of the new object. Required when the object metadata is not otherwise provided. Overrides the object metadata's name value, if any. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "destinationPredefinedAcl": {
+        //       "description": "Apply a predefined set of access controls to the destination object.",
+        //       "enum": [
+        //         "authenticatedRead",
+        //         "bucketOwnerFullControl",
+        //         "bucketOwnerRead",
+        //         "private",
+        //         "projectPrivate",
+        //         "publicRead"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.",
+        //         "Object owner gets OWNER access, and project team owners get OWNER access.",
+        //         "Object owner gets OWNER access, and project team owners get READER access.",
+        //         "Object owner gets OWNER access.",
+        //         "Object owner gets OWNER access, and project team members get access according to their roles.",
+        //         "Object owner gets OWNER access, and allUsers get READER access."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifGenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifGenerationNotMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current generation does not match the given value. If no live object exists, the precondition fails. Setting to 0 makes the operation succeed only if there is a live version of the object.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the destination object's current metageneration matches the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationNotMatch": {
+        //       "description": "Makes the operation conditional on whether the destination object's current metageneration does not match the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifSourceGenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the source object's current generation matches the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifSourceGenerationNotMatch": {
+        //       "description": "Makes the operation conditional on whether the source object's current generation does not match the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifSourceMetagenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the source object's current metageneration matches the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifSourceMetagenerationNotMatch": {
+        //       "description": "Makes the operation conditional on whether the source object's current metageneration does not match the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "maxBytesRewrittenPerCall": {
+        //       "description": "The maximum number of bytes that will be rewritten per rewrite request. Most callers shouldn't need to specify this parameter - it is primarily in place to support testing. If specified the value must be an integral multiple of 1 MiB (1048576). Also, this only applies to requests where the source and destination span locations and/or storage classes. Finally, this value must not change across rewrite calls else you'll get an error that the rewriteToken is invalid.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "projection": {
+        //       "description": "Set of properties to return. Defaults to noAcl, unless the object resource specifies the acl property, when it defaults to full.",
+        //       "enum": [
+        //         "full",
+        //         "noAcl"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Include all properties.",
+        //         "Omit the owner, acl property."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "rewriteToken": {
+        //       "description": "Include this field (from the previous rewrite response) on each rewrite request after the first one, until the rewrite response 'done' flag is true. Calls that provide a rewriteToken can omit all other request fields, but if included those fields must match the values provided in the first rewrite request.",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "sourceBucket": {
+        //       "description": "Name of the bucket in which to find the source object.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "sourceGeneration": {
+        //       "description": "If present, selects a specific revision of the source object (as opposed to the latest version, the default).",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "sourceObject": {
+        //       "description": "Name of the source object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{sourceBucket}/o/{sourceObject}/rewriteTo/b/{destinationBucket}/o/{destinationObject}",
+        //   "request": {
+        //     "$ref": "Object"
+        //   },
+        //   "response": {
+        //     "$ref": "RewriteResponse"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.objects.setIamPolicy":
+
+type ObjectsSetIamPolicyCall struct {
+        s          *Service
+        bucket     string
+        object     string
+        policy     *Policy
+        urlParams_ gensupport.URLParams
+        ctx_       context.Context
+        header_    http.Header
+}
+
+// SetIamPolicy: Updates an IAM policy for the specified object.
+func (r *ObjectsService) SetIamPolicy(bucket string, object string, policy *Policy) *ObjectsSetIamPolicyCall {
+        c := &ObjectsSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.object = object
+        c.policy = policy
+        return c
+}
+
+// Generation sets the optional parameter "generation": If present,
+// selects a specific revision of this object (as opposed to the latest
+// version, the default).
+func (c *ObjectsSetIamPolicyCall) Generation(generation int64) *ObjectsSetIamPolicyCall {
+        c.urlParams_.Set("generation", fmt.Sprint(generation))
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *ObjectsSetIamPolicyCall) UserProject(userProject string) *ObjectsSetIamPolicyCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectsSetIamPolicyCall) Fields(s ...googleapi.Field) *ObjectsSetIamPolicyCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ObjectsSetIamPolicyCall) Context(ctx context.Context) *ObjectsSetIamPolicyCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectsSetIamPolicyCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectsSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.policy)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}/iam")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("PUT", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "object": c.object,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.objects.setIamPolicy" call.
+// Exactly one of *Policy or error will be non-nil. Any non-2xx status
+// code is an error. Response headers are in either
+// *Policy.ServerResponse.Header or (if a response was returned at all)
+// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
+// check whether the returned error was because http.StatusNotModified
+// was returned.
+func (c *ObjectsSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Policy{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Updates an IAM policy for the specified object.",
+        //   "httpMethod": "PUT",
+        //   "id": "storage.objects.setIamPolicy",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "object"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of the bucket in which the object resides.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "generation": {
+        //       "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "object": {
+        //       "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/o/{object}/iam",
+        //   "request": {
+        //     "$ref": "Policy"
+        //   },
+        //   "response": {
+        //     "$ref": "Policy"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.objects.testIamPermissions":
+
+type ObjectsTestIamPermissionsCall struct {
+        s            *Service
+        bucket       string
+        object       string
+        urlParams_   gensupport.URLParams
+        ifNoneMatch_ string
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// TestIamPermissions: Tests a set of permissions on the given object to
+// see which, if any, are held by the caller.
+func (r *ObjectsService) TestIamPermissions(bucket string, object string, permissions []string) *ObjectsTestIamPermissionsCall {
+        c := &ObjectsTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.object = object
+        c.urlParams_.SetMulti("permissions", append([]string{}, permissions...))
+        return c
+}
+
+// Generation sets the optional parameter "generation": If present,
+// selects a specific revision of this object (as opposed to the latest
+// version, the default).
+func (c *ObjectsTestIamPermissionsCall) Generation(generation int64) *ObjectsTestIamPermissionsCall {
+        c.urlParams_.Set("generation", fmt.Sprint(generation))
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *ObjectsTestIamPermissionsCall) UserProject(userProject string) *ObjectsTestIamPermissionsCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectsTestIamPermissionsCall) Fields(s ...googleapi.Field) *ObjectsTestIamPermissionsCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// IfNoneMatch sets the optional parameter which makes the operation
+// fail if the object's ETag matches the given value. This is useful for
+// getting updates only after the object has changed since the last
+// request. Use googleapi.IsNotModified to check whether the response
+// error from Do is the result of In-None-Match.
+func (c *ObjectsTestIamPermissionsCall) IfNoneMatch(entityTag string) *ObjectsTestIamPermissionsCall {
+        c.ifNoneMatch_ = entityTag
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ObjectsTestIamPermissionsCall) Context(ctx context.Context) *ObjectsTestIamPermissionsCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectsTestIamPermissionsCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectsTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        if c.ifNoneMatch_ != "" {
+                reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
+        }
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}/iam/testPermissions")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("GET", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "object": c.object,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.objects.testIamPermissions" call.
+// Exactly one of *TestIamPermissionsResponse or error will be non-nil.
+// Any non-2xx status code is an error. Response headers are in either
+// *TestIamPermissionsResponse.ServerResponse.Header or (if a response
+// was returned at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *ObjectsTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &TestIamPermissionsResponse{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Tests a set of permissions on the given object to see which, if any, are held by the caller.",
+        //   "httpMethod": "GET",
+        //   "id": "storage.objects.testIamPermissions",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "object",
+        //     "permissions"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of the bucket in which the object resides.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "generation": {
+        //       "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "object": {
+        //       "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "permissions": {
+        //       "description": "Permissions to test.",
+        //       "location": "query",
+        //       "repeated": true,
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/o/{object}/iam/testPermissions",
+        //   "response": {
+        //     "$ref": "TestIamPermissionsResponse"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/cloud-platform.read-only",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_only",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
+
+// method id "storage.objects.update":
+
+type ObjectsUpdateCall struct {
+        s          *Service
+        bucket     string
+        object     string
+        object2    *Object
+        urlParams_ gensupport.URLParams
+        ctx_       context.Context
+        header_    http.Header
+}
+
+// Update: Updates an object's metadata.
+func (r *ObjectsService) Update(bucket string, object string, object2 *Object) *ObjectsUpdateCall {
+        c := &ObjectsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.object = object
+        c.object2 = object2
+        return c
+}
+
+// Generation sets the optional parameter "generation": If present,
+// selects a specific revision of this object (as opposed to the latest
+// version, the default).
+func (c *ObjectsUpdateCall) Generation(generation int64) *ObjectsUpdateCall {
+        c.urlParams_.Set("generation", fmt.Sprint(generation))
+        return c
+}
+
+// IfGenerationMatch sets the optional parameter "ifGenerationMatch":
+// Makes the operation conditional on whether the object's current
+// generation matches the given value. Setting to 0 makes the operation
+// succeed only if there are no live versions of the object.
+func (c *ObjectsUpdateCall) IfGenerationMatch(ifGenerationMatch int64) *ObjectsUpdateCall {
+        c.urlParams_.Set("ifGenerationMatch", fmt.Sprint(ifGenerationMatch))
+        return c
+}
+
+// IfGenerationNotMatch sets the optional parameter
+// "ifGenerationNotMatch": Makes the operation conditional on whether
+// the object's current generation does not match the given value. If no
+// live object exists, the precondition fails. Setting to 0 makes the
+// operation succeed only if there is a live version of the object.
+func (c *ObjectsUpdateCall) IfGenerationNotMatch(ifGenerationNotMatch int64) *ObjectsUpdateCall {
+        c.urlParams_.Set("ifGenerationNotMatch", fmt.Sprint(ifGenerationNotMatch))
+        return c
+}
+
+// IfMetagenerationMatch sets the optional parameter
+// "ifMetagenerationMatch": Makes the operation conditional on whether
+// the object's current metageneration matches the given value.
+func (c *ObjectsUpdateCall) IfMetagenerationMatch(ifMetagenerationMatch int64) *ObjectsUpdateCall {
+        c.urlParams_.Set("ifMetagenerationMatch", fmt.Sprint(ifMetagenerationMatch))
+        return c
+}
+
+// IfMetagenerationNotMatch sets the optional parameter
+// "ifMetagenerationNotMatch": Makes the operation conditional on
+// whether the object's current metageneration does not match the given
+// value.
+func (c *ObjectsUpdateCall) IfMetagenerationNotMatch(ifMetagenerationNotMatch int64) *ObjectsUpdateCall {
+        c.urlParams_.Set("ifMetagenerationNotMatch", fmt.Sprint(ifMetagenerationNotMatch))
+        return c
+}
+
+// PredefinedAcl sets the optional parameter "predefinedAcl": Apply a
+// predefined set of access controls to this object.
+//
+// Possible values:
+//   "authenticatedRead" - Object owner gets OWNER access, and
+// allAuthenticatedUsers get READER access.
+//   "bucketOwnerFullControl" - Object owner gets OWNER access, and
+// project team owners get OWNER access.
+//   "bucketOwnerRead" - Object owner gets OWNER access, and project
+// team owners get READER access.
+//   "private" - Object owner gets OWNER access.
+//   "projectPrivate" - Object owner gets OWNER access, and project team
+// members get access according to their roles.
+//   "publicRead" - Object owner gets OWNER access, and allUsers get
+// READER access.
+func (c *ObjectsUpdateCall) PredefinedAcl(predefinedAcl string) *ObjectsUpdateCall {
+        c.urlParams_.Set("predefinedAcl", predefinedAcl)
+        return c
+}
+
+// Projection sets the optional parameter "projection": Set of
+// properties to return. Defaults to full.
+//
+// Possible values:
+//   "full" - Include all properties.
+//   "noAcl" - Omit the owner, acl property.
+func (c *ObjectsUpdateCall) Projection(projection string) *ObjectsUpdateCall {
+        c.urlParams_.Set("projection", projection)
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *ObjectsUpdateCall) UserProject(userProject string) *ObjectsUpdateCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectsUpdateCall) Fields(s ...googleapi.Field) *ObjectsUpdateCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ObjectsUpdateCall) Context(ctx context.Context) *ObjectsUpdateCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectsUpdateCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectsUpdateCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.object2)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/{object}")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("PUT", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+                "object": c.object,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.objects.update" call.
+// Exactly one of *Object or error will be non-nil. Any non-2xx status
+// code is an error. Response headers are in either
+// *Object.ServerResponse.Header or (if a response was returned at all)
+// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
+// check whether the returned error was because http.StatusNotModified
+// was returned.
+func (c *ObjectsUpdateCall) Do(opts ...googleapi.CallOption) (*Object, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Object{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Updates an object's metadata.",
+        //   "httpMethod": "PUT",
+        //   "id": "storage.objects.update",
+        //   "parameterOrder": [
+        //     "bucket",
+        //     "object"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of the bucket in which the object resides.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "generation": {
+        //       "description": "If present, selects a specific revision of this object (as opposed to the latest version, the default).",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifGenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current generation matches the given value. Setting to 0 makes the operation succeed only if there are no live versions of the object.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifGenerationNotMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current generation does not match the given value. If no live object exists, the precondition fails. Setting to 0 makes the operation succeed only if there is a live version of the object.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current metageneration matches the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "ifMetagenerationNotMatch": {
+        //       "description": "Makes the operation conditional on whether the object's current metageneration does not match the given value.",
+        //       "format": "int64",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "object": {
+        //       "description": "Name of the object. For information about how to URL encode object names to be path safe, see Encoding URI Path Parts.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "predefinedAcl": {
+        //       "description": "Apply a predefined set of access controls to this object.",
+        //       "enum": [
+        //         "authenticatedRead",
+        //         "bucketOwnerFullControl",
+        //         "bucketOwnerRead",
+        //         "private",
+        //         "projectPrivate",
+        //         "publicRead"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Object owner gets OWNER access, and allAuthenticatedUsers get READER access.",
+        //         "Object owner gets OWNER access, and project team owners get OWNER access.",
+        //         "Object owner gets OWNER access, and project team owners get READER access.",
+        //         "Object owner gets OWNER access.",
+        //         "Object owner gets OWNER access, and project team members get access according to their roles.",
+        //         "Object owner gets OWNER access, and allUsers get READER access."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "projection": {
+        //       "description": "Set of properties to return. Defaults to full.",
+        //       "enum": [
+        //         "full",
+        //         "noAcl"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Include all properties.",
+        //         "Omit the owner, acl property."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/o/{object}",
+        //   "request": {
+        //     "$ref": "Object"
+        //   },
+        //   "response": {
+        //     "$ref": "Object"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/devstorage.full_control"
+        //   ]
+        // }
+
+}
+
+// method id "storage.objects.watchAll":
+
+type ObjectsWatchAllCall struct {
+        s          *Service
+        bucket     string
+        channel    *Channel
+        urlParams_ gensupport.URLParams
+        ctx_       context.Context
+        header_    http.Header
+}
+
+// WatchAll: Watch for changes on all objects in a bucket.
+func (r *ObjectsService) WatchAll(bucket string, channel *Channel) *ObjectsWatchAllCall {
+        c := &ObjectsWatchAllCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.bucket = bucket
+        c.channel = channel
+        return c
+}
+
+// Delimiter sets the optional parameter "delimiter": Returns results in
+// a directory-like mode. items will contain only objects whose names,
+// aside from the prefix, do not contain delimiter. Objects whose names,
+// aside from the prefix, contain delimiter will have their name,
+// truncated after the delimiter, returned in prefixes. Duplicate
+// prefixes are omitted.
+func (c *ObjectsWatchAllCall) Delimiter(delimiter string) *ObjectsWatchAllCall {
+        c.urlParams_.Set("delimiter", delimiter)
+        return c
+}
+
+// IncludeTrailingDelimiter sets the optional parameter
+// "includeTrailingDelimiter": If true, objects that end in exactly one
+// instance of delimiter will have their metadata included in items in
+// addition to prefixes.
+func (c *ObjectsWatchAllCall) IncludeTrailingDelimiter(includeTrailingDelimiter bool) *ObjectsWatchAllCall {
+        c.urlParams_.Set("includeTrailingDelimiter", fmt.Sprint(includeTrailingDelimiter))
+        return c
+}
+
+// MaxResults sets the optional parameter "maxResults": Maximum number
+// of items plus prefixes to return in a single page of responses. As
+// duplicate prefixes are omitted, fewer total results may be returned
+// than requested. The service will use this parameter or 1,000 items,
+// whichever is smaller.
+func (c *ObjectsWatchAllCall) MaxResults(maxResults int64) *ObjectsWatchAllCall {
+        c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
+        return c
+}
+
+// PageToken sets the optional parameter "pageToken": A
+// previously-returned page token representing part of the larger set of
+// results to view.
+func (c *ObjectsWatchAllCall) PageToken(pageToken string) *ObjectsWatchAllCall {
+        c.urlParams_.Set("pageToken", pageToken)
+        return c
+}
+
+// Prefix sets the optional parameter "prefix": Filter results to
+// objects whose names begin with this prefix.
+func (c *ObjectsWatchAllCall) Prefix(prefix string) *ObjectsWatchAllCall {
+        c.urlParams_.Set("prefix", prefix)
+        return c
+}
+
+// Projection sets the optional parameter "projection": Set of
+// properties to return. Defaults to noAcl.
+//
+// Possible values:
+//   "full" - Include all properties.
+//   "noAcl" - Omit the owner, acl property.
+func (c *ObjectsWatchAllCall) Projection(projection string) *ObjectsWatchAllCall {
+        c.urlParams_.Set("projection", projection)
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request. Required for Requester Pays buckets.
+func (c *ObjectsWatchAllCall) UserProject(userProject string) *ObjectsWatchAllCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Versions sets the optional parameter "versions": If true, lists all
+// versions of an object as distinct results. The default is false. For
+// more information, see Object Versioning.
+func (c *ObjectsWatchAllCall) Versions(versions bool) *ObjectsWatchAllCall {
+        c.urlParams_.Set("versions", fmt.Sprint(versions))
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ObjectsWatchAllCall) Fields(s ...googleapi.Field) *ObjectsWatchAllCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ObjectsWatchAllCall) Context(ctx context.Context) *ObjectsWatchAllCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ObjectsWatchAllCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ObjectsWatchAllCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        var body io.Reader = nil
+        body, err := googleapi.WithoutDataWrapper.JSONReader(c.channel)
+        if err != nil {
+                return nil, err
+        }
+        reqHeaders.Set("Content-Type", "application/json")
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "b/{bucket}/o/watch")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("POST", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "bucket": c.bucket,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.objects.watchAll" call.
+// Exactly one of *Channel or error will be non-nil. Any non-2xx status
+// code is an error. Response headers are in either
+// *Channel.ServerResponse.Header or (if a response was returned at all)
+// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
+// check whether the returned error was because http.StatusNotModified
+// was returned.
+func (c *ObjectsWatchAllCall) Do(opts ...googleapi.CallOption) (*Channel, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &Channel{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Watch for changes on all objects in a bucket.",
+        //   "httpMethod": "POST",
+        //   "id": "storage.objects.watchAll",
+        //   "parameterOrder": [
+        //     "bucket"
+        //   ],
+        //   "parameters": {
+        //     "bucket": {
+        //       "description": "Name of the bucket in which to look for objects.",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "delimiter": {
+        //       "description": "Returns results in a directory-like mode. items will contain only objects whose names, aside from the prefix, do not contain delimiter. Objects whose names, aside from the prefix, contain delimiter will have their name, truncated after the delimiter, returned in prefixes. Duplicate prefixes are omitted.",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "includeTrailingDelimiter": {
+        //       "description": "If true, objects that end in exactly one instance of delimiter will have their metadata included in items in addition to prefixes.",
+        //       "location": "query",
+        //       "type": "boolean"
+        //     },
+        //     "maxResults": {
+        //       "default": "1000",
+        //       "description": "Maximum number of items plus prefixes to return in a single page of responses. As duplicate prefixes are omitted, fewer total results may be returned than requested. The service will use this parameter or 1,000 items, whichever is smaller.",
+        //       "format": "uint32",
+        //       "location": "query",
+        //       "minimum": "0",
+        //       "type": "integer"
+        //     },
+        //     "pageToken": {
+        //       "description": "A previously-returned page token representing part of the larger set of results to view.",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "prefix": {
+        //       "description": "Filter results to objects whose names begin with this prefix.",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "projection": {
+        //       "description": "Set of properties to return. Defaults to noAcl.",
+        //       "enum": [
+        //         "full",
+        //         "noAcl"
+        //       ],
+        //       "enumDescriptions": [
+        //         "Include all properties.",
+        //         "Omit the owner, acl property."
+        //       ],
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request. Required for Requester Pays buckets.",
+        //       "location": "query",
+        //       "type": "string"
+        //     },
+        //     "versions": {
+        //       "description": "If true, lists all versions of an object as distinct results. The default is false. For more information, see Object Versioning.",
+        //       "location": "query",
+        //       "type": "boolean"
+        //     }
+        //   },
+        //   "path": "b/{bucket}/o/watch",
+        //   "request": {
+        //     "$ref": "Channel",
+        //     "parameterName": "resource"
+        //   },
+        //   "response": {
+        //     "$ref": "Channel"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/cloud-platform.read-only",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_only",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ],
+        //   "supportsSubscription": true
+        // }
+
+}
+
+// method id "storage.projects.serviceAccount.get":
+
+type ProjectsServiceAccountGetCall struct {
+        s            *Service
+        projectId    string
+        urlParams_   gensupport.URLParams
+        ifNoneMatch_ string
+        ctx_         context.Context
+        header_      http.Header
+}
+
+// Get: Get the email address of this project's Google Cloud Storage
+// service account.
+func (r *ProjectsServiceAccountService) Get(projectId string) *ProjectsServiceAccountGetCall {
+        c := &ProjectsServiceAccountGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
+        c.projectId = projectId
+        return c
+}
+
+// UserProject sets the optional parameter "userProject": The project to
+// be billed for this request.
+func (c *ProjectsServiceAccountGetCall) UserProject(userProject string) *ProjectsServiceAccountGetCall {
+        c.urlParams_.Set("userProject", userProject)
+        return c
+}
+
+// Fields allows partial responses to be retrieved. See
+// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
+// for more information.
+func (c *ProjectsServiceAccountGetCall) Fields(s ...googleapi.Field) *ProjectsServiceAccountGetCall {
+        c.urlParams_.Set("fields", googleapi.CombineFields(s))
+        return c
+}
+
+// IfNoneMatch sets the optional parameter which makes the operation
+// fail if the object's ETag matches the given value. This is useful for
+// getting updates only after the object has changed since the last
+// request. Use googleapi.IsNotModified to check whether the response
+// error from Do is the result of In-None-Match.
+func (c *ProjectsServiceAccountGetCall) IfNoneMatch(entityTag string) *ProjectsServiceAccountGetCall {
+        c.ifNoneMatch_ = entityTag
+        return c
+}
+
+// Context sets the context to be used in this call's Do method. Any
+// pending HTTP request will be aborted if the provided context is
+// canceled.
+func (c *ProjectsServiceAccountGetCall) Context(ctx context.Context) *ProjectsServiceAccountGetCall {
+        c.ctx_ = ctx
+        return c
+}
+
+// Header returns an http.Header that can be modified by the caller to
+// add HTTP headers to the request.
+func (c *ProjectsServiceAccountGetCall) Header() http.Header {
+        if c.header_ == nil {
+                c.header_ = make(http.Header)
+        }
+        return c.header_
+}
+
+func (c *ProjectsServiceAccountGetCall) doRequest(alt string) (*http.Response, error) {
+        reqHeaders := make(http.Header)
+        for k, v := range c.header_ {
+                reqHeaders[k] = v
+        }
+        reqHeaders.Set("User-Agent", c.s.userAgent())
+        if c.ifNoneMatch_ != "" {
+                reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
+        }
+        var body io.Reader = nil
+        c.urlParams_.Set("alt", alt)
+        c.urlParams_.Set("prettyPrint", "false")
+        urls := googleapi.ResolveRelative(c.s.BasePath, "projects/{projectId}/serviceAccount")
+        urls += "?" + c.urlParams_.Encode()
+        req, err := http.NewRequest("GET", urls, body)
+        if err != nil {
+                return nil, err
+        }
+        req.Header = reqHeaders
+        googleapi.Expand(req.URL, map[string]string{
+                "projectId": c.projectId,
+        })
+        return gensupport.SendRequest(c.ctx_, c.s.client, req)
+}
+
+// Do executes the "storage.projects.serviceAccount.get" call.
+// Exactly one of *ServiceAccount or error will be non-nil. Any non-2xx
+// status code is an error. Response headers are in either
+// *ServiceAccount.ServerResponse.Header or (if a response was returned
+// at all) in error.(*googleapi.Error).Header. Use
+// googleapi.IsNotModified to check whether the returned error was
+// because http.StatusNotModified was returned.
+func (c *ProjectsServiceAccountGetCall) Do(opts ...googleapi.CallOption) (*ServiceAccount, error) {
+        gensupport.SetOptions(c.urlParams_, opts...)
+        res, err := c.doRequest("json")
+        if res != nil && res.StatusCode == http.StatusNotModified {
+                if res.Body != nil {
+                        res.Body.Close()
+                }
+                return nil, &googleapi.Error{
+                        Code:   res.StatusCode,
+                        Header: res.Header,
+                }
+        }
+        if err != nil {
+                return nil, err
+        }
+        defer googleapi.CloseBody(res)
+        if err := googleapi.CheckResponse(res); err != nil {
+                return nil, err
+        }
+        ret := &ServiceAccount{
+                ServerResponse: googleapi.ServerResponse{
+                        Header:         res.Header,
+                        HTTPStatusCode: res.StatusCode,
+                },
+        }
+        target := &ret
+        if err := gensupport.DecodeResponse(target, res); err != nil {
+                return nil, err
+        }
+        return ret, nil
+        // {
+        //   "description": "Get the email address of this project's Google Cloud Storage service account.",
+        //   "httpMethod": "GET",
+        //   "id": "storage.projects.serviceAccount.get",
+        //   "parameterOrder": [
+        //     "projectId"
+        //   ],
+        //   "parameters": {
+        //     "projectId": {
+        //       "description": "Project ID",
+        //       "location": "path",
+        //       "required": true,
+        //       "type": "string"
+        //     },
+        //     "userProject": {
+        //       "description": "The project to be billed for this request.",
+        //       "location": "query",
+        //       "type": "string"
+        //     }
+        //   },
+        //   "path": "projects/{projectId}/serviceAccount",
+        //   "response": {
+        //     "$ref": "ServiceAccount"
+        //   },
+        //   "scopes": [
+        //     "https://www.googleapis.com/auth/cloud-platform",
+        //     "https://www.googleapis.com/auth/cloud-platform.read-only",
+        //     "https://www.googleapis.com/auth/devstorage.full_control",
+        //     "https://www.googleapis.com/auth/devstorage.read_only",
+        //     "https://www.googleapis.com/auth/devstorage.read_write"
+        //   ]
+        // }
+
+}
diff --git a/vendor/google.golang.org/api/transport/http/dial.go b/vendor/google.golang.org/api/transport/http/dial.go
new file mode 100644
index 0000000..a25da67
--- /dev/null
+++ b/vendor/google.golang.org/api/transport/http/dial.go
@@ -0,0 +1,147 @@
+// Copyright 2015 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package http supports network connections to HTTP servers.
+// This package is not intended for use by end developers. Use the
+// google.golang.org/api/option package to configure API clients.
+package http
+
+import (
+        "context"
+        "errors"
+        "net/http"
+
+        "go.opencensus.io/plugin/ochttp"
+        "golang.org/x/oauth2"
+        "google.golang.org/api/googleapi/transport"
+        "google.golang.org/api/internal"
+        "google.golang.org/api/option"
+        "google.golang.org/api/transport/http/internal/propagation"
+)
+
+// NewClient returns an HTTP client for use communicating with a Google cloud
+// service, configured with the given ClientOptions. It also returns the endpoint
+// for the service as specified in the options.
+func NewClient(ctx context.Context, opts ...option.ClientOption) (*http.Client, string, error) {
+        settings, err := newSettings(opts)
+        if err != nil {
+                return nil, "", err
+        }
+        // TODO(cbro): consider injecting the User-Agent even if an explicit HTTP client is provided?
+        if settings.HTTPClient != nil {
+                return settings.HTTPClient, settings.Endpoint, nil
+        }
+        trans, err := newTransport(ctx, defaultBaseTransport(ctx), settings)
+        if err != nil {
+                return nil, "", err
+        }
+        return &http.Client{Transport: trans}, settings.Endpoint, nil
+}
+
+// NewTransport creates an http.RoundTripper for use communicating with a Google
+// cloud service, configured with the given ClientOptions. Its RoundTrip method delegates to base.
+func NewTransport(ctx context.Context, base http.RoundTripper, opts ...option.ClientOption) (http.RoundTripper, error) {
+        settings, err := newSettings(opts)
+        if err != nil {
+                return nil, err
+        }
+        if settings.HTTPClient != nil {
+                return nil, errors.New("transport/http: WithHTTPClient passed to NewTransport")
+        }
+        return newTransport(ctx, base, settings)
+}
+
+func newTransport(ctx context.Context, base http.RoundTripper, settings *internal.DialSettings) (http.RoundTripper, error) {
+        trans := base
+        trans = userAgentTransport{
+                base:      trans,
+                userAgent: settings.UserAgent,
+        }
+        trans = addOCTransport(trans)
+        switch {
+        case settings.NoAuth:
+                // Do nothing.
+        case settings.APIKey != "":
+                trans = &transport.APIKey{
+                        Transport: trans,
+                        Key:       settings.APIKey,
+                }
+        default:
+                creds, err := internal.Creds(ctx, settings)
+                if err != nil {
+                        return nil, err
+                }
+                trans = &oauth2.Transport{
+                        Base:   trans,
+                        Source: creds.TokenSource,
+                }
+        }
+        return trans, nil
+}
+
+func newSettings(opts []option.ClientOption) (*internal.DialSettings, error) {
+        var o internal.DialSettings
+        for _, opt := range opts {
+                opt.Apply(&o)
+        }
+        if err := o.Validate(); err != nil {
+                return nil, err
+        }
+        if o.GRPCConn != nil {
+                return nil, errors.New("unsupported gRPC connection specified")
+        }
+        return &o, nil
+}
+
+type userAgentTransport struct {
+        userAgent string
+        base      http.RoundTripper
+}
+
+func (t userAgentTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+        rt := t.base
+        if rt == nil {
+                return nil, errors.New("transport: no Transport specified")
+        }
+        if t.userAgent == "" {
+                return rt.RoundTrip(req)
+        }
+        newReq := *req
+        newReq.Header = make(http.Header)
+        for k, vv := range req.Header {
+                newReq.Header[k] = vv
+        }
+        // TODO(cbro): append to existing User-Agent header?
+        newReq.Header["User-Agent"] = []string{t.userAgent}
+        return rt.RoundTrip(&newReq)
+}
+
+// Set at init time by dial_appengine.go. If nil, we're not on App Engine.
+var appengineUrlfetchHook func(context.Context) http.RoundTripper
+
+// defaultBaseTransport returns the base HTTP transport.
+// On App Engine, this is urlfetch.Transport, otherwise it's http.DefaultTransport.
+func defaultBaseTransport(ctx context.Context) http.RoundTripper {
+        if appengineUrlfetchHook != nil {
+                return appengineUrlfetchHook(ctx)
+        }
+        return http.DefaultTransport
+}
+
+func addOCTransport(trans http.RoundTripper) http.RoundTripper {
+        return &ochttp.Transport{
+                Base:        trans,
+                Propagation: &propagation.HTTPFormat{},
+        }
+}
diff --git a/vendor/google.golang.org/grpc/health/grpc_health_v1/health.proto b/vendor/google.golang.org/api/transport/http/dial_appengine.go
index 6072fdc..04c8141 100644
--- a/vendor/google.golang.org/grpc/health/grpc_health_v1/health.proto
+++ b/vendor/google.golang.org/api/transport/http/dial_appengine.go
@@ -1,10 +1,10 @@
-// Copyright 2017 gRPC authors.
+// Copyright 2016 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
+//      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ -12,23 +12,19 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-syntax = "proto3";
+// +build appengine
 
-package grpc.health.v1;
+package http
 
-message HealthCheckRequest {
-  string service = 1;
-}
+import (
+        "context"
+        "net/http"
 
-message HealthCheckResponse {
-  enum ServingStatus {
-        UNKNOWN = 0;
-        SERVING = 1;
-        NOT_SERVING = 2;
-  }
-  ServingStatus status = 1;
-}
+        "google.golang.org/appengine/urlfetch"
+)
 
-service Health{
-  rpc Check(HealthCheckRequest) returns (HealthCheckResponse);
-} 
+func init() {
+        appengineUrlfetchHook = func(ctx context.Context) http.RoundTripper {
+                return &urlfetch.Transport{Context: ctx}
+        }
+}
diff --git a/vendor/google.golang.org/api/transport/http/internal/propagation/http.go b/vendor/google.golang.org/api/transport/http/internal/propagation/http.go
new file mode 100644
index 0000000..24b4f0d
--- /dev/null
+++ b/vendor/google.golang.org/api/transport/http/internal/propagation/http.go
@@ -0,0 +1,96 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build go1.8
+
+// Package propagation implements X-Cloud-Trace-Context header propagation used
+// by Google Cloud products.
+package propagation
+
+import (
+        "encoding/binary"
+        "encoding/hex"
+        "fmt"
+        "net/http"
+        "strconv"
+        "strings"
+
+        "go.opencensus.io/trace"
+        "go.opencensus.io/trace/propagation"
+)
+
+const (
+        httpHeaderMaxSize = 200
+        httpHeader        = `X-Cloud-Trace-Context`
+)
+
+var _ propagation.HTTPFormat = (*HTTPFormat)(nil)
+
+// HTTPFormat implements propagation.HTTPFormat to propagate
+// traces in HTTP headers for Google Cloud Platform and Stackdriver Trace.
+type HTTPFormat struct{}
+
+// SpanContextFromRequest extracts a Stackdriver Trace span context from incoming requests.
+func (f *HTTPFormat) SpanContextFromRequest(req *http.Request) (sc trace.SpanContext, ok bool) {
+        h := req.Header.Get(httpHeader)
+        // See https://cloud.google.com/trace/docs/faq for the header HTTPFormat.
+        // Return if the header is empty or missing, or if the header is unreasonably
+        // large, to avoid making unnecessary copies of a large string.
+        if h == "" || len(h) > httpHeaderMaxSize {
+                return trace.SpanContext{}, false
+        }
+
+        // Parse the trace id field.
+        slash := strings.Index(h, `/`)
+        if slash == -1 {
+                return trace.SpanContext{}, false
+        }
+        tid, h := h[:slash], h[slash+1:]
+
+        buf, err := hex.DecodeString(tid)
+        if err != nil {
+                return trace.SpanContext{}, false
+        }
+        copy(sc.TraceID[:], buf)
+
+        // Parse the span id field.
+        spanstr := h
+        semicolon := strings.Index(h, `;`)
+        if semicolon != -1 {
+                spanstr, h = h[:semicolon], h[semicolon+1:]
+        }
+        sid, err := strconv.ParseUint(spanstr, 10, 64)
+        if err != nil {
+                return trace.SpanContext{}, false
+        }
+        binary.BigEndian.PutUint64(sc.SpanID[:], sid)
+
+        // Parse the options field, options field is optional.
+        if !strings.HasPrefix(h, "o=") {
+                return sc, true
+        }
+        o, err := strconv.ParseUint(h[2:], 10, 64)
+        if err != nil {
+                return trace.SpanContext{}, false
+        }
+        sc.TraceOptions = trace.TraceOptions(o)
+        return sc, true
+}
+
+// SpanContextToRequest modifies the given request to include a Stackdriver Trace header.
+func (f *HTTPFormat) SpanContextToRequest(sc trace.SpanContext, req *http.Request) {
+        sid := binary.BigEndian.Uint64(sc.SpanID[:])
+        header := fmt.Sprintf("%s/%d;o=%d", hex.EncodeToString(sc.TraceID[:]), sid, int64(sc.TraceOptions))
+        req.Header.Set(httpHeader, header)
+}
diff --git a/vendor/google.golang.org/appengine/.travis.yml b/vendor/google.golang.org/appengine/.travis.yml
new file mode 100644
index 0000000..70ffe89
--- /dev/null
+++ b/vendor/google.golang.org/appengine/.travis.yml
@@ -0,0 +1,20 @@
+language: go
+
+go_import_path: google.golang.org/appengine
+
+install:
+  - ./travis_install.sh
+
+script:
+  - ./travis_test.sh
+
+matrix:
+  include:
+    - go: 1.8.x
+      env: GOAPP=true
+    - go: 1.9.x
+      env: GOAPP=true
+    - go: 1.10.x
+      env: GOAPP=false
+    - go: 1.11.x
+      env: GO111MODULE=on
diff --git a/vendor/google.golang.org/appengine/CONTRIBUTING.md b/vendor/google.golang.org/appengine/CONTRIBUTING.md
new file mode 100644
index 0000000..ffc2985
--- /dev/null
+++ b/vendor/google.golang.org/appengine/CONTRIBUTING.md
@@ -0,0 +1,90 @@
+# Contributing
+
+1. Sign one of the contributor license agreements below.
+1. Get the package:
+
+    `go get -d google.golang.org/appengine`
+1. Change into the checked out source:
+
+    `cd $GOPATH/src/google.golang.org/appengine`
+1. Fork the repo.
+1. Set your fork as a remote:
+
+    `git remote add fork git@github.com:GITHUB_USERNAME/appengine.git`
+1. Make changes, commit to your fork.
+1. Send a pull request with your changes. 
+   The first line of your commit message is conventionally a one-line summary of the change, prefixed by the primary affected package, and is used as the title of your pull request.
+
+# Testing
+
+## Running system tests
+
+Download and install the [Go App Engine SDK](https://cloud.google.com/appengine/docs/go/download). Make sure the `go_appengine` dir is in your `PATH`.
+
+Set the `APPENGINE_DEV_APPSERVER` environment variable to `/path/to/go_appengine/dev_appserver.py`.
+
+Run tests with `goapp test`:
+
+```
+goapp test -v google.golang.org/appengine/...
+```
+
+## Contributor License Agreements
+
+Before we can accept your pull requests you'll need to sign a Contributor
+License Agreement (CLA):
+
+- **If you are an individual writing original source code** and **you own the
+intellectual property**, then you'll need to sign an [individual CLA][indvcla].
+- **If you work for a company that wants to allow you to contribute your work**,
+then you'll need to sign a [corporate CLA][corpcla].
+
+You can sign these electronically (just scroll to the bottom). After that,
+we'll be able to accept your pull requests.
+
+## Contributor Code of Conduct
+
+As contributors and maintainers of this project,
+and in the interest of fostering an open and welcoming community,
+we pledge to respect all people who contribute through reporting issues,
+posting feature requests, updating documentation,
+submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project
+a harassment-free experience for everyone,
+regardless of level of experience, gender, gender identity and expression,
+sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information,
+such as physical or electronic
+addresses, without explicit permission
+* Other unethical or unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct.
+By adopting this Code of Conduct,
+project maintainers commit themselves to fairly and consistently
+applying these principles to every aspect of managing this project.
+Project maintainers who do not follow or enforce the Code of Conduct
+may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior
+may be reported by opening an issue
+or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.2.0,
+available at [http://contributor-covenant.org/version/1/2/0/](http://contributor-covenant.org/version/1/2/0/)
+
+[indvcla]: https://developers.google.com/open-source/cla/individual
+[corpcla]: https://developers.google.com/open-source/cla/corporate
diff --git a/vendor/google.golang.org/appengine/LICENSE b/vendor/google.golang.org/appengine/LICENSE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/vendor/google.golang.org/appengine/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/vendor/google.golang.org/appengine/README.md b/vendor/google.golang.org/appengine/README.md
new file mode 100644
index 0000000..d86768a
--- /dev/null
+++ b/vendor/google.golang.org/appengine/README.md
@@ -0,0 +1,73 @@
+# Go App Engine packages
+
+[![Build Status](https://travis-ci.org/golang/appengine.svg)](https://travis-ci.org/golang/appengine)
+
+This repository supports the Go runtime on *App Engine standard*.
+It provides APIs for interacting with App Engine services.
+Its canonical import path is `google.golang.org/appengine`.
+
+See https://cloud.google.com/appengine/docs/go/
+for more information.
+
+File issue reports and feature requests on the [GitHub's issue
+tracker](https://github.com/golang/appengine/issues).
+
+## Upgrading an App Engine app to the flexible environment
+
+This package does not work on *App Engine flexible*.
+
+There are many differences between the App Engine standard environment and
+the flexible environment.
+
+See the [documentation on upgrading to the flexible environment](https://cloud.google.com/appengine/docs/flexible/go/upgrading).
+
+## Directory structure
+
+The top level directory of this repository is the `appengine` package. It
+contains the
+basic APIs (e.g. `appengine.NewContext`) that apply across APIs. Specific API
+packages are in subdirectories (e.g. `datastore`).
+
+There is an `internal` subdirectory that contains service protocol buffers,
+plus packages required for connectivity to make API calls. App Engine apps
+should not directly import any package under `internal`.
+
+## Updating from legacy (`import "appengine"`) packages
+
+If you're currently using the bare `appengine` packages
+(that is, not these ones, imported via `google.golang.org/appengine`),
+then you can use the `aefix` tool to help automate an upgrade to these packages.
+
+Run `go get google.golang.org/appengine/cmd/aefix` to install it.
+
+### 1. Update import paths
+
+The import paths for App Engine packages are now fully qualified, based at `google.golang.org/appengine`.
+You will need to update your code to use import paths starting with that; for instance,
+code importing `appengine/datastore` will now need to import `google.golang.org/appengine/datastore`.
+
+### 2. Update code using deprecated, removed or modified APIs
+
+Most App Engine services are available with exactly the same API.
+A few APIs were cleaned up, and there are some differences:
+
+* `appengine.Context` has been replaced with the `Context` type from `golang.org/x/net/context`.
+* Logging methods that were on `appengine.Context` are now functions in `google.golang.org/appengine/log`.
+* `appengine.Timeout` has been removed. Use `context.WithTimeout` instead.
+* `appengine.Datacenter` now takes a `context.Context` argument.
+* `datastore.PropertyLoadSaver` has been simplified to use slices in place of channels.
+* `delay.Call` now returns an error.
+* `search.FieldLoadSaver` now handles document metadata.
+* `urlfetch.Transport` no longer has a Deadline field; set a deadline on the
+  `context.Context` instead.
+* `aetest` no longer declares its own Context type, and uses the standard one instead.
+* `taskqueue.QueueStats` no longer takes a maxTasks argument. That argument has been
+  deprecated and unused for a long time.
+* `appengine.BackendHostname` and `appengine.BackendInstance` were for the deprecated backends feature.
+  Use `appengine.ModuleHostname`and `appengine.ModuleName` instead.
+* Most of `appengine/file` and parts of `appengine/blobstore` are deprecated.
+  Use [Google Cloud Storage](https://godoc.org/cloud.google.com/go/storage) if the
+  feature you require is not present in the new
+  [blobstore package](https://google.golang.org/appengine/blobstore).
+* `appengine/socket` is not required on App Engine flexible environment / Managed VMs.
+  Use the standard `net` package instead.
diff --git a/vendor/google.golang.org/appengine/appengine.go b/vendor/google.golang.org/appengine/appengine.go
new file mode 100644
index 0000000..0cca033
--- /dev/null
+++ b/vendor/google.golang.org/appengine/appengine.go
@@ -0,0 +1,137 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// Package appengine provides basic functionality for Google App Engine.
+//
+// For more information on how to write Go apps for Google App Engine, see:
+// https://cloud.google.com/appengine/docs/go/
+package appengine // import "google.golang.org/appengine"
+
+import (
+        "net/http"
+
+        "github.com/golang/protobuf/proto"
+        "golang.org/x/net/context"
+
+        "google.golang.org/appengine/internal"
+)
+
+// The gophers party all night; the rabbits provide the beats.
+
+// Main is the principal entry point for an app running in App Engine.
+//
+// On App Engine Flexible it installs a trivial health checker if one isn't
+// already registered, and starts listening on port 8080 (overridden by the
+// $PORT environment variable).
+//
+// See https://cloud.google.com/appengine/docs/flexible/custom-runtimes#health_check_requests
+// for details on how to do your own health checking.
+//
+// On App Engine Standard it ensures the server has started and is prepared to
+// receive requests.
+//
+// Main never returns.
+//
+// Main is designed so that the app's main package looks like this:
+//
+//      package main
+//
+//      import (
+//              "google.golang.org/appengine"
+//
+//              _ "myapp/package0"
+//              _ "myapp/package1"
+//      )
+//
+//      func main() {
+//              appengine.Main()
+//      }
+//
+// The "myapp/packageX" packages are expected to register HTTP handlers
+// in their init functions.
+func Main() {
+        internal.Main()
+}
+
+// IsDevAppServer reports whether the App Engine app is running in the
+// development App Server.
+func IsDevAppServer() bool {
+        return internal.IsDevAppServer()
+}
+
+// IsStandard reports whether the App Engine app is running in the standard
+// environment. This includes both the first generation runtimes (<= Go 1.9)
+// and the second generation runtimes (>= Go 1.11).
+func IsStandard() bool {
+        return internal.IsStandard()
+}
+
+// IsFlex reports whether the App Engine app is running in the flexible environment.
+func IsFlex() bool {
+        return internal.IsFlex()
+}
+
+// IsAppEngine reports whether the App Engine app is running on App Engine, in either
+// the standard or flexible environment.
+func IsAppEngine() bool {
+        return internal.IsAppEngine()
+}
+
+// IsSecondGen reports whether the App Engine app is running on the second generation
+// runtimes (>= Go 1.11).
+func IsSecondGen() bool {
+        return internal.IsSecondGen()
+}
+
+// NewContext returns a context for an in-flight HTTP request.
+// This function is cheap.
+func NewContext(req *http.Request) context.Context {
+        return internal.ReqContext(req)
+}
+
+// WithContext returns a copy of the parent context
+// and associates it with an in-flight HTTP request.
+// This function is cheap.
+func WithContext(parent context.Context, req *http.Request) context.Context {
+        return internal.WithContext(parent, req)
+}
+
+// TODO(dsymonds): Add a Call function here? Otherwise other packages can't access internal.Call.
+
+// BlobKey is a key for a blobstore blob.
+//
+// Conceptually, this type belongs in the blobstore package, but it lives in
+// the appengine package to avoid a circular dependency: blobstore depends on
+// datastore, and datastore needs to refer to the BlobKey type.
+type BlobKey string
+
+// GeoPoint represents a location as latitude/longitude in degrees.
+type GeoPoint struct {
+        Lat, Lng float64
+}
+
+// Valid returns whether a GeoPoint is within [-90, 90] latitude and [-180, 180] longitude.
+func (g GeoPoint) Valid() bool {
+        return -90 <= g.Lat && g.Lat <= 90 && -180 <= g.Lng && g.Lng <= 180
+}
+
+// APICallFunc defines a function type for handling an API call.
+// See WithCallOverride.
+type APICallFunc func(ctx context.Context, service, method string, in, out proto.Message) error
+
+// WithAPICallFunc returns a copy of the parent context
+// that will cause API calls to invoke f instead of their normal operation.
+//
+// This is intended for advanced users only.
+func WithAPICallFunc(ctx context.Context, f APICallFunc) context.Context {
+        return internal.WithCallOverride(ctx, internal.CallOverrideFunc(f))
+}
+
+// APICall performs an API call.
+//
+// This is not intended for general use; it is exported for use in conjunction
+// with WithAPICallFunc.
+func APICall(ctx context.Context, service, method string, in, out proto.Message) error {
+        return internal.Call(ctx, service, method, in, out)
+}
diff --git a/vendor/google.golang.org/appengine/appengine_vm.go b/vendor/google.golang.org/appengine/appengine_vm.go
new file mode 100644
index 0000000..f4b645a
--- /dev/null
+++ b/vendor/google.golang.org/appengine/appengine_vm.go
@@ -0,0 +1,20 @@
+// Copyright 2015 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build !appengine
+
+package appengine
+
+import (
+        "golang.org/x/net/context"
+
+        "google.golang.org/appengine/internal"
+)
+
+// BackgroundContext returns a context not associated with a request.
+// This should only be used when not servicing a request.
+// This only works in App Engine "flexible environment".
+func BackgroundContext() context.Context {
+        return internal.BackgroundContext()
+}
diff --git a/vendor/google.golang.org/appengine/datastore/datastore.go b/vendor/google.golang.org/appengine/datastore/datastore.go
new file mode 100644
index 0000000..576bc50
--- /dev/null
+++ b/vendor/google.golang.org/appengine/datastore/datastore.go
@@ -0,0 +1,407 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package datastore
+
+import (
+        "errors"
+        "fmt"
+        "reflect"
+
+        "github.com/golang/protobuf/proto"
+        "golang.org/x/net/context"
+
+        "google.golang.org/appengine"
+        "google.golang.org/appengine/internal"
+        pb "google.golang.org/appengine/internal/datastore"
+)
+
+var (
+        // ErrInvalidEntityType is returned when functions like Get or Next are
+        // passed a dst or src argument of invalid type.
+        ErrInvalidEntityType = errors.New("datastore: invalid entity type")
+        // ErrInvalidKey is returned when an invalid key is presented.
+        ErrInvalidKey = errors.New("datastore: invalid key")
+        // ErrNoSuchEntity is returned when no entity was found for a given key.
+        ErrNoSuchEntity = errors.New("datastore: no such entity")
+)
+
+// ErrFieldMismatch is returned when a field is to be loaded into a different
+// type than the one it was stored from, or when a field is missing or
+// unexported in the destination struct.
+// StructType is the type of the struct pointed to by the destination argument
+// passed to Get or to Iterator.Next.
+type ErrFieldMismatch struct {
+        StructType reflect.Type
+        FieldName  string
+        Reason     string
+}
+
+func (e *ErrFieldMismatch) Error() string {
+        return fmt.Sprintf("datastore: cannot load field %q into a %q: %s",
+                e.FieldName, e.StructType, e.Reason)
+}
+
+// protoToKey converts a Reference proto to a *Key. If the key is invalid,
+// protoToKey will return the invalid key along with ErrInvalidKey.
+func protoToKey(r *pb.Reference) (k *Key, err error) {
+        appID := r.GetApp()
+        namespace := r.GetNameSpace()
+        for _, e := range r.Path.Element {
+                k = &Key{
+                        kind:      e.GetType(),
+                        stringID:  e.GetName(),
+                        intID:     e.GetId(),
+                        parent:    k,
+                        appID:     appID,
+                        namespace: namespace,
+                }
+                if !k.valid() {
+                        return k, ErrInvalidKey
+                }
+        }
+        return
+}
+
+// keyToProto converts a *Key to a Reference proto.
+func keyToProto(defaultAppID string, k *Key) *pb.Reference {
+        appID := k.appID
+        if appID == "" {
+                appID = defaultAppID
+        }
+        n := 0
+        for i := k; i != nil; i = i.parent {
+                n++
+        }
+        e := make([]*pb.Path_Element, n)
+        for i := k; i != nil; i = i.parent {
+                n--
+                e[n] = &pb.Path_Element{
+                        Type: &i.kind,
+                }
+                // At most one of {Name,Id} should be set.
+                // Neither will be set for incomplete keys.
+                if i.stringID != "" {
+                        e[n].Name = &i.stringID
+                } else if i.intID != 0 {
+                        e[n].Id = &i.intID
+                }
+        }
+        var namespace *string
+        if k.namespace != "" {
+                namespace = proto.String(k.namespace)
+        }
+        return &pb.Reference{
+                App:       proto.String(appID),
+                NameSpace: namespace,
+                Path: &pb.Path{
+                        Element: e,
+                },
+        }
+}
+
+// multiKeyToProto is a batch version of keyToProto.
+func multiKeyToProto(appID string, key []*Key) []*pb.Reference {
+        ret := make([]*pb.Reference, len(key))
+        for i, k := range key {
+                ret[i] = keyToProto(appID, k)
+        }
+        return ret
+}
+
+// multiValid is a batch version of Key.valid. It returns an error, not a
+// []bool.
+func multiValid(key []*Key) error {
+        invalid := false
+        for _, k := range key {
+                if !k.valid() {
+                        invalid = true
+                        break
+                }
+        }
+        if !invalid {
+                return nil
+        }
+        err := make(appengine.MultiError, len(key))
+        for i, k := range key {
+                if !k.valid() {
+                        err[i] = ErrInvalidKey
+                }
+        }
+        return err
+}
+
+// It's unfortunate that the two semantically equivalent concepts pb.Reference
+// and pb.PropertyValue_ReferenceValue aren't the same type. For example, the
+// two have different protobuf field numbers.
+
+// referenceValueToKey is the same as protoToKey except the input is a
+// PropertyValue_ReferenceValue instead of a Reference.
+func referenceValueToKey(r *pb.PropertyValue_ReferenceValue) (k *Key, err error) {
+        appID := r.GetApp()
+        namespace := r.GetNameSpace()
+        for _, e := range r.Pathelement {
+                k = &Key{
+                        kind:      e.GetType(),
+                        stringID:  e.GetName(),
+                        intID:     e.GetId(),
+                        parent:    k,
+                        appID:     appID,
+                        namespace: namespace,
+                }
+                if !k.valid() {
+                        return nil, ErrInvalidKey
+                }
+        }
+        return
+}
+
+// keyToReferenceValue is the same as keyToProto except the output is a
+// PropertyValue_ReferenceValue instead of a Reference.
+func keyToReferenceValue(defaultAppID string, k *Key) *pb.PropertyValue_ReferenceValue {
+        ref := keyToProto(defaultAppID, k)
+        pe := make([]*pb.PropertyValue_ReferenceValue_PathElement, len(ref.Path.Element))
+        for i, e := range ref.Path.Element {
+                pe[i] = &pb.PropertyValue_ReferenceValue_PathElement{
+                        Type: e.Type,
+                        Id:   e.Id,
+                        Name: e.Name,
+                }
+        }
+        return &pb.PropertyValue_ReferenceValue{
+                App:         ref.App,
+                NameSpace:   ref.NameSpace,
+                Pathelement: pe,
+        }
+}
+
+type multiArgType int
+
+const (
+        multiArgTypeInvalid multiArgType = iota
+        multiArgTypePropertyLoadSaver
+        multiArgTypeStruct
+        multiArgTypeStructPtr
+        multiArgTypeInterface
+)
+
+// checkMultiArg checks that v has type []S, []*S, []I, or []P, for some struct
+// type S, for some interface type I, or some non-interface non-pointer type P
+// such that P or *P implements PropertyLoadSaver.
+//
+// It returns what category the slice's elements are, and the reflect.Type
+// that represents S, I or P.
+//
+// As a special case, PropertyList is an invalid type for v.
+func checkMultiArg(v reflect.Value) (m multiArgType, elemType reflect.Type) {
+        if v.Kind() != reflect.Slice {
+                return multiArgTypeInvalid, nil
+        }
+        if v.Type() == typeOfPropertyList {
+                return multiArgTypeInvalid, nil
+        }
+        elemType = v.Type().Elem()
+        if reflect.PtrTo(elemType).Implements(typeOfPropertyLoadSaver) {
+                return multiArgTypePropertyLoadSaver, elemType
+        }
+        switch elemType.Kind() {
+        case reflect.Struct:
+                return multiArgTypeStruct, elemType
+        case reflect.Interface:
+                return multiArgTypeInterface, elemType
+        case reflect.Ptr:
+                elemType = elemType.Elem()
+                if elemType.Kind() == reflect.Struct {
+                        return multiArgTypeStructPtr, elemType
+                }
+        }
+        return multiArgTypeInvalid, nil
+}
+
+// Get loads the entity stored for k into dst, which must be a struct pointer
+// or implement PropertyLoadSaver. If there is no such entity for the key, Get
+// returns ErrNoSuchEntity.
+//
+// The values of dst's unmatched struct fields are not modified, and matching
+// slice-typed fields are not reset before appending to them. In particular, it
+// is recommended to pass a pointer to a zero valued struct on each Get call.
+//
+// ErrFieldMismatch is returned when a field is to be loaded into a different
+// type than the one it was stored from, or when a field is missing or
+// unexported in the destination struct. ErrFieldMismatch is only returned if
+// dst is a struct pointer.
+func Get(c context.Context, key *Key, dst interface{}) error {
+        if dst == nil { // GetMulti catches nil interface; we need to catch nil ptr here
+                return ErrInvalidEntityType
+        }
+        err := GetMulti(c, []*Key{key}, []interface{}{dst})
+        if me, ok := err.(appengine.MultiError); ok {
+                return me[0]
+        }
+        return err
+}
+
+// GetMulti is a batch version of Get.
+//
+// dst must be a []S, []*S, []I or []P, for some struct type S, some interface
+// type I, or some non-interface non-pointer type P such that P or *P
+// implements PropertyLoadSaver. If an []I, each element must be a valid dst
+// for Get: it must be a struct pointer or implement PropertyLoadSaver.
+//
+// As a special case, PropertyList is an invalid type for dst, even though a
+// PropertyList is a slice of structs. It is treated as invalid to avoid being
+// mistakenly passed when []PropertyList was intended.
+func GetMulti(c context.Context, key []*Key, dst interface{}) error {
+        v := reflect.ValueOf(dst)
+        multiArgType, _ := checkMultiArg(v)
+        if multiArgType == multiArgTypeInvalid {
+                return errors.New("datastore: dst has invalid type")
+        }
+        if len(key) != v.Len() {
+                return errors.New("datastore: key and dst slices have different length")
+        }
+        if len(key) == 0 {
+                return nil
+        }
+        if err := multiValid(key); err != nil {
+                return err
+        }
+        req := &pb.GetRequest{
+                Key: multiKeyToProto(internal.FullyQualifiedAppID(c), key),
+        }
+        res := &pb.GetResponse{}
+        if err := internal.Call(c, "datastore_v3", "Get", req, res); err != nil {
+                return err
+        }
+        if len(key) != len(res.Entity) {
+                return errors.New("datastore: internal error: server returned the wrong number of entities")
+        }
+        multiErr, any := make(appengine.MultiError, len(key)), false
+        for i, e := range res.Entity {
+                if e.Entity == nil {
+                        multiErr[i] = ErrNoSuchEntity
+                } else {
+                        elem := v.Index(i)
+                        if multiArgType == multiArgTypePropertyLoadSaver || multiArgType == multiArgTypeStruct {
+                                elem = elem.Addr()
+                        }
+                        if multiArgType == multiArgTypeStructPtr && elem.IsNil() {
+                                elem.Set(reflect.New(elem.Type().Elem()))
+                        }
+                        multiErr[i] = loadEntity(elem.Interface(), e.Entity)
+                }
+                if multiErr[i] != nil {
+                        any = true
+                }
+        }
+        if any {
+                return multiErr
+        }
+        return nil
+}
+
+// Put saves the entity src into the datastore with key k. src must be a struct
+// pointer or implement PropertyLoadSaver; if a struct pointer then any
+// unexported fields of that struct will be skipped. If k is an incomplete key,
+// the returned key will be a unique key generated by the datastore.
+func Put(c context.Context, key *Key, src interface{}) (*Key, error) {
+        k, err := PutMulti(c, []*Key{key}, []interface{}{src})
+        if err != nil {
+                if me, ok := err.(appengine.MultiError); ok {
+                        return nil, me[0]
+                }
+                return nil, err
+        }
+        return k[0], nil
+}
+
+// PutMulti is a batch version of Put.
+//
+// src must satisfy the same conditions as the dst argument to GetMulti.
+func PutMulti(c context.Context, key []*Key, src interface{}) ([]*Key, error) {
+        v := reflect.ValueOf(src)
+        multiArgType, _ := checkMultiArg(v)
+        if multiArgType == multiArgTypeInvalid {
+                return nil, errors.New("datastore: src has invalid type")
+        }
+        if len(key) != v.Len() {
+                return nil, errors.New("datastore: key and src slices have different length")
+        }
+        if len(key) == 0 {
+                return nil, nil
+        }
+        appID := internal.FullyQualifiedAppID(c)
+        if err := multiValid(key); err != nil {
+                return nil, err
+        }
+        req := &pb.PutRequest{}
+        for i := range key {
+                elem := v.Index(i)
+                if multiArgType == multiArgTypePropertyLoadSaver || multiArgType == multiArgTypeStruct {
+                        elem = elem.Addr()
+                }
+                sProto, err := saveEntity(appID, key[i], elem.Interface())
+                if err != nil {
+                        return nil, err
+                }
+                req.Entity = append(req.Entity, sProto)
+        }
+        res := &pb.PutResponse{}
+        if err := internal.Call(c, "datastore_v3", "Put", req, res); err != nil {
+                return nil, err
+        }
+        if len(key) != len(res.Key) {
+                return nil, errors.New("datastore: internal error: server returned the wrong number of keys")
+        }
+        ret := make([]*Key, len(key))
+        for i := range ret {
+                var err error
+                ret[i], err = protoToKey(res.Key[i])
+                if err != nil || ret[i].Incomplete() {
+                        return nil, errors.New("datastore: internal error: server returned an invalid key")
+                }
+        }
+        return ret, nil
+}
+
+// Delete deletes the entity for the given key.
+func Delete(c context.Context, key *Key) error {
+        err := DeleteMulti(c, []*Key{key})
+        if me, ok := err.(appengine.MultiError); ok {
+                return me[0]
+        }
+        return err
+}
+
+// DeleteMulti is a batch version of Delete.
+func DeleteMulti(c context.Context, key []*Key) error {
+        if len(key) == 0 {
+                return nil
+        }
+        if err := multiValid(key); err != nil {
+                return err
+        }
+        req := &pb.DeleteRequest{
+                Key: multiKeyToProto(internal.FullyQualifiedAppID(c), key),
+        }
+        res := &pb.DeleteResponse{}
+        return internal.Call(c, "datastore_v3", "Delete", req, res)
+}
+
+func namespaceMod(m proto.Message, namespace string) {
+        // pb.Query is the only type that has a name_space field.
+        // All other namespace support in datastore is in the keys.
+        switch m := m.(type) {
+        case *pb.Query:
+                if m.NameSpace == nil {
+                        m.NameSpace = &namespace
+                }
+        }
+}
+
+func init() {
+        internal.NamespaceMods["datastore_v3"] = namespaceMod
+        internal.RegisterErrorCodeMap("datastore_v3", pb.Error_ErrorCode_name)
+        internal.RegisterTimeoutErrorCode("datastore_v3", int32(pb.Error_TIMEOUT))
+}
diff --git a/vendor/google.golang.org/appengine/datastore/doc.go b/vendor/google.golang.org/appengine/datastore/doc.go
new file mode 100644
index 0000000..85616cf
--- /dev/null
+++ b/vendor/google.golang.org/appengine/datastore/doc.go
@@ -0,0 +1,361 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+/*
+Package datastore provides a client for App Engine's datastore service.
+
+
+Basic Operations
+
+Entities are the unit of storage and are associated with a key. A key
+consists of an optional parent key, a string application ID, a string kind
+(also known as an entity type), and either a StringID or an IntID. A
+StringID is also known as an entity name or key name.
+
+It is valid to create a key with a zero StringID and a zero IntID; this is
+called an incomplete key, and does not refer to any saved entity. Putting an
+entity into the datastore under an incomplete key will cause a unique key
+to be generated for that entity, with a non-zero IntID.
+
+An entity's contents are a mapping from case-sensitive field names to values.
+Valid value types are:
+  - signed integers (int, int8, int16, int32 and int64),
+  - bool,
+  - string,
+  - float32 and float64,
+  - []byte (up to 1 megabyte in length),
+  - any type whose underlying type is one of the above predeclared types,
+  - ByteString,
+  - *Key,
+  - time.Time (stored with microsecond precision),
+  - appengine.BlobKey,
+  - appengine.GeoPoint,
+  - structs whose fields are all valid value types,
+  - slices of any of the above.
+
+Slices of structs are valid, as are structs that contain slices. However, if
+one struct contains another, then at most one of those can be repeated. This
+disqualifies recursively defined struct types: any struct T that (directly or
+indirectly) contains a []T.
+
+The Get and Put functions load and save an entity's contents. An entity's
+contents are typically represented by a struct pointer.
+
+Example code:
+
+        type Entity struct {
+                Value string
+        }
+
+        func handle(w http.ResponseWriter, r *http.Request) {
+                ctx := appengine.NewContext(r)
+
+                k := datastore.NewKey(ctx, "Entity", "stringID", 0, nil)
+                e := new(Entity)
+                if err := datastore.Get(ctx, k, e); err != nil {
+                        http.Error(w, err.Error(), 500)
+                        return
+                }
+
+                old := e.Value
+                e.Value = r.URL.Path
+
+                if _, err := datastore.Put(ctx, k, e); err != nil {
+                        http.Error(w, err.Error(), 500)
+                        return
+                }
+
+                w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+                fmt.Fprintf(w, "old=%q\nnew=%q\n", old, e.Value)
+        }
+
+GetMulti, PutMulti and DeleteMulti are batch versions of the Get, Put and
+Delete functions. They take a []*Key instead of a *Key, and may return an
+appengine.MultiError when encountering partial failure.
+
+
+Properties
+
+An entity's contents can be represented by a variety of types. These are
+typically struct pointers, but can also be any type that implements the
+PropertyLoadSaver interface. If using a struct pointer, you do not have to
+explicitly implement the PropertyLoadSaver interface; the datastore will
+automatically convert via reflection. If a struct pointer does implement that
+interface then those methods will be used in preference to the default
+behavior for struct pointers. Struct pointers are more strongly typed and are
+easier to use; PropertyLoadSavers are more flexible.
+
+The actual types passed do not have to match between Get and Put calls or even
+across different calls to datastore. It is valid to put a *PropertyList and
+get that same entity as a *myStruct, or put a *myStruct0 and get a *myStruct1.
+Conceptually, any entity is saved as a sequence of properties, and is loaded
+into the destination value on a property-by-property basis. When loading into
+a struct pointer, an entity that cannot be completely represented (such as a
+missing field) will result in an ErrFieldMismatch error but it is up to the
+caller whether this error is fatal, recoverable or ignorable.
+
+By default, for struct pointers, all properties are potentially indexed, and
+the property name is the same as the field name (and hence must start with an
+upper case letter).
+
+Fields may have a `datastore:"name,options"` tag. The tag name is the
+property name, which must be one or more valid Go identifiers joined by ".",
+but may start with a lower case letter. An empty tag name means to just use the
+field name. A "-" tag name means that the datastore will ignore that field.
+
+The only valid options are "omitempty" and "noindex".
+
+If the options include "omitempty" and the value of the field is empty, then the field will be omitted on Save.
+The empty values are false, 0, any nil interface value, and any array, slice, map, or string of length zero.
+Struct field values will never be empty.
+
+If options include "noindex" then the field will not be indexed. All fields are indexed
+by default. Strings or byte slices longer than 1500 bytes cannot be indexed;
+fields used to store long strings and byte slices must be tagged with "noindex"
+or they will cause Put operations to fail.
+
+To use multiple options together, separate them by a comma.
+The order does not matter.
+
+If the options is "" then the comma may be omitted.
+
+Example code:
+
+        // A and B are renamed to a and b.
+        // A, C and J are not indexed.
+        // D's tag is equivalent to having no tag at all (E).
+        // I is ignored entirely by the datastore.
+        // J has tag information for both the datastore and json packages.
+        type TaggedStruct struct {
+                A int `datastore:"a,noindex"`
+                B int `datastore:"b"`
+                C int `datastore:",noindex"`
+                D int `datastore:""`
+                E int
+                I int `datastore:"-"`
+                J int `datastore:",noindex" json:"j"`
+        }
+
+
+Structured Properties
+
+If the struct pointed to contains other structs, then the nested or embedded
+structs are flattened. For example, given these definitions:
+
+        type Inner1 struct {
+                W int32
+                X string
+        }
+
+        type Inner2 struct {
+                Y float64
+        }
+
+        type Inner3 struct {
+                Z bool
+        }
+
+        type Outer struct {
+                A int16
+                I []Inner1
+                J Inner2
+                Inner3
+        }
+
+then an Outer's properties would be equivalent to those of:
+
+        type OuterEquivalent struct {
+                A     int16
+                IDotW []int32  `datastore:"I.W"`
+                IDotX []string `datastore:"I.X"`
+                JDotY float64  `datastore:"J.Y"`
+                Z     bool
+        }
+
+If Outer's embedded Inner3 field was tagged as `datastore:"Foo"` then the
+equivalent field would instead be: FooDotZ bool `datastore:"Foo.Z"`.
+
+If an outer struct is tagged "noindex" then all of its implicit flattened
+fields are effectively "noindex".
+
+
+The PropertyLoadSaver Interface
+
+An entity's contents can also be represented by any type that implements the
+PropertyLoadSaver interface. This type may be a struct pointer, but it does
+not have to be. The datastore package will call Load when getting the entity's
+contents, and Save when putting the entity's contents.
+Possible uses include deriving non-stored fields, verifying fields, or indexing
+a field only if its value is positive.
+
+Example code:
+
+        type CustomPropsExample struct {
+                I, J int
+                // Sum is not stored, but should always be equal to I + J.
+                Sum int `datastore:"-"`
+        }
+
+        func (x *CustomPropsExample) Load(ps []datastore.Property) error {
+                // Load I and J as usual.
+                if err := datastore.LoadStruct(x, ps); err != nil {
+                        return err
+                }
+                // Derive the Sum field.
+                x.Sum = x.I + x.J
+                return nil
+        }
+
+        func (x *CustomPropsExample) Save() ([]datastore.Property, error) {
+                // Validate the Sum field.
+                if x.Sum != x.I + x.J {
+                        return nil, errors.New("CustomPropsExample has inconsistent sum")
+                }
+                // Save I and J as usual. The code below is equivalent to calling
+                // "return datastore.SaveStruct(x)", but is done manually for
+                // demonstration purposes.
+                return []datastore.Property{
+                        {
+                                Name:  "I",
+                                Value: int64(x.I),
+                        },
+                        {
+                                Name:  "J",
+                                Value: int64(x.J),
+                        },
+                }, nil
+        }
+
+The *PropertyList type implements PropertyLoadSaver, and can therefore hold an
+arbitrary entity's contents.
+
+
+Queries
+
+Queries retrieve entities based on their properties or key's ancestry. Running
+a query yields an iterator of results: either keys or (key, entity) pairs.
+Queries are re-usable and it is safe to call Query.Run from concurrent
+goroutines. Iterators are not safe for concurrent use.
+
+Queries are immutable, and are either created by calling NewQuery, or derived
+from an existing query by calling a method like Filter or Order that returns a
+new query value. A query is typically constructed by calling NewQuery followed
+by a chain of zero or more such methods. These methods are:
+  - Ancestor and Filter constrain the entities returned by running a query.
+  - Order affects the order in which they are returned.
+  - Project constrains the fields returned.
+  - Distinct de-duplicates projected entities.
+  - KeysOnly makes the iterator return only keys, not (key, entity) pairs.
+  - Start, End, Offset and Limit define which sub-sequence of matching entities
+    to return. Start and End take cursors, Offset and Limit take integers. Start
+    and Offset affect the first result, End and Limit affect the last result.
+    If both Start and Offset are set, then the offset is relative to Start.
+    If both End and Limit are set, then the earliest constraint wins. Limit is
+    relative to Start+Offset, not relative to End. As a special case, a
+    negative limit means unlimited.
+
+Example code:
+
+        type Widget struct {
+                Description string
+                Price       int
+        }
+
+        func handle(w http.ResponseWriter, r *http.Request) {
+                ctx := appengine.NewContext(r)
+                q := datastore.NewQuery("Widget").
+                        Filter("Price <", 1000).
+                        Order("-Price")
+                b := new(bytes.Buffer)
+                for t := q.Run(ctx); ; {
+                        var x Widget
+                        key, err := t.Next(&x)
+                        if err == datastore.Done {
+                                break
+                        }
+                        if err != nil {
+                                serveError(ctx, w, err)
+                                return
+                        }
+                        fmt.Fprintf(b, "Key=%v\nWidget=%#v\n\n", key, x)
+                }
+                w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+                io.Copy(w, b)
+        }
+
+
+Transactions
+
+RunInTransaction runs a function in a transaction.
+
+Example code:
+
+        type Counter struct {
+                Count int
+        }
+
+        func inc(ctx context.Context, key *datastore.Key) (int, error) {
+                var x Counter
+                if err := datastore.Get(ctx, key, &x); err != nil && err != datastore.ErrNoSuchEntity {
+                        return 0, err
+                }
+                x.Count++
+                if _, err := datastore.Put(ctx, key, &x); err != nil {
+                        return 0, err
+                }
+                return x.Count, nil
+        }
+
+        func handle(w http.ResponseWriter, r *http.Request) {
+                ctx := appengine.NewContext(r)
+                var count int
+                err := datastore.RunInTransaction(ctx, func(ctx context.Context) error {
+                        var err1 error
+                        count, err1 = inc(ctx, datastore.NewKey(ctx, "Counter", "singleton", 0, nil))
+                        return err1
+                }, nil)
+                if err != nil {
+                        serveError(ctx, w, err)
+                        return
+                }
+                w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+                fmt.Fprintf(w, "Count=%d", count)
+        }
+
+
+Metadata
+
+The datastore package provides access to some of App Engine's datastore
+metadata. This metadata includes information about the entity groups,
+namespaces, entity kinds, and properties in the datastore, as well as the
+property representations for each property.
+
+Example code:
+
+        func handle(w http.ResponseWriter, r *http.Request) {
+                // Print all the kinds in the datastore, with all the indexed
+                // properties (and their representations) for each.
+                ctx := appengine.NewContext(r)
+
+                kinds, err := datastore.Kinds(ctx)
+                if err != nil {
+                        serveError(ctx, w, err)
+                        return
+                }
+
+                w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+                for _, kind := range kinds {
+                        fmt.Fprintf(w, "%s:\n", kind)
+                        props, err := datastore.KindProperties(ctx, kind)
+                        if err != nil {
+                                fmt.Fprintln(w, "\t(unable to retrieve properties)")
+                                continue
+                        }
+                        for p, rep := range props {
+                                fmt.Fprintf(w, "\t-%s (%s)\n", p, strings.Join(rep, ", "))
+                        }
+                }
+        }
+*/
+package datastore // import "google.golang.org/appengine/datastore"
diff --git a/vendor/google.golang.org/appengine/datastore/key.go b/vendor/google.golang.org/appengine/datastore/key.go
new file mode 100644
index 0000000..6ab83ea
--- /dev/null
+++ b/vendor/google.golang.org/appengine/datastore/key.go
@@ -0,0 +1,396 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package datastore
+
+import (
+        "bytes"
+        "encoding/base64"
+        "encoding/gob"
+        "errors"
+        "fmt"
+        "strconv"
+        "strings"
+
+        "github.com/golang/protobuf/proto"
+        "golang.org/x/net/context"
+
+        "google.golang.org/appengine/internal"
+        pb "google.golang.org/appengine/internal/datastore"
+)
+
+type KeyRangeCollisionError struct {
+        start int64
+        end   int64
+}
+
+func (e *KeyRangeCollisionError) Error() string {
+        return fmt.Sprintf("datastore: Collision when attempting to allocate range [%d, %d]",
+                e.start, e.end)
+}
+
+type KeyRangeContentionError struct {
+        start int64
+        end   int64
+}
+
+func (e *KeyRangeContentionError) Error() string {
+        return fmt.Sprintf("datastore: Contention when attempting to allocate range [%d, %d]",
+                e.start, e.end)
+}
+
+// Key represents the datastore key for a stored entity, and is immutable.
+type Key struct {
+        kind      string
+        stringID  string
+        intID     int64
+        parent    *Key
+        appID     string
+        namespace string
+}
+
+// Kind returns the key's kind (also known as entity type).
+func (k *Key) Kind() string {
+        return k.kind
+}
+
+// StringID returns the key's string ID (also known as an entity name or key
+// name), which may be "".
+func (k *Key) StringID() string {
+        return k.stringID
+}
+
+// IntID returns the key's integer ID, which may be 0.
+func (k *Key) IntID() int64 {
+        return k.intID
+}
+
+// Parent returns the key's parent key, which may be nil.
+func (k *Key) Parent() *Key {
+        return k.parent
+}
+
+// AppID returns the key's application ID.
+func (k *Key) AppID() string {
+        return k.appID
+}
+
+// Namespace returns the key's namespace.
+func (k *Key) Namespace() string {
+        return k.namespace
+}
+
+// Incomplete returns whether the key does not refer to a stored entity.
+// In particular, whether the key has a zero StringID and a zero IntID.
+func (k *Key) Incomplete() bool {
+        return k.stringID == "" && k.intID == 0
+}
+
+// valid returns whether the key is valid.
+func (k *Key) valid() bool {
+        if k == nil {
+                return false
+        }
+        for ; k != nil; k = k.parent {
+                if k.kind == "" || k.appID == "" {
+                        return false
+                }
+                if k.stringID != "" && k.intID != 0 {
+                        return false
+                }
+                if k.parent != nil {
+                        if k.parent.Incomplete() {
+                                return false
+                        }
+                        if k.parent.appID != k.appID || k.parent.namespace != k.namespace {
+                                return false
+                        }
+                }
+        }
+        return true
+}
+
+// Equal returns whether two keys are equal.
+func (k *Key) Equal(o *Key) bool {
+        for k != nil && o != nil {
+                if k.kind != o.kind || k.stringID != o.stringID || k.intID != o.intID || k.appID != o.appID || k.namespace != o.namespace {
+                        return false
+                }
+                k, o = k.parent, o.parent
+        }
+        return k == o
+}
+
+// root returns the furthest ancestor of a key, which may be itself.
+func (k *Key) root() *Key {
+        for k.parent != nil {
+                k = k.parent
+        }
+        return k
+}
+
+// marshal marshals the key's string representation to the buffer.
+func (k *Key) marshal(b *bytes.Buffer) {
+        if k.parent != nil {
+                k.parent.marshal(b)
+        }
+        b.WriteByte('/')
+        b.WriteString(k.kind)
+        b.WriteByte(',')
+        if k.stringID != "" {
+                b.WriteString(k.stringID)
+        } else {
+                b.WriteString(strconv.FormatInt(k.intID, 10))
+        }
+}
+
+// String returns a string representation of the key.
+func (k *Key) String() string {
+        if k == nil {
+                return ""
+        }
+        b := bytes.NewBuffer(make([]byte, 0, 512))
+        k.marshal(b)
+        return b.String()
+}
+
+type gobKey struct {
+        Kind      string
+        StringID  string
+        IntID     int64
+        Parent    *gobKey
+        AppID     string
+        Namespace string
+}
+
+func keyToGobKey(k *Key) *gobKey {
+        if k == nil {
+                return nil
+        }
+        return &gobKey{
+                Kind:      k.kind,
+                StringID:  k.stringID,
+                IntID:     k.intID,
+                Parent:    keyToGobKey(k.parent),
+                AppID:     k.appID,
+                Namespace: k.namespace,
+        }
+}
+
+func gobKeyToKey(gk *gobKey) *Key {
+        if gk == nil {
+                return nil
+        }
+        return &Key{
+                kind:      gk.Kind,
+                stringID:  gk.StringID,
+                intID:     gk.IntID,
+                parent:    gobKeyToKey(gk.Parent),
+                appID:     gk.AppID,
+                namespace: gk.Namespace,
+        }
+}
+
+func (k *Key) GobEncode() ([]byte, error) {
+        buf := new(bytes.Buffer)
+        if err := gob.NewEncoder(buf).Encode(keyToGobKey(k)); err != nil {
+                return nil, err
+        }
+        return buf.Bytes(), nil
+}
+
+func (k *Key) GobDecode(buf []byte) error {
+        gk := new(gobKey)
+        if err := gob.NewDecoder(bytes.NewBuffer(buf)).Decode(gk); err != nil {
+                return err
+        }
+        *k = *gobKeyToKey(gk)
+        return nil
+}
+
+func (k *Key) MarshalJSON() ([]byte, error) {
+        return []byte(`"` + k.Encode() + `"`), nil
+}
+
+func (k *Key) UnmarshalJSON(buf []byte) error {
+        if len(buf) < 2 || buf[0] != '"' || buf[len(buf)-1] != '"' {
+                return errors.New("datastore: bad JSON key")
+        }
+        k2, err := DecodeKey(string(buf[1 : len(buf)-1]))
+        if err != nil {
+                return err
+        }
+        *k = *k2
+        return nil
+}
+
+// Encode returns an opaque representation of the key
+// suitable for use in HTML and URLs.
+// This is compatible with the Python and Java runtimes.
+func (k *Key) Encode() string {
+        ref := keyToProto("", k)
+
+        b, err := proto.Marshal(ref)
+        if err != nil {
+                panic(err)
+        }
+
+        // Trailing padding is stripped.
+        return strings.TrimRight(base64.URLEncoding.EncodeToString(b), "=")
+}
+
+// DecodeKey decodes a key from the opaque representation returned by Encode.
+func DecodeKey(encoded string) (*Key, error) {
+        // Re-add padding.
+        if m := len(encoded) % 4; m != 0 {
+                encoded += strings.Repeat("=", 4-m)
+        }
+
+        b, err := base64.URLEncoding.DecodeString(encoded)
+        if err != nil {
+                return nil, err
+        }
+
+        ref := new(pb.Reference)
+        if err := proto.Unmarshal(b, ref); err != nil {
+                return nil, err
+        }
+
+        return protoToKey(ref)
+}
+
+// NewIncompleteKey creates a new incomplete key.
+// kind cannot be empty.
+func NewIncompleteKey(c context.Context, kind string, parent *Key) *Key {
+        return NewKey(c, kind, "", 0, parent)
+}
+
+// NewKey creates a new key.
+// kind cannot be empty.
+// Either one or both of stringID and intID must be zero. If both are zero,
+// the key returned is incomplete.
+// parent must either be a complete key or nil.
+func NewKey(c context.Context, kind, stringID string, intID int64, parent *Key) *Key {
+        // If there's a parent key, use its namespace.
+        // Otherwise, use any namespace attached to the context.
+        var namespace string
+        if parent != nil {
+                namespace = parent.namespace
+        } else {
+                namespace = internal.NamespaceFromContext(c)
+        }
+
+        return &Key{
+                kind:      kind,
+                stringID:  stringID,
+                intID:     intID,
+                parent:    parent,
+                appID:     internal.FullyQualifiedAppID(c),
+                namespace: namespace,
+        }
+}
+
+// AllocateIDs returns a range of n integer IDs with the given kind and parent
+// combination. kind cannot be empty; parent may be nil. The IDs in the range
+// returned will not be used by the datastore's automatic ID sequence generator
+// and may be used with NewKey without conflict.
+//
+// The range is inclusive at the low end and exclusive at the high end. In
+// other words, valid intIDs x satisfy low <= x && x < high.
+//
+// If no error is returned, low + n == high.
+func AllocateIDs(c context.Context, kind string, parent *Key, n int) (low, high int64, err error) {
+        if kind == "" {
+                return 0, 0, errors.New("datastore: AllocateIDs given an empty kind")
+        }
+        if n < 0 {
+                return 0, 0, fmt.Errorf("datastore: AllocateIDs given a negative count: %d", n)
+        }
+        if n == 0 {
+                return 0, 0, nil
+        }
+        req := &pb.AllocateIdsRequest{
+                ModelKey: keyToProto("", NewIncompleteKey(c, kind, parent)),
+                Size:     proto.Int64(int64(n)),
+        }
+        res := &pb.AllocateIdsResponse{}
+        if err := internal.Call(c, "datastore_v3", "AllocateIds", req, res); err != nil {
+                return 0, 0, err
+        }
+        // The protobuf is inclusive at both ends. Idiomatic Go (e.g. slices, for loops)
+        // is inclusive at the low end and exclusive at the high end, so we add 1.
+        low = res.GetStart()
+        high = res.GetEnd() + 1
+        if low+int64(n) != high {
+                return 0, 0, fmt.Errorf("datastore: internal error: could not allocate %d IDs", n)
+        }
+        return low, high, nil
+}
+
+// AllocateIDRange allocates a range of IDs with specific endpoints.
+// The range is inclusive at both the low and high end. Once these IDs have been
+// allocated, you can manually assign them to newly created entities.
+//
+// The Datastore's automatic ID allocator never assigns a key that has already
+// been allocated (either through automatic ID allocation or through an explicit
+// AllocateIDs call). As a result, entities written to the given key range will
+// never be overwritten. However, writing entities with manually assigned keys in
+// this range may overwrite existing entities (or new entities written by a separate
+// request), depending on the error returned.
+//
+// Use this only if you have an existing numeric ID range that you want to reserve
+// (for example, bulk loading entities that already have IDs). If you don't care
+// about which IDs you receive, use AllocateIDs instead.
+//
+// AllocateIDRange returns nil if the range is successfully allocated. If one or more
+// entities with an ID in the given range already exist, it returns a KeyRangeCollisionError.
+// If the Datastore has already cached IDs in this range (e.g. from a previous call to
+// AllocateIDRange), it returns a KeyRangeContentionError. Errors of other types indicate
+// problems with arguments or an error returned directly from the Datastore.
+func AllocateIDRange(c context.Context, kind string, parent *Key, start, end int64) (err error) {
+        if kind == "" {
+                return errors.New("datastore: AllocateIDRange given an empty kind")
+        }
+
+        if start < 1 || end < 1 {
+                return errors.New("datastore: AllocateIDRange start and end must both be greater than 0")
+        }
+
+        if start > end {
+                return errors.New("datastore: AllocateIDRange start must be before end")
+        }
+
+        req := &pb.AllocateIdsRequest{
+                ModelKey: keyToProto("", NewIncompleteKey(c, kind, parent)),
+                Max:      proto.Int64(end),
+        }
+        res := &pb.AllocateIdsResponse{}
+        if err := internal.Call(c, "datastore_v3", "AllocateIds", req, res); err != nil {
+                return err
+        }
+
+        // Check for collisions, i.e. existing entities with IDs in this range.
+        // We could do this before the allocation, but we'd still have to do it
+        // afterward as well to catch the race condition where an entity is inserted
+        // after that initial check but before the allocation. Skip the up-front check
+        // and just do it once.
+        q := NewQuery(kind).Filter("__key__ >=", NewKey(c, kind, "", start, parent)).
+                Filter("__key__ <=", NewKey(c, kind, "", end, parent)).KeysOnly().Limit(1)
+
+        keys, err := q.GetAll(c, nil)
+        if err != nil {
+                return err
+        }
+        if len(keys) != 0 {
+                return &KeyRangeCollisionError{start: start, end: end}
+        }
+
+        // Check for a race condition, i.e. cases where the datastore may have
+        // cached ID batches that contain IDs in this range.
+        if start < res.GetStart() {
+                return &KeyRangeContentionError{start: start, end: end}
+        }
+
+        return nil
+}
diff --git a/vendor/google.golang.org/appengine/datastore/load.go b/vendor/google.golang.org/appengine/datastore/load.go
new file mode 100644
index 0000000..38a6365
--- /dev/null
+++ b/vendor/google.golang.org/appengine/datastore/load.go
@@ -0,0 +1,429 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package datastore
+
+import (
+        "fmt"
+        "reflect"
+        "strings"
+        "time"
+
+        "github.com/golang/protobuf/proto"
+        "google.golang.org/appengine"
+        pb "google.golang.org/appengine/internal/datastore"
+)
+
+var (
+        typeOfBlobKey    = reflect.TypeOf(appengine.BlobKey(""))
+        typeOfByteSlice  = reflect.TypeOf([]byte(nil))
+        typeOfByteString = reflect.TypeOf(ByteString(nil))
+        typeOfGeoPoint   = reflect.TypeOf(appengine.GeoPoint{})
+        typeOfTime       = reflect.TypeOf(time.Time{})
+        typeOfKeyPtr     = reflect.TypeOf(&Key{})
+        typeOfEntityPtr  = reflect.TypeOf(&Entity{})
+)
+
+// typeMismatchReason returns a string explaining why the property p could not
+// be stored in an entity field of type v.Type().
+func typeMismatchReason(pValue interface{}, v reflect.Value) string {
+        entityType := "empty"
+        switch pValue.(type) {
+        case int64:
+                entityType = "int"
+        case bool:
+                entityType = "bool"
+        case string:
+                entityType = "string"
+        case float64:
+                entityType = "float"
+        case *Key:
+                entityType = "*datastore.Key"
+        case time.Time:
+                entityType = "time.Time"
+        case appengine.BlobKey:
+                entityType = "appengine.BlobKey"
+        case appengine.GeoPoint:
+                entityType = "appengine.GeoPoint"
+        case ByteString:
+                entityType = "datastore.ByteString"
+        case []byte:
+                entityType = "[]byte"
+        }
+        return fmt.Sprintf("type mismatch: %s versus %v", entityType, v.Type())
+}
+
+type propertyLoader struct {
+        // m holds the number of times a substruct field like "Foo.Bar.Baz" has
+        // been seen so far. The map is constructed lazily.
+        m map[string]int
+}
+
+func (l *propertyLoader) load(codec *structCodec, structValue reflect.Value, p Property, requireSlice bool) string {
+        var v reflect.Value
+        var sliceIndex int
+
+        name := p.Name
+
+        // If name ends with a '.', the last field is anonymous.
+        // In this case, strings.Split will give us "" as the
+        // last element of our fields slice, which will match the ""
+        // field name in the substruct codec.
+        fields := strings.Split(name, ".")
+
+        for len(fields) > 0 {
+                var decoder fieldCodec
+                var ok bool
+
+                // Cut off the last field (delimited by ".") and find its parent
+                // in the codec.
+                // eg. for name "A.B.C.D", split off "A.B.C" and try to
+                // find a field in the codec with this name.
+                // Loop again with "A.B", etc.
+                for i := len(fields); i > 0; i-- {
+                        parent := strings.Join(fields[:i], ".")
+                        decoder, ok = codec.fields[parent]
+                        if ok {
+                                fields = fields[i:]
+                                break
+                        }
+                }
+
+                // If we never found a matching field in the codec, return
+                // error message.
+                if !ok {
+                        return "no such struct field"
+                }
+
+                v = initField(structValue, decoder.path)
+                if !v.IsValid() {
+                        return "no such struct field"
+                }
+                if !v.CanSet() {
+                        return "cannot set struct field"
+                }
+
+                if decoder.structCodec != nil {
+                        codec = decoder.structCodec
+                        structValue = v
+                }
+
+                if v.Kind() == reflect.Slice && v.Type() != typeOfByteSlice {
+                        if l.m == nil {
+                                l.m = make(map[string]int)
+                        }
+                        sliceIndex = l.m[p.Name]
+                        l.m[p.Name] = sliceIndex + 1
+                        for v.Len() <= sliceIndex {
+                                v.Set(reflect.Append(v, reflect.New(v.Type().Elem()).Elem()))
+                        }
+                        structValue = v.Index(sliceIndex)
+                        requireSlice = false
+                }
+        }
+
+        var slice reflect.Value
+        if v.Kind() == reflect.Slice && v.Type().Elem().Kind() != reflect.Uint8 {
+                slice = v
+                v = reflect.New(v.Type().Elem()).Elem()
+        } else if requireSlice {
+                return "multiple-valued property requires a slice field type"
+        }
+
+        // Convert indexValues to a Go value with a meaning derived from the
+        // destination type.
+        pValue := p.Value
+        if iv, ok := pValue.(indexValue); ok {
+                meaning := pb.Property_NO_MEANING
+                switch v.Type() {
+                case typeOfBlobKey:
+                        meaning = pb.Property_BLOBKEY
+                case typeOfByteSlice:
+                        meaning = pb.Property_BLOB
+                case typeOfByteString:
+                        meaning = pb.Property_BYTESTRING
+                case typeOfGeoPoint:
+                        meaning = pb.Property_GEORSS_POINT
+                case typeOfTime:
+                        meaning = pb.Property_GD_WHEN
+                case typeOfEntityPtr:
+                        meaning = pb.Property_ENTITY_PROTO
+                }
+                var err error
+                pValue, err = propValue(iv.value, meaning)
+                if err != nil {
+                        return err.Error()
+                }
+        }
+
+        if errReason := setVal(v, pValue); errReason != "" {
+                // Set the slice back to its zero value.
+                if slice.IsValid() {
+                        slice.Set(reflect.Zero(slice.Type()))
+                }
+                return errReason
+        }
+
+        if slice.IsValid() {
+                slice.Index(sliceIndex).Set(v)
+        }
+
+        return ""
+}
+
+// setVal sets v to the value pValue.
+func setVal(v reflect.Value, pValue interface{}) string {
+        switch v.Kind() {
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                x, ok := pValue.(int64)
+                if !ok && pValue != nil {
+                        return typeMismatchReason(pValue, v)
+                }
+                if v.OverflowInt(x) {
+                        return fmt.Sprintf("value %v overflows struct field of type %v", x, v.Type())
+                }
+                v.SetInt(x)
+        case reflect.Bool:
+                x, ok := pValue.(bool)
+                if !ok && pValue != nil {
+                        return typeMismatchReason(pValue, v)
+                }
+                v.SetBool(x)
+        case reflect.String:
+                switch x := pValue.(type) {
+                case appengine.BlobKey:
+                        v.SetString(string(x))
+                case ByteString:
+                        v.SetString(string(x))
+                case string:
+                        v.SetString(x)
+                default:
+                        if pValue != nil {
+                                return typeMismatchReason(pValue, v)
+                        }
+                }
+        case reflect.Float32, reflect.Float64:
+                x, ok := pValue.(float64)
+                if !ok && pValue != nil {
+                        return typeMismatchReason(pValue, v)
+                }
+                if v.OverflowFloat(x) {
+                        return fmt.Sprintf("value %v overflows struct field of type %v", x, v.Type())
+                }
+                v.SetFloat(x)
+        case reflect.Ptr:
+                x, ok := pValue.(*Key)
+                if !ok && pValue != nil {
+                        return typeMismatchReason(pValue, v)
+                }
+                if _, ok := v.Interface().(*Key); !ok {
+                        return typeMismatchReason(pValue, v)
+                }
+                v.Set(reflect.ValueOf(x))
+        case reflect.Struct:
+                switch v.Type() {
+                case typeOfTime:
+                        x, ok := pValue.(time.Time)
+                        if !ok && pValue != nil {
+                                return typeMismatchReason(pValue, v)
+                        }
+                        v.Set(reflect.ValueOf(x))
+                case typeOfGeoPoint:
+                        x, ok := pValue.(appengine.GeoPoint)
+                        if !ok && pValue != nil {
+                                return typeMismatchReason(pValue, v)
+                        }
+                        v.Set(reflect.ValueOf(x))
+                default:
+                        ent, ok := pValue.(*Entity)
+                        if !ok {
+                                return typeMismatchReason(pValue, v)
+                        }
+
+                        // Recursively load nested struct
+                        pls, err := newStructPLS(v.Addr().Interface())
+                        if err != nil {
+                                return err.Error()
+                        }
+
+                        // if ent has a Key value and our struct has a Key field,
+                        // load the Entity's Key value into the Key field on the struct.
+                        if ent.Key != nil && pls.codec.keyField != -1 {
+
+                                pls.v.Field(pls.codec.keyField).Set(reflect.ValueOf(ent.Key))
+                        }
+
+                        err = pls.Load(ent.Properties)
+                        if err != nil {
+                                return err.Error()
+                        }
+                }
+        case reflect.Slice:
+                x, ok := pValue.([]byte)
+                if !ok {
+                        if y, yok := pValue.(ByteString); yok {
+                                x, ok = []byte(y), true
+                        }
+                }
+                if !ok && pValue != nil {
+                        return typeMismatchReason(pValue, v)
+                }
+                if v.Type().Elem().Kind() != reflect.Uint8 {
+                        return typeMismatchReason(pValue, v)
+                }
+                v.SetBytes(x)
+        default:
+                return typeMismatchReason(pValue, v)
+        }
+        return ""
+}
+
+// initField is similar to reflect's Value.FieldByIndex, in that it
+// returns the nested struct field corresponding to index, but it
+// initialises any nil pointers encountered when traversing the structure.
+func initField(val reflect.Value, index []int) reflect.Value {
+        for _, i := range index[:len(index)-1] {
+                val = val.Field(i)
+                if val.Kind() == reflect.Ptr {
+                        if val.IsNil() {
+                                val.Set(reflect.New(val.Type().Elem()))
+                        }
+                        val = val.Elem()
+                }
+        }
+        return val.Field(index[len(index)-1])
+}
+
+// loadEntity loads an EntityProto into PropertyLoadSaver or struct pointer.
+func loadEntity(dst interface{}, src *pb.EntityProto) (err error) {
+        ent, err := protoToEntity(src)
+        if err != nil {
+                return err
+        }
+        if e, ok := dst.(PropertyLoadSaver); ok {
+                return e.Load(ent.Properties)
+        }
+        return LoadStruct(dst, ent.Properties)
+}
+
+func (s structPLS) Load(props []Property) error {
+        var fieldName, reason string
+        var l propertyLoader
+        for _, p := range props {
+                if errStr := l.load(s.codec, s.v, p, p.Multiple); errStr != "" {
+                        // We don't return early, as we try to load as many properties as possible.
+                        // It is valid to load an entity into a struct that cannot fully represent it.
+                        // That case returns an error, but the caller is free to ignore it.
+                        fieldName, reason = p.Name, errStr
+                }
+        }
+        if reason != "" {
+                return &ErrFieldMismatch{
+                        StructType: s.v.Type(),
+                        FieldName:  fieldName,
+                        Reason:     reason,
+                }
+        }
+        return nil
+}
+
+func protoToEntity(src *pb.EntityProto) (*Entity, error) {
+        props, rawProps := src.Property, src.RawProperty
+        outProps := make([]Property, 0, len(props)+len(rawProps))
+        for {
+                var (
+                        x       *pb.Property
+                        noIndex bool
+                )
+                if len(props) > 0 {
+                        x, props = props[0], props[1:]
+                } else if len(rawProps) > 0 {
+                        x, rawProps = rawProps[0], rawProps[1:]
+                        noIndex = true
+                } else {
+                        break
+                }
+
+                var value interface{}
+                if x.Meaning != nil && *x.Meaning == pb.Property_INDEX_VALUE {
+                        value = indexValue{x.Value}
+                } else {
+                        var err error
+                        value, err = propValue(x.Value, x.GetMeaning())
+                        if err != nil {
+                                return nil, err
+                        }
+                }
+                outProps = append(outProps, Property{
+                        Name:     x.GetName(),
+                        Value:    value,
+                        NoIndex:  noIndex,
+                        Multiple: x.GetMultiple(),
+                })
+        }
+
+        var key *Key
+        if src.Key != nil {
+                // Ignore any error, since nested entity values
+                // are allowed to have an invalid key.
+                key, _ = protoToKey(src.Key)
+        }
+        return &Entity{key, outProps}, nil
+}
+
+// propValue returns a Go value that combines the raw PropertyValue with a
+// meaning. For example, an Int64Value with GD_WHEN becomes a time.Time.
+func propValue(v *pb.PropertyValue, m pb.Property_Meaning) (interface{}, error) {
+        switch {
+        case v.Int64Value != nil:
+                if m == pb.Property_GD_WHEN {
+                        return fromUnixMicro(*v.Int64Value), nil
+                } else {
+                        return *v.Int64Value, nil
+                }
+        case v.BooleanValue != nil:
+                return *v.BooleanValue, nil
+        case v.StringValue != nil:
+                if m == pb.Property_BLOB {
+                        return []byte(*v.StringValue), nil
+                } else if m == pb.Property_BLOBKEY {
+                        return appengine.BlobKey(*v.StringValue), nil
+                } else if m == pb.Property_BYTESTRING {
+                        return ByteString(*v.StringValue), nil
+                } else if m == pb.Property_ENTITY_PROTO {
+                        var ent pb.EntityProto
+                        err := proto.Unmarshal([]byte(*v.StringValue), &ent)
+                        if err != nil {
+                                return nil, err
+                        }
+                        return protoToEntity(&ent)
+                } else {
+                        return *v.StringValue, nil
+                }
+        case v.DoubleValue != nil:
+                return *v.DoubleValue, nil
+        case v.Referencevalue != nil:
+                key, err := referenceValueToKey(v.Referencevalue)
+                if err != nil {
+                        return nil, err
+                }
+                return key, nil
+        case v.Pointvalue != nil:
+                // NOTE: Strangely, latitude maps to X, longitude to Y.
+                return appengine.GeoPoint{Lat: v.Pointvalue.GetX(), Lng: v.Pointvalue.GetY()}, nil
+        }
+        return nil, nil
+}
+
+// indexValue is a Property value that is created when entities are loaded from
+// an index, such as from a projection query.
+//
+// Such Property values do not contain all of the metadata required to be
+// faithfully represented as a Go value, and are instead represented as an
+// opaque indexValue. Load the properties into a concrete struct type (e.g. by
+// passing a struct pointer to Iterator.Next) to reconstruct actual Go values
+// of type int, string, time.Time, etc.
+type indexValue struct {
+        value *pb.PropertyValue
+}
diff --git a/vendor/google.golang.org/appengine/datastore/metadata.go b/vendor/google.golang.org/appengine/datastore/metadata.go
new file mode 100644
index 0000000..6acacc3
--- /dev/null
+++ b/vendor/google.golang.org/appengine/datastore/metadata.go
@@ -0,0 +1,78 @@
+// Copyright 2016 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package datastore
+
+import "golang.org/x/net/context"
+
+// Datastore kinds for the metadata entities.
+const (
+        namespaceKind = "__namespace__"
+        kindKind      = "__kind__"
+        propertyKind  = "__property__"
+)
+
+// Namespaces returns all the datastore namespaces.
+func Namespaces(ctx context.Context) ([]string, error) {
+        // TODO(djd): Support range queries.
+        q := NewQuery(namespaceKind).KeysOnly()
+        keys, err := q.GetAll(ctx, nil)
+        if err != nil {
+                return nil, err
+        }
+        // The empty namespace key uses a numeric ID (==1), but luckily
+        // the string ID defaults to "" for numeric IDs anyway.
+        return keyNames(keys), nil
+}
+
+// Kinds returns the names of all the kinds in the current namespace.
+func Kinds(ctx context.Context) ([]string, error) {
+        // TODO(djd): Support range queries.
+        q := NewQuery(kindKind).KeysOnly()
+        keys, err := q.GetAll(ctx, nil)
+        if err != nil {
+                return nil, err
+        }
+        return keyNames(keys), nil
+}
+
+// keyNames returns a slice of the provided keys' names (string IDs).
+func keyNames(keys []*Key) []string {
+        n := make([]string, 0, len(keys))
+        for _, k := range keys {
+                n = append(n, k.StringID())
+        }
+        return n
+}
+
+// KindProperties returns all the indexed properties for the given kind.
+// The properties are returned as a map of property names to a slice of the
+// representation types. The representation types for the supported Go property
+// types are:
+//   "INT64":     signed integers and time.Time
+//   "DOUBLE":    float32 and float64
+//   "BOOLEAN":   bool
+//   "STRING":    string, []byte and ByteString
+//   "POINT":     appengine.GeoPoint
+//   "REFERENCE": *Key
+//   "USER":      (not used in the Go runtime)
+func KindProperties(ctx context.Context, kind string) (map[string][]string, error) {
+        // TODO(djd): Support range queries.
+        kindKey := NewKey(ctx, kindKind, kind, 0, nil)
+        q := NewQuery(propertyKind).Ancestor(kindKey)
+
+        propMap := map[string][]string{}
+        props := []struct {
+                Repr []string `datastore:"property_representation"`
+        }{}
+
+        keys, err := q.GetAll(ctx, &props)
+        if err != nil {
+                return nil, err
+        }
+        for i, p := range props {
+                propMap[keys[i].StringID()] = p.Repr
+        }
+        return propMap, nil
+}
diff --git a/vendor/google.golang.org/appengine/datastore/prop.go b/vendor/google.golang.org/appengine/datastore/prop.go
new file mode 100644
index 0000000..5cb2079
--- /dev/null
+++ b/vendor/google.golang.org/appengine/datastore/prop.go
@@ -0,0 +1,330 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package datastore
+
+import (
+        "fmt"
+        "reflect"
+        "strings"
+        "sync"
+        "unicode"
+)
+
+// Entities with more than this many indexed properties will not be saved.
+const maxIndexedProperties = 20000
+
+// []byte fields more than 1 megabyte long will not be loaded or saved.
+const maxBlobLen = 1 << 20
+
+// Property is a name/value pair plus some metadata. A datastore entity's
+// contents are loaded and saved as a sequence of Properties. An entity can
+// have multiple Properties with the same name, provided that p.Multiple is
+// true on all of that entity's Properties with that name.
+type Property struct {
+        // Name is the property name.
+        Name string
+        // Value is the property value. The valid types are:
+        //      - int64
+        //      - bool
+        //      - string
+        //      - float64
+        //      - ByteString
+        //      - *Key
+        //      - time.Time
+        //      - appengine.BlobKey
+        //      - appengine.GeoPoint
+        //      - []byte (up to 1 megabyte in length)
+        //      - *Entity (representing a nested struct)
+        // This set is smaller than the set of valid struct field types that the
+        // datastore can load and save. A Property Value cannot be a slice (apart
+        // from []byte); use multiple Properties instead. Also, a Value's type
+        // must be explicitly on the list above; it is not sufficient for the
+        // underlying type to be on that list. For example, a Value of "type
+        // myInt64 int64" is invalid. Smaller-width integers and floats are also
+        // invalid. Again, this is more restrictive than the set of valid struct
+        // field types.
+        //
+        // A Value will have an opaque type when loading entities from an index,
+        // such as via a projection query. Load entities into a struct instead
+        // of a PropertyLoadSaver when using a projection query.
+        //
+        // A Value may also be the nil interface value; this is equivalent to
+        // Python's None but not directly representable by a Go struct. Loading
+        // a nil-valued property into a struct will set that field to the zero
+        // value.
+        Value interface{}
+        // NoIndex is whether the datastore cannot index this property.
+        NoIndex bool
+        // Multiple is whether the entity can have multiple properties with
+        // the same name. Even if a particular instance only has one property with
+        // a certain name, Multiple should be true if a struct would best represent
+        // it as a field of type []T instead of type T.
+        Multiple bool
+}
+
+// An Entity is the value type for a nested struct.
+// This type is only used for a Property's Value.
+type Entity struct {
+        Key        *Key
+        Properties []Property
+}
+
+// ByteString is a short byte slice (up to 1500 bytes) that can be indexed.
+type ByteString []byte
+
+// PropertyLoadSaver can be converted from and to a slice of Properties.
+type PropertyLoadSaver interface {
+        Load([]Property) error
+        Save() ([]Property, error)
+}
+
+// PropertyList converts a []Property to implement PropertyLoadSaver.
+type PropertyList []Property
+
+var (
+        typeOfPropertyLoadSaver = reflect.TypeOf((*PropertyLoadSaver)(nil)).Elem()
+        typeOfPropertyList      = reflect.TypeOf(PropertyList(nil))
+)
+
+// Load loads all of the provided properties into l.
+// It does not first reset *l to an empty slice.
+func (l *PropertyList) Load(p []Property) error {
+        *l = append(*l, p...)
+        return nil
+}
+
+// Save saves all of l's properties as a slice or Properties.
+func (l *PropertyList) Save() ([]Property, error) {
+        return *l, nil
+}
+
+// validPropertyName returns whether name consists of one or more valid Go
+// identifiers joined by ".".
+func validPropertyName(name string) bool {
+        if name == "" {
+                return false
+        }
+        for _, s := range strings.Split(name, ".") {
+                if s == "" {
+                        return false
+                }
+                first := true
+                for _, c := range s {
+                        if first {
+                                first = false
+                                if c != '_' && !unicode.IsLetter(c) {
+                                        return false
+                                }
+                        } else {
+                                if c != '_' && !unicode.IsLetter(c) && !unicode.IsDigit(c) {
+                                        return false
+                                }
+                        }
+                }
+        }
+        return true
+}
+
+// structCodec describes how to convert a struct to and from a sequence of
+// properties.
+type structCodec struct {
+        // fields gives the field codec for the structTag with the given name.
+        fields map[string]fieldCodec
+        // hasSlice is whether a struct or any of its nested or embedded structs
+        // has a slice-typed field (other than []byte).
+        hasSlice bool
+        // keyField is the index of a *Key field with structTag __key__.
+        // This field is not relevant for the top level struct, only for
+        // nested structs.
+        keyField int
+        // complete is whether the structCodec is complete. An incomplete
+        // structCodec may be encountered when walking a recursive struct.
+        complete bool
+}
+
+// fieldCodec is a struct field's index and, if that struct field's type is
+// itself a struct, that substruct's structCodec.
+type fieldCodec struct {
+        // path is the index path to the field
+        path    []int
+        noIndex bool
+        // omitEmpty indicates that the field should be omitted on save
+        // if empty.
+        omitEmpty bool
+        // structCodec is the codec fot the struct field at index 'path',
+        // or nil if the field is not a struct.
+        structCodec *structCodec
+}
+
+// structCodecs collects the structCodecs that have already been calculated.
+var (
+        structCodecsMutex sync.Mutex
+        structCodecs      = make(map[reflect.Type]*structCodec)
+)
+
+// getStructCodec returns the structCodec for the given struct type.
+func getStructCodec(t reflect.Type) (*structCodec, error) {
+        structCodecsMutex.Lock()
+        defer structCodecsMutex.Unlock()
+        return getStructCodecLocked(t)
+}
+
+// getStructCodecLocked implements getStructCodec. The structCodecsMutex must
+// be held when calling this function.
+func getStructCodecLocked(t reflect.Type) (ret *structCodec, retErr error) {
+        c, ok := structCodecs[t]
+        if ok {
+                return c, nil
+        }
+        c = &structCodec{
+                fields: make(map[string]fieldCodec),
+                // We initialize keyField to -1 so that the zero-value is not
+                // misinterpreted as index 0.
+                keyField: -1,
+        }
+
+        // Add c to the structCodecs map before we are sure it is good. If t is
+        // a recursive type, it needs to find the incomplete entry for itself in
+        // the map.
+        structCodecs[t] = c
+        defer func() {
+                if retErr != nil {
+                        delete(structCodecs, t)
+                }
+        }()
+
+        for i := 0; i < t.NumField(); i++ {
+                f := t.Field(i)
+                // Skip unexported fields.
+                // Note that if f is an anonymous, unexported struct field,
+                // we will promote its fields.
+                if f.PkgPath != "" && !f.Anonymous {
+                        continue
+                }
+
+                tags := strings.Split(f.Tag.Get("datastore"), ",")
+                name := tags[0]
+                opts := make(map[string]bool)
+                for _, t := range tags[1:] {
+                        opts[t] = true
+                }
+                switch {
+                case name == "":
+                        if !f.Anonymous {
+                                name = f.Name
+                        }
+                case name == "-":
+                        continue
+                case name == "__key__":
+                        if f.Type != typeOfKeyPtr {
+                                return nil, fmt.Errorf("datastore: __key__ field on struct %v is not a *datastore.Key", t)
+                        }
+                        c.keyField = i
+                case !validPropertyName(name):
+                        return nil, fmt.Errorf("datastore: struct tag has invalid property name: %q", name)
+                }
+
+                substructType, fIsSlice := reflect.Type(nil), false
+                switch f.Type.Kind() {
+                case reflect.Struct:
+                        substructType = f.Type
+                case reflect.Slice:
+                        if f.Type.Elem().Kind() == reflect.Struct {
+                                substructType = f.Type.Elem()
+                        }
+                        fIsSlice = f.Type != typeOfByteSlice
+                        c.hasSlice = c.hasSlice || fIsSlice
+                }
+
+                var sub *structCodec
+                if substructType != nil && substructType != typeOfTime && substructType != typeOfGeoPoint {
+                        var err error
+                        sub, err = getStructCodecLocked(substructType)
+                        if err != nil {
+                                return nil, err
+                        }
+                        if !sub.complete {
+                                return nil, fmt.Errorf("datastore: recursive struct: field %q", f.Name)
+                        }
+                        if fIsSlice && sub.hasSlice {
+                                return nil, fmt.Errorf(
+                                        "datastore: flattening nested structs leads to a slice of slices: field %q", f.Name)
+                        }
+                        c.hasSlice = c.hasSlice || sub.hasSlice
+                        // If f is an anonymous struct field, we promote the substruct's fields up to this level
+                        // in the linked list of struct codecs.
+                        if f.Anonymous {
+                                for subname, subfield := range sub.fields {
+                                        if name != "" {
+                                                subname = name + "." + subname
+                                        }
+                                        if _, ok := c.fields[subname]; ok {
+                                                return nil, fmt.Errorf("datastore: struct tag has repeated property name: %q", subname)
+                                        }
+                                        c.fields[subname] = fieldCodec{
+                                                path:        append([]int{i}, subfield.path...),
+                                                noIndex:     subfield.noIndex || opts["noindex"],
+                                                omitEmpty:   subfield.omitEmpty,
+                                                structCodec: subfield.structCodec,
+                                        }
+                                }
+                                continue
+                        }
+                }
+
+                if _, ok := c.fields[name]; ok {
+                        return nil, fmt.Errorf("datastore: struct tag has repeated property name: %q", name)
+                }
+                c.fields[name] = fieldCodec{
+                        path:        []int{i},
+                        noIndex:     opts["noindex"],
+                        omitEmpty:   opts["omitempty"],
+                        structCodec: sub,
+                }
+        }
+        c.complete = true
+        return c, nil
+}
+
+// structPLS adapts a struct to be a PropertyLoadSaver.
+type structPLS struct {
+        v     reflect.Value
+        codec *structCodec
+}
+
+// newStructPLS returns a structPLS, which implements the
+// PropertyLoadSaver interface, for the struct pointer p.
+func newStructPLS(p interface{}) (*structPLS, error) {
+        v := reflect.ValueOf(p)
+        if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Struct {
+                return nil, ErrInvalidEntityType
+        }
+        v = v.Elem()
+        codec, err := getStructCodec(v.Type())
+        if err != nil {
+                return nil, err
+        }
+        return &structPLS{v, codec}, nil
+}
+
+// LoadStruct loads the properties from p to dst.
+// dst must be a struct pointer.
+func LoadStruct(dst interface{}, p []Property) error {
+        x, err := newStructPLS(dst)
+        if err != nil {
+                return err
+        }
+        return x.Load(p)
+}
+
+// SaveStruct returns the properties from src as a slice of Properties.
+// src must be a struct pointer.
+func SaveStruct(src interface{}) ([]Property, error) {
+        x, err := newStructPLS(src)
+        if err != nil {
+                return nil, err
+        }
+        return x.Save()
+}
diff --git a/vendor/google.golang.org/appengine/datastore/query.go b/vendor/google.golang.org/appengine/datastore/query.go
new file mode 100644
index 0000000..c1ea4ad
--- /dev/null
+++ b/vendor/google.golang.org/appengine/datastore/query.go
@@ -0,0 +1,757 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package datastore
+
+import (
+        "encoding/base64"
+        "errors"
+        "fmt"
+        "math"
+        "reflect"
+        "strings"
+
+        "github.com/golang/protobuf/proto"
+        "golang.org/x/net/context"
+
+        "google.golang.org/appengine/internal"
+        pb "google.golang.org/appengine/internal/datastore"
+)
+
+type operator int
+
+const (
+        lessThan operator = iota
+        lessEq
+        equal
+        greaterEq
+        greaterThan
+)
+
+var operatorToProto = map[operator]*pb.Query_Filter_Operator{
+        lessThan:    pb.Query_Filter_LESS_THAN.Enum(),
+        lessEq:      pb.Query_Filter_LESS_THAN_OR_EQUAL.Enum(),
+        equal:       pb.Query_Filter_EQUAL.Enum(),
+        greaterEq:   pb.Query_Filter_GREATER_THAN_OR_EQUAL.Enum(),
+        greaterThan: pb.Query_Filter_GREATER_THAN.Enum(),
+}
+
+// filter is a conditional filter on query results.
+type filter struct {
+        FieldName string
+        Op        operator
+        Value     interface{}
+}
+
+type sortDirection int
+
+const (
+        ascending sortDirection = iota
+        descending
+)
+
+var sortDirectionToProto = map[sortDirection]*pb.Query_Order_Direction{
+        ascending:  pb.Query_Order_ASCENDING.Enum(),
+        descending: pb.Query_Order_DESCENDING.Enum(),
+}
+
+// order is a sort order on query results.
+type order struct {
+        FieldName string
+        Direction sortDirection
+}
+
+// NewQuery creates a new Query for a specific entity kind.
+//
+// An empty kind means to return all entities, including entities created and
+// managed by other App Engine features, and is called a kindless query.
+// Kindless queries cannot include filters or sort orders on property values.
+func NewQuery(kind string) *Query {
+        return &Query{
+                kind:  kind,
+                limit: -1,
+        }
+}
+
+// Query represents a datastore query.
+type Query struct {
+        kind       string
+        ancestor   *Key
+        filter     []filter
+        order      []order
+        projection []string
+
+        distinct bool
+        keysOnly bool
+        eventual bool
+        limit    int32
+        offset   int32
+        count    int32
+        start    *pb.CompiledCursor
+        end      *pb.CompiledCursor
+
+        err error
+}
+
+func (q *Query) clone() *Query {
+        x := *q
+        // Copy the contents of the slice-typed fields to a new backing store.
+        if len(q.filter) > 0 {
+                x.filter = make([]filter, len(q.filter))
+                copy(x.filter, q.filter)
+        }
+        if len(q.order) > 0 {
+                x.order = make([]order, len(q.order))
+                copy(x.order, q.order)
+        }
+        return &x
+}
+
+// Ancestor returns a derivative query with an ancestor filter.
+// The ancestor should not be nil.
+func (q *Query) Ancestor(ancestor *Key) *Query {
+        q = q.clone()
+        if ancestor == nil {
+                q.err = errors.New("datastore: nil query ancestor")
+                return q
+        }
+        q.ancestor = ancestor
+        return q
+}
+
+// EventualConsistency returns a derivative query that returns eventually
+// consistent results.
+// It only has an effect on ancestor queries.
+func (q *Query) EventualConsistency() *Query {
+        q = q.clone()
+        q.eventual = true
+        return q
+}
+
+// Filter returns a derivative query with a field-based filter.
+// The filterStr argument must be a field name followed by optional space,
+// followed by an operator, one of ">", "<", ">=", "<=", or "=".
+// Fields are compared against the provided value using the operator.
+// Multiple filters are AND'ed together.
+func (q *Query) Filter(filterStr string, value interface{}) *Query {
+        q = q.clone()
+        filterStr = strings.TrimSpace(filterStr)
+        if len(filterStr) < 1 {
+                q.err = errors.New("datastore: invalid filter: " + filterStr)
+                return q
+        }
+        f := filter{
+                FieldName: strings.TrimRight(filterStr, " ><=!"),
+                Value:     value,
+        }
+        switch op := strings.TrimSpace(filterStr[len(f.FieldName):]); op {
+        case "<=":
+                f.Op = lessEq
+        case ">=":
+                f.Op = greaterEq
+        case "<":
+                f.Op = lessThan
+        case ">":
+                f.Op = greaterThan
+        case "=":
+                f.Op = equal
+        default:
+                q.err = fmt.Errorf("datastore: invalid operator %q in filter %q", op, filterStr)
+                return q
+        }
+        q.filter = append(q.filter, f)
+        return q
+}
+
+// Order returns a derivative query with a field-based sort order. Orders are
+// applied in the order they are added. The default order is ascending; to sort
+// in descending order prefix the fieldName with a minus sign (-).
+func (q *Query) Order(fieldName string) *Query {
+        q = q.clone()
+        fieldName = strings.TrimSpace(fieldName)
+        o := order{
+                Direction: ascending,
+                FieldName: fieldName,
+        }
+        if strings.HasPrefix(fieldName, "-") {
+                o.Direction = descending
+                o.FieldName = strings.TrimSpace(fieldName[1:])
+        } else if strings.HasPrefix(fieldName, "+") {
+                q.err = fmt.Errorf("datastore: invalid order: %q", fieldName)
+                return q
+        }
+        if len(o.FieldName) == 0 {
+                q.err = errors.New("datastore: empty order")
+                return q
+        }
+        q.order = append(q.order, o)
+        return q
+}
+
+// Project returns a derivative query that yields only the given fields. It
+// cannot be used with KeysOnly.
+func (q *Query) Project(fieldNames ...string) *Query {
+        q = q.clone()
+        q.projection = append([]string(nil), fieldNames...)
+        return q
+}
+
+// Distinct returns a derivative query that yields de-duplicated entities with
+// respect to the set of projected fields. It is only used for projection
+// queries.
+func (q *Query) Distinct() *Query {
+        q = q.clone()
+        q.distinct = true
+        return q
+}
+
+// KeysOnly returns a derivative query that yields only keys, not keys and
+// entities. It cannot be used with projection queries.
+func (q *Query) KeysOnly() *Query {
+        q = q.clone()
+        q.keysOnly = true
+        return q
+}
+
+// Limit returns a derivative query that has a limit on the number of results
+// returned. A negative value means unlimited.
+func (q *Query) Limit(limit int) *Query {
+        q = q.clone()
+        if limit < math.MinInt32 || limit > math.MaxInt32 {
+                q.err = errors.New("datastore: query limit overflow")
+                return q
+        }
+        q.limit = int32(limit)
+        return q
+}
+
+// Offset returns a derivative query that has an offset of how many keys to
+// skip over before returning results. A negative value is invalid.
+func (q *Query) Offset(offset int) *Query {
+        q = q.clone()
+        if offset < 0 {
+                q.err = errors.New("datastore: negative query offset")
+                return q
+        }
+        if offset > math.MaxInt32 {
+                q.err = errors.New("datastore: query offset overflow")
+                return q
+        }
+        q.offset = int32(offset)
+        return q
+}
+
+// BatchSize returns a derivative query to fetch the supplied number of results
+// at once. This value should be greater than zero, and equal to or less than
+// the Limit.
+func (q *Query) BatchSize(size int) *Query {
+        q = q.clone()
+        if size <= 0 || size > math.MaxInt32 {
+                q.err = errors.New("datastore: query batch size overflow")
+                return q
+        }
+        q.count = int32(size)
+        return q
+}
+
+// Start returns a derivative query with the given start point.
+func (q *Query) Start(c Cursor) *Query {
+        q = q.clone()
+        if c.cc == nil {
+                q.err = errors.New("datastore: invalid cursor")
+                return q
+        }
+        q.start = c.cc
+        return q
+}
+
+// End returns a derivative query with the given end point.
+func (q *Query) End(c Cursor) *Query {
+        q = q.clone()
+        if c.cc == nil {
+                q.err = errors.New("datastore: invalid cursor")
+                return q
+        }
+        q.end = c.cc
+        return q
+}
+
+// toProto converts the query to a protocol buffer.
+func (q *Query) toProto(dst *pb.Query, appID string) error {
+        if len(q.projection) != 0 && q.keysOnly {
+                return errors.New("datastore: query cannot both project and be keys-only")
+        }
+        dst.Reset()
+        dst.App = proto.String(appID)
+        if q.kind != "" {
+                dst.Kind = proto.String(q.kind)
+        }
+        if q.ancestor != nil {
+                dst.Ancestor = keyToProto(appID, q.ancestor)
+                if q.eventual {
+                        dst.Strong = proto.Bool(false)
+                }
+        }
+        if q.projection != nil {
+                dst.PropertyName = q.projection
+                if q.distinct {
+                        dst.GroupByPropertyName = q.projection
+                }
+        }
+        if q.keysOnly {
+                dst.KeysOnly = proto.Bool(true)
+                dst.RequirePerfectPlan = proto.Bool(true)
+        }
+        for _, qf := range q.filter {
+                if qf.FieldName == "" {
+                        return errors.New("datastore: empty query filter field name")
+                }
+                p, errStr := valueToProto(appID, qf.FieldName, reflect.ValueOf(qf.Value), false)
+                if errStr != "" {
+                        return errors.New("datastore: bad query filter value type: " + errStr)
+                }
+                xf := &pb.Query_Filter{
+                        Op:       operatorToProto[qf.Op],
+                        Property: []*pb.Property{p},
+                }
+                if xf.Op == nil {
+                        return errors.New("datastore: unknown query filter operator")
+                }
+                dst.Filter = append(dst.Filter, xf)
+        }
+        for _, qo := range q.order {
+                if qo.FieldName == "" {
+                        return errors.New("datastore: empty query order field name")
+                }
+                xo := &pb.Query_Order{
+                        Property:  proto.String(qo.FieldName),
+                        Direction: sortDirectionToProto[qo.Direction],
+                }
+                if xo.Direction == nil {
+                        return errors.New("datastore: unknown query order direction")
+                }
+                dst.Order = append(dst.Order, xo)
+        }
+        if q.limit >= 0 {
+                dst.Limit = proto.Int32(q.limit)
+        }
+        if q.offset != 0 {
+                dst.Offset = proto.Int32(q.offset)
+        }
+        if q.count != 0 {
+                dst.Count = proto.Int32(q.count)
+        }
+        dst.CompiledCursor = q.start
+        dst.EndCompiledCursor = q.end
+        dst.Compile = proto.Bool(true)
+        return nil
+}
+
+// Count returns the number of results for the query.
+//
+// The running time and number of API calls made by Count scale linearly with
+// the sum of the query's offset and limit. Unless the result count is
+// expected to be small, it is best to specify a limit; otherwise Count will
+// continue until it finishes counting or the provided context expires.
+func (q *Query) Count(c context.Context) (int, error) {
+        // Check that the query is well-formed.
+        if q.err != nil {
+                return 0, q.err
+        }
+
+        // Run a copy of the query, with keysOnly true (if we're not a projection,
+        // since the two are incompatible), and an adjusted offset. We also set the
+        // limit to zero, as we don't want any actual entity data, just the number
+        // of skipped results.
+        newQ := q.clone()
+        newQ.keysOnly = len(newQ.projection) == 0
+        newQ.limit = 0
+        if q.limit < 0 {
+                // If the original query was unlimited, set the new query's offset to maximum.
+                newQ.offset = math.MaxInt32
+        } else {
+                newQ.offset = q.offset + q.limit
+                if newQ.offset < 0 {
+                        // Do the best we can, in the presence of overflow.
+                        newQ.offset = math.MaxInt32
+                }
+        }
+        req := &pb.Query{}
+        if err := newQ.toProto(req, internal.FullyQualifiedAppID(c)); err != nil {
+                return 0, err
+        }
+        res := &pb.QueryResult{}
+        if err := internal.Call(c, "datastore_v3", "RunQuery", req, res); err != nil {
+                return 0, err
+        }
+
+        // n is the count we will return. For example, suppose that our original
+        // query had an offset of 4 and a limit of 2008: the count will be 2008,
+        // provided that there are at least 2012 matching entities. However, the
+        // RPCs will only skip 1000 results at a time. The RPC sequence is:
+        //   call RunQuery with (offset, limit) = (2012, 0)  // 2012 == newQ.offset
+        //   response has (skippedResults, moreResults) = (1000, true)
+        //   n += 1000  // n == 1000
+        //   call Next     with (offset, limit) = (1012, 0)  // 1012 == newQ.offset - n
+        //   response has (skippedResults, moreResults) = (1000, true)
+        //   n += 1000  // n == 2000
+        //   call Next     with (offset, limit) = (12, 0)    // 12 == newQ.offset - n
+        //   response has (skippedResults, moreResults) = (12, false)
+        //   n += 12    // n == 2012
+        //   // exit the loop
+        //   n -= 4     // n == 2008
+        var n int32
+        for {
+                // The QueryResult should have no actual entity data, just skipped results.
+                if len(res.Result) != 0 {
+                        return 0, errors.New("datastore: internal error: Count request returned too much data")
+                }
+                n += res.GetSkippedResults()
+                if !res.GetMoreResults() {
+                        break
+                }
+                if err := callNext(c, res, newQ.offset-n, q.count); err != nil {
+                        return 0, err
+                }
+        }
+        n -= q.offset
+        if n < 0 {
+                // If the offset was greater than the number of matching entities,
+                // return 0 instead of negative.
+                n = 0
+        }
+        return int(n), nil
+}
+
+// callNext issues a datastore_v3/Next RPC to advance a cursor, such as that
+// returned by a query with more results.
+func callNext(c context.Context, res *pb.QueryResult, offset, count int32) error {
+        if res.Cursor == nil {
+                return errors.New("datastore: internal error: server did not return a cursor")
+        }
+        req := &pb.NextRequest{
+                Cursor: res.Cursor,
+        }
+        if count >= 0 {
+                req.Count = proto.Int32(count)
+        }
+        if offset != 0 {
+                req.Offset = proto.Int32(offset)
+        }
+        if res.CompiledCursor != nil {
+                req.Compile = proto.Bool(true)
+        }
+        res.Reset()
+        return internal.Call(c, "datastore_v3", "Next", req, res)
+}
+
+// GetAll runs the query in the given context and returns all keys that match
+// that query, as well as appending the values to dst.
+//
+// dst must have type *[]S or *[]*S or *[]P, for some struct type S or some non-
+// interface, non-pointer type P such that P or *P implements PropertyLoadSaver.
+//
+// As a special case, *PropertyList is an invalid type for dst, even though a
+// PropertyList is a slice of structs. It is treated as invalid to avoid being
+// mistakenly passed when *[]PropertyList was intended.
+//
+// The keys returned by GetAll will be in a 1-1 correspondence with the entities
+// added to dst.
+//
+// If q is a ``keys-only'' query, GetAll ignores dst and only returns the keys.
+//
+// The running time and number of API calls made by GetAll scale linearly with
+// the sum of the query's offset and limit. Unless the result count is
+// expected to be small, it is best to specify a limit; otherwise GetAll will
+// continue until it finishes collecting results or the provided context
+// expires.
+func (q *Query) GetAll(c context.Context, dst interface{}) ([]*Key, error) {
+        var (
+                dv               reflect.Value
+                mat              multiArgType
+                elemType         reflect.Type
+                errFieldMismatch error
+        )
+        if !q.keysOnly {
+                dv = reflect.ValueOf(dst)
+                if dv.Kind() != reflect.Ptr || dv.IsNil() {
+                        return nil, ErrInvalidEntityType
+                }
+                dv = dv.Elem()
+                mat, elemType = checkMultiArg(dv)
+                if mat == multiArgTypeInvalid || mat == multiArgTypeInterface {
+                        return nil, ErrInvalidEntityType
+                }
+        }
+
+        var keys []*Key
+        for t := q.Run(c); ; {
+                k, e, err := t.next()
+                if err == Done {
+                        break
+                }
+                if err != nil {
+                        return keys, err
+                }
+                if !q.keysOnly {
+                        ev := reflect.New(elemType)
+                        if elemType.Kind() == reflect.Map {
+                                // This is a special case. The zero values of a map type are
+                                // not immediately useful; they have to be make'd.
+                                //
+                                // Funcs and channels are similar, in that a zero value is not useful,
+                                // but even a freshly make'd channel isn't useful: there's no fixed
+                                // channel buffer size that is always going to be large enough, and
+                                // there's no goroutine to drain the other end. Theoretically, these
+                                // types could be supported, for example by sniffing for a constructor
+                                // method or requiring prior registration, but for now it's not a
+                                // frequent enough concern to be worth it. Programmers can work around
+                                // it by explicitly using Iterator.Next instead of the Query.GetAll
+                                // convenience method.
+                                x := reflect.MakeMap(elemType)
+                                ev.Elem().Set(x)
+                        }
+                        if err = loadEntity(ev.Interface(), e); err != nil {
+                                if _, ok := err.(*ErrFieldMismatch); ok {
+                                        // We continue loading entities even in the face of field mismatch errors.
+                                        // If we encounter any other error, that other error is returned. Otherwise,
+                                        // an ErrFieldMismatch is returned.
+                                        errFieldMismatch = err
+                                } else {
+                                        return keys, err
+                                }
+                        }
+                        if mat != multiArgTypeStructPtr {
+                                ev = ev.Elem()
+                        }
+                        dv.Set(reflect.Append(dv, ev))
+                }
+                keys = append(keys, k)
+        }
+        return keys, errFieldMismatch
+}
+
+// Run runs the query in the given context.
+func (q *Query) Run(c context.Context) *Iterator {
+        if q.err != nil {
+                return &Iterator{err: q.err}
+        }
+        t := &Iterator{
+                c:      c,
+                limit:  q.limit,
+                count:  q.count,
+                q:      q,
+                prevCC: q.start,
+        }
+        var req pb.Query
+        if err := q.toProto(&req, internal.FullyQualifiedAppID(c)); err != nil {
+                t.err = err
+                return t
+        }
+        if err := internal.Call(c, "datastore_v3", "RunQuery", &req, &t.res); err != nil {
+                t.err = err
+                return t
+        }
+        offset := q.offset - t.res.GetSkippedResults()
+        var count int32
+        if t.count > 0 && (t.limit < 0 || t.count < t.limit) {
+                count = t.count
+        } else {
+                count = t.limit
+        }
+        for offset > 0 && t.res.GetMoreResults() {
+                t.prevCC = t.res.CompiledCursor
+                if err := callNext(t.c, &t.res, offset, count); err != nil {
+                        t.err = err
+                        break
+                }
+                skip := t.res.GetSkippedResults()
+                if skip < 0 {
+                        t.err = errors.New("datastore: internal error: negative number of skipped_results")
+                        break
+                }
+                offset -= skip
+        }
+        if offset < 0 {
+                t.err = errors.New("datastore: internal error: query offset was overshot")
+        }
+        return t
+}
+
+// Iterator is the result of running a query.
+type Iterator struct {
+        c   context.Context
+        err error
+        // res is the result of the most recent RunQuery or Next API call.
+        res pb.QueryResult
+        // i is how many elements of res.Result we have iterated over.
+        i int
+        // limit is the limit on the number of results this iterator should return.
+        // A negative value means unlimited.
+        limit int32
+        // count is the number of results this iterator should fetch at once. This
+        // should be equal to or greater than zero.
+        count int32
+        // q is the original query which yielded this iterator.
+        q *Query
+        // prevCC is the compiled cursor that marks the end of the previous batch
+        // of results.
+        prevCC *pb.CompiledCursor
+}
+
+// Done is returned when a query iteration has completed.
+var Done = errors.New("datastore: query has no more results")
+
+// Next returns the key of the next result. When there are no more results,
+// Done is returned as the error.
+//
+// If the query is not keys only and dst is non-nil, it also loads the entity
+// stored for that key into the struct pointer or PropertyLoadSaver dst, with
+// the same semantics and possible errors as for the Get function.
+func (t *Iterator) Next(dst interface{}) (*Key, error) {
+        k, e, err := t.next()
+        if err != nil {
+                return nil, err
+        }
+        if dst != nil && !t.q.keysOnly {
+                err = loadEntity(dst, e)
+        }
+        return k, err
+}
+
+func (t *Iterator) next() (*Key, *pb.EntityProto, error) {
+        if t.err != nil {
+                return nil, nil, t.err
+        }
+
+        // Issue datastore_v3/Next RPCs as necessary.
+        for t.i == len(t.res.Result) {
+                if !t.res.GetMoreResults() {
+                        t.err = Done
+                        return nil, nil, t.err
+                }
+                t.prevCC = t.res.CompiledCursor
+                var count int32
+                if t.count > 0 && (t.limit < 0 || t.count < t.limit) {
+                        count = t.count
+                } else {
+                        count = t.limit
+                }
+                if err := callNext(t.c, &t.res, 0, count); err != nil {
+                        t.err = err
+                        return nil, nil, t.err
+                }
+                if t.res.GetSkippedResults() != 0 {
+                        t.err = errors.New("datastore: internal error: iterator has skipped results")
+                        return nil, nil, t.err
+                }
+                t.i = 0
+                if t.limit >= 0 {
+                        t.limit -= int32(len(t.res.Result))
+                        if t.limit < 0 {
+                                t.err = errors.New("datastore: internal error: query returned more results than the limit")
+                                return nil, nil, t.err
+                        }
+                }
+        }
+
+        // Extract the key from the t.i'th element of t.res.Result.
+        e := t.res.Result[t.i]
+        t.i++
+        if e.Key == nil {
+                return nil, nil, errors.New("datastore: internal error: server did not return a key")
+        }
+        k, err := protoToKey(e.Key)
+        if err != nil || k.Incomplete() {
+                return nil, nil, errors.New("datastore: internal error: server returned an invalid key")
+        }
+        return k, e, nil
+}
+
+// Cursor returns a cursor for the iterator's current location.
+func (t *Iterator) Cursor() (Cursor, error) {
+        if t.err != nil && t.err != Done {
+                return Cursor{}, t.err
+        }
+        // If we are at either end of the current batch of results,
+        // return the compiled cursor at that end.
+        skipped := t.res.GetSkippedResults()
+        if t.i == 0 && skipped == 0 {
+                if t.prevCC == nil {
+                        // A nil pointer (of type *pb.CompiledCursor) means no constraint:
+                        // passing it as the end cursor of a new query means unlimited results
+                        // (glossing over the integer limit parameter for now).
+                        // A non-nil pointer to an empty pb.CompiledCursor means the start:
+                        // passing it as the end cursor of a new query means 0 results.
+                        // If prevCC was nil, then the original query had no start cursor, but
+                        // Iterator.Cursor should return "the start" instead of unlimited.
+                        return Cursor{&zeroCC}, nil
+                }
+                return Cursor{t.prevCC}, nil
+        }
+        if t.i == len(t.res.Result) {
+                return Cursor{t.res.CompiledCursor}, nil
+        }
+        // Otherwise, re-run the query offset to this iterator's position, starting from
+        // the most recent compiled cursor. This is done on a best-effort basis, as it
+        // is racy; if a concurrent process has added or removed entities, then the
+        // cursor returned may be inconsistent.
+        q := t.q.clone()
+        q.start = t.prevCC
+        q.offset = skipped + int32(t.i)
+        q.limit = 0
+        q.keysOnly = len(q.projection) == 0
+        t1 := q.Run(t.c)
+        _, _, err := t1.next()
+        if err != Done {
+                if err == nil {
+                        err = fmt.Errorf("datastore: internal error: zero-limit query did not have zero results")
+                }
+                return Cursor{}, err
+        }
+        return Cursor{t1.res.CompiledCursor}, nil
+}
+
+var zeroCC pb.CompiledCursor
+
+// Cursor is an iterator's position. It can be converted to and from an opaque
+// string. A cursor can be used from different HTTP requests, but only with a
+// query with the same kind, ancestor, filter and order constraints.
+type Cursor struct {
+        cc *pb.CompiledCursor
+}
+
+// String returns a base-64 string representation of a cursor.
+func (c Cursor) String() string {
+        if c.cc == nil {
+                return ""
+        }
+        b, err := proto.Marshal(c.cc)
+        if err != nil {
+                // The only way to construct a Cursor with a non-nil cc field is to
+                // unmarshal from the byte representation. We panic if the unmarshal
+                // succeeds but the marshaling of the unchanged protobuf value fails.
+                panic(fmt.Sprintf("datastore: internal error: malformed cursor: %v", err))
+        }
+        return strings.TrimRight(base64.URLEncoding.EncodeToString(b), "=")
+}
+
+// Decode decodes a cursor from its base-64 string representation.
+func DecodeCursor(s string) (Cursor, error) {
+        if s == "" {
+                return Cursor{&zeroCC}, nil
+        }
+        if n := len(s) % 4; n != 0 {
+                s += strings.Repeat("=", 4-n)
+        }
+        b, err := base64.URLEncoding.DecodeString(s)
+        if err != nil {
+                return Cursor{}, err
+        }
+        cc := &pb.CompiledCursor{}
+        if err := proto.Unmarshal(b, cc); err != nil {
+                return Cursor{}, err
+        }
+        return Cursor{cc}, nil
+}
diff --git a/vendor/google.golang.org/appengine/datastore/save.go b/vendor/google.golang.org/appengine/datastore/save.go
new file mode 100644
index 0000000..7b045a5
--- /dev/null
+++ b/vendor/google.golang.org/appengine/datastore/save.go
@@ -0,0 +1,333 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package datastore
+
+import (
+        "errors"
+        "fmt"
+        "math"
+        "reflect"
+        "time"
+
+        "github.com/golang/protobuf/proto"
+
+        "google.golang.org/appengine"
+        pb "google.golang.org/appengine/internal/datastore"
+)
+
+func toUnixMicro(t time.Time) int64 {
+        // We cannot use t.UnixNano() / 1e3 because we want to handle times more than
+        // 2^63 nanoseconds (which is about 292 years) away from 1970, and those cannot
+        // be represented in the numerator of a single int64 divide.
+        return t.Unix()*1e6 + int64(t.Nanosecond()/1e3)
+}
+
+func fromUnixMicro(t int64) time.Time {
+        return time.Unix(t/1e6, (t%1e6)*1e3).UTC()
+}
+
+var (
+        minTime = time.Unix(int64(math.MinInt64)/1e6, (int64(math.MinInt64)%1e6)*1e3)
+        maxTime = time.Unix(int64(math.MaxInt64)/1e6, (int64(math.MaxInt64)%1e6)*1e3)
+)
+
+// valueToProto converts a named value to a newly allocated Property.
+// The returned error string is empty on success.
+func valueToProto(defaultAppID, name string, v reflect.Value, multiple bool) (p *pb.Property, errStr string) {
+        var (
+                pv          pb.PropertyValue
+                unsupported bool
+        )
+        switch v.Kind() {
+        case reflect.Invalid:
+                // No-op.
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                pv.Int64Value = proto.Int64(v.Int())
+        case reflect.Bool:
+                pv.BooleanValue = proto.Bool(v.Bool())
+        case reflect.String:
+                pv.StringValue = proto.String(v.String())
+        case reflect.Float32, reflect.Float64:
+                pv.DoubleValue = proto.Float64(v.Float())
+        case reflect.Ptr:
+                if k, ok := v.Interface().(*Key); ok {
+                        if k != nil {
+                                pv.Referencevalue = keyToReferenceValue(defaultAppID, k)
+                        }
+                } else {
+                        unsupported = true
+                }
+        case reflect.Struct:
+                switch t := v.Interface().(type) {
+                case time.Time:
+                        if t.Before(minTime) || t.After(maxTime) {
+                                return nil, "time value out of range"
+                        }
+                        pv.Int64Value = proto.Int64(toUnixMicro(t))
+                case appengine.GeoPoint:
+                        if !t.Valid() {
+                                return nil, "invalid GeoPoint value"
+                        }
+                        // NOTE: Strangely, latitude maps to X, longitude to Y.
+                        pv.Pointvalue = &pb.PropertyValue_PointValue{X: &t.Lat, Y: &t.Lng}
+                default:
+                        unsupported = true
+                }
+        case reflect.Slice:
+                if b, ok := v.Interface().([]byte); ok {
+                        pv.StringValue = proto.String(string(b))
+                } else {
+                        // nvToProto should already catch slice values.
+                        // If we get here, we have a slice of slice values.
+                        unsupported = true
+                }
+        default:
+                unsupported = true
+        }
+        if unsupported {
+                return nil, "unsupported datastore value type: " + v.Type().String()
+        }
+        p = &pb.Property{
+                Name:     proto.String(name),
+                Value:    &pv,
+                Multiple: proto.Bool(multiple),
+        }
+        if v.IsValid() {
+                switch v.Interface().(type) {
+                case []byte:
+                        p.Meaning = pb.Property_BLOB.Enum()
+                case ByteString:
+                        p.Meaning = pb.Property_BYTESTRING.Enum()
+                case appengine.BlobKey:
+                        p.Meaning = pb.Property_BLOBKEY.Enum()
+                case time.Time:
+                        p.Meaning = pb.Property_GD_WHEN.Enum()
+                case appengine.GeoPoint:
+                        p.Meaning = pb.Property_GEORSS_POINT.Enum()
+                }
+        }
+        return p, ""
+}
+
+type saveOpts struct {
+        noIndex   bool
+        multiple  bool
+        omitEmpty bool
+}
+
+// saveEntity saves an EntityProto into a PropertyLoadSaver or struct pointer.
+func saveEntity(defaultAppID string, key *Key, src interface{}) (*pb.EntityProto, error) {
+        var err error
+        var props []Property
+        if e, ok := src.(PropertyLoadSaver); ok {
+                props, err = e.Save()
+        } else {
+                props, err = SaveStruct(src)
+        }
+        if err != nil {
+                return nil, err
+        }
+        return propertiesToProto(defaultAppID, key, props)
+}
+
+func saveStructProperty(props *[]Property, name string, opts saveOpts, v reflect.Value) error {
+        if opts.omitEmpty && isEmptyValue(v) {
+                return nil
+        }
+        p := Property{
+                Name:     name,
+                NoIndex:  opts.noIndex,
+                Multiple: opts.multiple,
+        }
+        switch x := v.Interface().(type) {
+        case *Key:
+                p.Value = x
+        case time.Time:
+                p.Value = x
+        case appengine.BlobKey:
+                p.Value = x
+        case appengine.GeoPoint:
+                p.Value = x
+        case ByteString:
+                p.Value = x
+        default:
+                switch v.Kind() {
+                case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                        p.Value = v.Int()
+                case reflect.Bool:
+                        p.Value = v.Bool()
+                case reflect.String:
+                        p.Value = v.String()
+                case reflect.Float32, reflect.Float64:
+                        p.Value = v.Float()
+                case reflect.Slice:
+                        if v.Type().Elem().Kind() == reflect.Uint8 {
+                                p.NoIndex = true
+                                p.Value = v.Bytes()
+                        }
+                case reflect.Struct:
+                        if !v.CanAddr() {
+                                return fmt.Errorf("datastore: unsupported struct field: value is unaddressable")
+                        }
+                        sub, err := newStructPLS(v.Addr().Interface())
+                        if err != nil {
+                                return fmt.Errorf("datastore: unsupported struct field: %v", err)
+                        }
+                        return sub.save(props, name+".", opts)
+                }
+        }
+        if p.Value == nil {
+                return fmt.Errorf("datastore: unsupported struct field type: %v", v.Type())
+        }
+        *props = append(*props, p)
+        return nil
+}
+
+func (s structPLS) Save() ([]Property, error) {
+        var props []Property
+        if err := s.save(&props, "", saveOpts{}); err != nil {
+                return nil, err
+        }
+        return props, nil
+}
+
+func (s structPLS) save(props *[]Property, prefix string, opts saveOpts) error {
+        for name, f := range s.codec.fields {
+                name = prefix + name
+                v := s.v.FieldByIndex(f.path)
+                if !v.IsValid() || !v.CanSet() {
+                        continue
+                }
+                var opts1 saveOpts
+                opts1.noIndex = opts.noIndex || f.noIndex
+                opts1.multiple = opts.multiple
+                opts1.omitEmpty = f.omitEmpty // don't propagate
+                // For slice fields that aren't []byte, save each element.
+                if v.Kind() == reflect.Slice && v.Type().Elem().Kind() != reflect.Uint8 {
+                        opts1.multiple = true
+                        for j := 0; j < v.Len(); j++ {
+                                if err := saveStructProperty(props, name, opts1, v.Index(j)); err != nil {
+                                        return err
+                                }
+                        }
+                        continue
+                }
+                // Otherwise, save the field itself.
+                if err := saveStructProperty(props, name, opts1, v); err != nil {
+                        return err
+                }
+        }
+        return nil
+}
+
+func propertiesToProto(defaultAppID string, key *Key, props []Property) (*pb.EntityProto, error) {
+        e := &pb.EntityProto{
+                Key: keyToProto(defaultAppID, key),
+        }
+        if key.parent == nil {
+                e.EntityGroup = &pb.Path{}
+        } else {
+                e.EntityGroup = keyToProto(defaultAppID, key.root()).Path
+        }
+        prevMultiple := make(map[string]bool)
+
+        for _, p := range props {
+                if pm, ok := prevMultiple[p.Name]; ok {
+                        if !pm || !p.Multiple {
+                                return nil, fmt.Errorf("datastore: multiple Properties with Name %q, but Multiple is false", p.Name)
+                        }
+                } else {
+                        prevMultiple[p.Name] = p.Multiple
+                }
+
+                x := &pb.Property{
+                        Name:     proto.String(p.Name),
+                        Value:    new(pb.PropertyValue),
+                        Multiple: proto.Bool(p.Multiple),
+                }
+                switch v := p.Value.(type) {
+                case int64:
+                        x.Value.Int64Value = proto.Int64(v)
+                case bool:
+                        x.Value.BooleanValue = proto.Bool(v)
+                case string:
+                        x.Value.StringValue = proto.String(v)
+                        if p.NoIndex {
+                                x.Meaning = pb.Property_TEXT.Enum()
+                        }
+                case float64:
+                        x.Value.DoubleValue = proto.Float64(v)
+                case *Key:
+                        if v != nil {
+                                x.Value.Referencevalue = keyToReferenceValue(defaultAppID, v)
+                        }
+                case time.Time:
+                        if v.Before(minTime) || v.After(maxTime) {
+                                return nil, fmt.Errorf("datastore: time value out of range")
+                        }
+                        x.Value.Int64Value = proto.Int64(toUnixMicro(v))
+                        x.Meaning = pb.Property_GD_WHEN.Enum()
+                case appengine.BlobKey:
+                        x.Value.StringValue = proto.String(string(v))
+                        x.Meaning = pb.Property_BLOBKEY.Enum()
+                case appengine.GeoPoint:
+                        if !v.Valid() {
+                                return nil, fmt.Errorf("datastore: invalid GeoPoint value")
+                        }
+                        // NOTE: Strangely, latitude maps to X, longitude to Y.
+                        x.Value.Pointvalue = &pb.PropertyValue_PointValue{X: &v.Lat, Y: &v.Lng}
+                        x.Meaning = pb.Property_GEORSS_POINT.Enum()
+                case []byte:
+                        x.Value.StringValue = proto.String(string(v))
+                        x.Meaning = pb.Property_BLOB.Enum()
+                        if !p.NoIndex {
+                                return nil, fmt.Errorf("datastore: cannot index a []byte valued Property with Name %q", p.Name)
+                        }
+                case ByteString:
+                        x.Value.StringValue = proto.String(string(v))
+                        x.Meaning = pb.Property_BYTESTRING.Enum()
+                default:
+                        if p.Value != nil {
+                                return nil, fmt.Errorf("datastore: invalid Value type for a Property with Name %q", p.Name)
+                        }
+                }
+
+                if p.NoIndex {
+                        e.RawProperty = append(e.RawProperty, x)
+                } else {
+                        e.Property = append(e.Property, x)
+                        if len(e.Property) > maxIndexedProperties {
+                                return nil, errors.New("datastore: too many indexed properties")
+                        }
+                }
+        }
+        return e, nil
+}
+
+// isEmptyValue is taken from the encoding/json package in the standard library.
+func isEmptyValue(v reflect.Value) bool {
+        switch v.Kind() {
+        case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+                // TODO(perfomance): Only reflect.String needed, other property types are not supported (copy/paste from json package)
+                return v.Len() == 0
+        case reflect.Bool:
+                return !v.Bool()
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                return v.Int() == 0
+        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+                // TODO(perfomance): Uint* are unsupported property types - should be removed (copy/paste from json package)
+                return v.Uint() == 0
+        case reflect.Float32, reflect.Float64:
+                return v.Float() == 0
+        case reflect.Interface, reflect.Ptr:
+                return v.IsNil()
+        case reflect.Struct:
+                switch x := v.Interface().(type) {
+                case time.Time:
+                        return x.IsZero()
+                }
+        }
+        return false
+}
diff --git a/vendor/google.golang.org/appengine/datastore/transaction.go b/vendor/google.golang.org/appengine/datastore/transaction.go
new file mode 100644
index 0000000..2ae8428
--- /dev/null
+++ b/vendor/google.golang.org/appengine/datastore/transaction.go
@@ -0,0 +1,96 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package datastore
+
+import (
+        "errors"
+
+        "golang.org/x/net/context"
+
+        "google.golang.org/appengine/internal"
+        pb "google.golang.org/appengine/internal/datastore"
+)
+
+func init() {
+        internal.RegisterTransactionSetter(func(x *pb.Query, t *pb.Transaction) {
+                x.Transaction = t
+        })
+        internal.RegisterTransactionSetter(func(x *pb.GetRequest, t *pb.Transaction) {
+                x.Transaction = t
+        })
+        internal.RegisterTransactionSetter(func(x *pb.PutRequest, t *pb.Transaction) {
+                x.Transaction = t
+        })
+        internal.RegisterTransactionSetter(func(x *pb.DeleteRequest, t *pb.Transaction) {
+                x.Transaction = t
+        })
+}
+
+// ErrConcurrentTransaction is returned when a transaction is rolled back due
+// to a conflict with a concurrent transaction.
+var ErrConcurrentTransaction = errors.New("datastore: concurrent transaction")
+
+// RunInTransaction runs f in a transaction. It calls f with a transaction
+// context tc that f should use for all App Engine operations.
+//
+// If f returns nil, RunInTransaction attempts to commit the transaction,
+// returning nil if it succeeds. If the commit fails due to a conflicting
+// transaction, RunInTransaction retries f, each time with a new transaction
+// context. It gives up and returns ErrConcurrentTransaction after three
+// failed attempts. The number of attempts can be configured by specifying
+// TransactionOptions.Attempts.
+//
+// If f returns non-nil, then any datastore changes will not be applied and
+// RunInTransaction returns that same error. The function f is not retried.
+//
+// Note that when f returns, the transaction is not yet committed. Calling code
+// must be careful not to assume that any of f's changes have been committed
+// until RunInTransaction returns nil.
+//
+// Since f may be called multiple times, f should usually be idempotent.
+// datastore.Get is not idempotent when unmarshaling slice fields.
+//
+// Nested transactions are not supported; c may not be a transaction context.
+func RunInTransaction(c context.Context, f func(tc context.Context) error, opts *TransactionOptions) error {
+        xg := false
+        if opts != nil {
+                xg = opts.XG
+        }
+        readOnly := false
+        if opts != nil {
+                readOnly = opts.ReadOnly
+        }
+        attempts := 3
+        if opts != nil && opts.Attempts > 0 {
+                attempts = opts.Attempts
+        }
+        var t *pb.Transaction
+        var err error
+        for i := 0; i < attempts; i++ {
+                if t, err = internal.RunTransactionOnce(c, f, xg, readOnly, t); err != internal.ErrConcurrentTransaction {
+                        return err
+                }
+        }
+        return ErrConcurrentTransaction
+}
+
+// TransactionOptions are the options for running a transaction.
+type TransactionOptions struct {
+        // XG is whether the transaction can cross multiple entity groups. In
+        // comparison, a single group transaction is one where all datastore keys
+        // used have the same root key. Note that cross group transactions do not
+        // have the same behavior as single group transactions. In particular, it
+        // is much more likely to see partially applied transactions in different
+        // entity groups, in global queries.
+        // It is valid to set XG to true even if the transaction is within a
+        // single entity group.
+        XG bool
+        // Attempts controls the number of retries to perform when commits fail
+        // due to a conflicting transaction. If omitted, it defaults to 3.
+        Attempts int
+        // ReadOnly controls whether the transaction is a read only transaction.
+        // Read only transactions are potentially more efficient.
+        ReadOnly bool
+}
diff --git a/vendor/google.golang.org/appengine/errors.go b/vendor/google.golang.org/appengine/errors.go
new file mode 100644
index 0000000..16d0772
--- /dev/null
+++ b/vendor/google.golang.org/appengine/errors.go
@@ -0,0 +1,46 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// This file provides error functions for common API failure modes.
+
+package appengine
+
+import (
+        "fmt"
+
+        "google.golang.org/appengine/internal"
+)
+
+// IsOverQuota reports whether err represents an API call failure
+// due to insufficient available quota.
+func IsOverQuota(err error) bool {
+        callErr, ok := err.(*internal.CallError)
+        return ok && callErr.Code == 4
+}
+
+// MultiError is returned by batch operations when there are errors with
+// particular elements. Errors will be in a one-to-one correspondence with
+// the input elements; successful elements will have a nil entry.
+type MultiError []error
+
+func (m MultiError) Error() string {
+        s, n := "", 0
+        for _, e := range m {
+                if e != nil {
+                        if n == 0 {
+                                s = e.Error()
+                        }
+                        n++
+                }
+        }
+        switch n {
+        case 0:
+                return "(0 errors)"
+        case 1:
+                return s
+        case 2:
+                return s + " (and 1 other error)"
+        }
+        return fmt.Sprintf("%s (and %d other errors)", s, n-1)
+}
diff --git a/vendor/google.golang.org/appengine/go.mod b/vendor/google.golang.org/appengine/go.mod
new file mode 100644
index 0000000..f449359
--- /dev/null
+++ b/vendor/google.golang.org/appengine/go.mod
@@ -0,0 +1,7 @@
+module google.golang.org/appengine
+
+require (
+        github.com/golang/protobuf v1.2.0
+        golang.org/x/net v0.0.0-20180724234803-3673e40ba225
+        golang.org/x/text v0.3.0
+)
diff --git a/vendor/google.golang.org/appengine/go.sum b/vendor/google.golang.org/appengine/go.sum
new file mode 100644
index 0000000..1a221c0
--- /dev/null
+++ b/vendor/google.golang.org/appengine/go.sum
@@ -0,0 +1,6 @@
+github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225 h1:kNX+jCowfMYzvlSvJu5pQWEmyWFrBXJ3PBy10xKMXK8=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
diff --git a/vendor/google.golang.org/appengine/identity.go b/vendor/google.golang.org/appengine/identity.go
new file mode 100644
index 0000000..b8dcf8f
--- /dev/null
+++ b/vendor/google.golang.org/appengine/identity.go
@@ -0,0 +1,142 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package appengine
+
+import (
+        "time"
+
+        "golang.org/x/net/context"
+
+        "google.golang.org/appengine/internal"
+        pb "google.golang.org/appengine/internal/app_identity"
+        modpb "google.golang.org/appengine/internal/modules"
+)
+
+// AppID returns the application ID for the current application.
+// The string will be a plain application ID (e.g. "appid"), with a
+// domain prefix for custom domain deployments (e.g. "example.com:appid").
+func AppID(c context.Context) string { return internal.AppID(c) }
+
+// DefaultVersionHostname returns the standard hostname of the default version
+// of the current application (e.g. "my-app.appspot.com"). This is suitable for
+// use in constructing URLs.
+func DefaultVersionHostname(c context.Context) string {
+        return internal.DefaultVersionHostname(c)
+}
+
+// ModuleName returns the module name of the current instance.
+func ModuleName(c context.Context) string {
+        return internal.ModuleName(c)
+}
+
+// ModuleHostname returns a hostname of a module instance.
+// If module is the empty string, it refers to the module of the current instance.
+// If version is empty, it refers to the version of the current instance if valid,
+// or the default version of the module of the current instance.
+// If instance is empty, ModuleHostname returns the load-balancing hostname.
+func ModuleHostname(c context.Context, module, version, instance string) (string, error) {
+        req := &modpb.GetHostnameRequest{}
+        if module != "" {
+                req.Module = &module
+        }
+        if version != "" {
+                req.Version = &version
+        }
+        if instance != "" {
+                req.Instance = &instance
+        }
+        res := &modpb.GetHostnameResponse{}
+        if err := internal.Call(c, "modules", "GetHostname", req, res); err != nil {
+                return "", err
+        }
+        return *res.Hostname, nil
+}
+
+// VersionID returns the version ID for the current application.
+// It will be of the form "X.Y", where X is specified in app.yaml,
+// and Y is a number generated when each version of the app is uploaded.
+// It does not include a module name.
+func VersionID(c context.Context) string { return internal.VersionID(c) }
+
+// InstanceID returns a mostly-unique identifier for this instance.
+func InstanceID() string { return internal.InstanceID() }
+
+// Datacenter returns an identifier for the datacenter that the instance is running in.
+func Datacenter(c context.Context) string { return internal.Datacenter(c) }
+
+// ServerSoftware returns the App Engine release version.
+// In production, it looks like "Google App Engine/X.Y.Z".
+// In the development appserver, it looks like "Development/X.Y".
+func ServerSoftware() string { return internal.ServerSoftware() }
+
+// RequestID returns a string that uniquely identifies the request.
+func RequestID(c context.Context) string { return internal.RequestID(c) }
+
+// AccessToken generates an OAuth2 access token for the specified scopes on
+// behalf of service account of this application. This token will expire after
+// the returned time.
+func AccessToken(c context.Context, scopes ...string) (token string, expiry time.Time, err error) {
+        req := &pb.GetAccessTokenRequest{Scope: scopes}
+        res := &pb.GetAccessTokenResponse{}
+
+        err = internal.Call(c, "app_identity_service", "GetAccessToken", req, res)
+        if err != nil {
+                return "", time.Time{}, err
+        }
+        return res.GetAccessToken(), time.Unix(res.GetExpirationTime(), 0), nil
+}
+
+// Certificate represents a public certificate for the app.
+type Certificate struct {
+        KeyName string
+        Data    []byte // PEM-encoded X.509 certificate
+}
+
+// PublicCertificates retrieves the public certificates for the app.
+// They can be used to verify a signature returned by SignBytes.
+func PublicCertificates(c context.Context) ([]Certificate, error) {
+        req := &pb.GetPublicCertificateForAppRequest{}
+        res := &pb.GetPublicCertificateForAppResponse{}
+        if err := internal.Call(c, "app_identity_service", "GetPublicCertificatesForApp", req, res); err != nil {
+                return nil, err
+        }
+        var cs []Certificate
+        for _, pc := range res.PublicCertificateList {
+                cs = append(cs, Certificate{
+                        KeyName: pc.GetKeyName(),
+                        Data:    []byte(pc.GetX509CertificatePem()),
+                })
+        }
+        return cs, nil
+}
+
+// ServiceAccount returns a string representing the service account name, in
+// the form of an email address (typically app_id@appspot.gserviceaccount.com).
+func ServiceAccount(c context.Context) (string, error) {
+        req := &pb.GetServiceAccountNameRequest{}
+        res := &pb.GetServiceAccountNameResponse{}
+
+        err := internal.Call(c, "app_identity_service", "GetServiceAccountName", req, res)
+        if err != nil {
+                return "", err
+        }
+        return res.GetServiceAccountName(), err
+}
+
+// SignBytes signs bytes using a private key unique to your application.
+func SignBytes(c context.Context, bytes []byte) (keyName string, signature []byte, err error) {
+        req := &pb.SignForAppRequest{BytesToSign: bytes}
+        res := &pb.SignForAppResponse{}
+
+        if err := internal.Call(c, "app_identity_service", "SignForApp", req, res); err != nil {
+                return "", nil, err
+        }
+        return res.GetKeyName(), res.GetSignatureBytes(), nil
+}
+
+func init() {
+        internal.RegisterErrorCodeMap("app_identity_service", pb.AppIdentityServiceError_ErrorCode_name)
+        internal.RegisterErrorCodeMap("modules", modpb.ModulesServiceError_ErrorCode_name)
+}
diff --git a/vendor/google.golang.org/appengine/internal/api.go b/vendor/google.golang.org/appengine/internal/api.go
new file mode 100644
index 0000000..bbc1cb9
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/api.go
@@ -0,0 +1,671 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build !appengine
+
+package internal
+
+import (
+        "bytes"
+        "errors"
+        "fmt"
+        "io/ioutil"
+        "log"
+        "net"
+        "net/http"
+        "net/url"
+        "os"
+        "runtime"
+        "strconv"
+        "strings"
+        "sync"
+        "sync/atomic"
+        "time"
+
+        "github.com/golang/protobuf/proto"
+        netcontext "golang.org/x/net/context"
+
+        basepb "google.golang.org/appengine/internal/base"
+        logpb "google.golang.org/appengine/internal/log"
+        remotepb "google.golang.org/appengine/internal/remote_api"
+)
+
+const (
+        apiPath             = "/rpc_http"
+        defaultTicketSuffix = "/default.20150612t184001.0"
+)
+
+var (
+        // Incoming headers.
+        ticketHeader       = http.CanonicalHeaderKey("X-AppEngine-API-Ticket")
+        dapperHeader       = http.CanonicalHeaderKey("X-Google-DapperTraceInfo")
+        traceHeader        = http.CanonicalHeaderKey("X-Cloud-Trace-Context")
+        curNamespaceHeader = http.CanonicalHeaderKey("X-AppEngine-Current-Namespace")
+        userIPHeader       = http.CanonicalHeaderKey("X-AppEngine-User-IP")
+        remoteAddrHeader   = http.CanonicalHeaderKey("X-AppEngine-Remote-Addr")
+
+        // Outgoing headers.
+        apiEndpointHeader      = http.CanonicalHeaderKey("X-Google-RPC-Service-Endpoint")
+        apiEndpointHeaderValue = []string{"app-engine-apis"}
+        apiMethodHeader        = http.CanonicalHeaderKey("X-Google-RPC-Service-Method")
+        apiMethodHeaderValue   = []string{"/VMRemoteAPI.CallRemoteAPI"}
+        apiDeadlineHeader      = http.CanonicalHeaderKey("X-Google-RPC-Service-Deadline")
+        apiContentType         = http.CanonicalHeaderKey("Content-Type")
+        apiContentTypeValue    = []string{"application/octet-stream"}
+        logFlushHeader         = http.CanonicalHeaderKey("X-AppEngine-Log-Flush-Count")
+
+        apiHTTPClient = &http.Client{
+                Transport: &http.Transport{
+                        Proxy: http.ProxyFromEnvironment,
+                        Dial:  limitDial,
+                },
+        }
+
+        defaultTicketOnce     sync.Once
+        defaultTicket         string
+        backgroundContextOnce sync.Once
+        backgroundContext     netcontext.Context
+)
+
+func apiURL() *url.URL {
+        host, port := "appengine.googleapis.internal", "10001"
+        if h := os.Getenv("API_HOST"); h != "" {
+                host = h
+        }
+        if p := os.Getenv("API_PORT"); p != "" {
+                port = p
+        }
+        return &url.URL{
+                Scheme: "http",
+                Host:   host + ":" + port,
+                Path:   apiPath,
+        }
+}
+
+func handleHTTP(w http.ResponseWriter, r *http.Request) {
+        c := &context{
+                req:       r,
+                outHeader: w.Header(),
+                apiURL:    apiURL(),
+        }
+        r = r.WithContext(withContext(r.Context(), c))
+        c.req = r
+
+        stopFlushing := make(chan int)
+
+        // Patch up RemoteAddr so it looks reasonable.
+        if addr := r.Header.Get(userIPHeader); addr != "" {
+                r.RemoteAddr = addr
+        } else if addr = r.Header.Get(remoteAddrHeader); addr != "" {
+                r.RemoteAddr = addr
+        } else {
+                // Should not normally reach here, but pick a sensible default anyway.
+                r.RemoteAddr = "127.0.0.1"
+        }
+        // The address in the headers will most likely be of these forms:
+        //      123.123.123.123
+        //      2001:db8::1
+        // net/http.Request.RemoteAddr is specified to be in "IP:port" form.
+        if _, _, err := net.SplitHostPort(r.RemoteAddr); err != nil {
+                // Assume the remote address is only a host; add a default port.
+                r.RemoteAddr = net.JoinHostPort(r.RemoteAddr, "80")
+        }
+
+        // Start goroutine responsible for flushing app logs.
+        // This is done after adding c to ctx.m (and stopped before removing it)
+        // because flushing logs requires making an API call.
+        go c.logFlusher(stopFlushing)
+
+        executeRequestSafely(c, r)
+        c.outHeader = nil // make sure header changes aren't respected any more
+
+        stopFlushing <- 1 // any logging beyond this point will be dropped
+
+        // Flush any pending logs asynchronously.
+        c.pendingLogs.Lock()
+        flushes := c.pendingLogs.flushes
+        if len(c.pendingLogs.lines) > 0 {
+                flushes++
+        }
+        c.pendingLogs.Unlock()
+        flushed := make(chan struct{})
+        go func() {
+                defer close(flushed)
+                // Force a log flush, because with very short requests we
+                // may not ever flush logs.
+                c.flushLog(true)
+        }()
+        w.Header().Set(logFlushHeader, strconv.Itoa(flushes))
+
+        // Avoid nil Write call if c.Write is never called.
+        if c.outCode != 0 {
+                w.WriteHeader(c.outCode)
+        }
+        if c.outBody != nil {
+                w.Write(c.outBody)
+        }
+        // Wait for the last flush to complete before returning,
+        // otherwise the security ticket will not be valid.
+        <-flushed
+}
+
+func executeRequestSafely(c *context, r *http.Request) {
+        defer func() {
+                if x := recover(); x != nil {
+                        logf(c, 4, "%s", renderPanic(x)) // 4 == critical
+                        c.outCode = 500
+                }
+        }()
+
+        http.DefaultServeMux.ServeHTTP(c, r)
+}
+
+func renderPanic(x interface{}) string {
+        buf := make([]byte, 16<<10) // 16 KB should be plenty
+        buf = buf[:runtime.Stack(buf, false)]
+
+        // Remove the first few stack frames:
+        //   this func
+        //   the recover closure in the caller
+        // That will root the stack trace at the site of the panic.
+        const (
+                skipStart  = "internal.renderPanic"
+                skipFrames = 2
+        )
+        start := bytes.Index(buf, []byte(skipStart))
+        p := start
+        for i := 0; i < skipFrames*2 && p+1 < len(buf); i++ {
+                p = bytes.IndexByte(buf[p+1:], '\n') + p + 1
+                if p < 0 {
+                        break
+                }
+        }
+        if p >= 0 {
+                // buf[start:p+1] is the block to remove.
+                // Copy buf[p+1:] over buf[start:] and shrink buf.
+                copy(buf[start:], buf[p+1:])
+                buf = buf[:len(buf)-(p+1-start)]
+        }
+
+        // Add panic heading.
+        head := fmt.Sprintf("panic: %v\n\n", x)
+        if len(head) > len(buf) {
+                // Extremely unlikely to happen.
+                return head
+        }
+        copy(buf[len(head):], buf)
+        copy(buf, head)
+
+        return string(buf)
+}
+
+// context represents the context of an in-flight HTTP request.
+// It implements the appengine.Context and http.ResponseWriter interfaces.
+type context struct {
+        req *http.Request
+
+        outCode   int
+        outHeader http.Header
+        outBody   []byte
+
+        pendingLogs struct {
+                sync.Mutex
+                lines   []*logpb.UserAppLogLine
+                flushes int
+        }
+
+        apiURL *url.URL
+}
+
+var contextKey = "holds a *context"
+
+// jointContext joins two contexts in a superficial way.
+// It takes values and timeouts from a base context, and only values from another context.
+type jointContext struct {
+        base       netcontext.Context
+        valuesOnly netcontext.Context
+}
+
+func (c jointContext) Deadline() (time.Time, bool) {
+        return c.base.Deadline()
+}
+
+func (c jointContext) Done() <-chan struct{} {
+        return c.base.Done()
+}
+
+func (c jointContext) Err() error {
+        return c.base.Err()
+}
+
+func (c jointContext) Value(key interface{}) interface{} {
+        if val := c.base.Value(key); val != nil {
+                return val
+        }
+        return c.valuesOnly.Value(key)
+}
+
+// fromContext returns the App Engine context or nil if ctx is not
+// derived from an App Engine context.
+func fromContext(ctx netcontext.Context) *context {
+        c, _ := ctx.Value(&contextKey).(*context)
+        return c
+}
+
+func withContext(parent netcontext.Context, c *context) netcontext.Context {
+        ctx := netcontext.WithValue(parent, &contextKey, c)
+        if ns := c.req.Header.Get(curNamespaceHeader); ns != "" {
+                ctx = withNamespace(ctx, ns)
+        }
+        return ctx
+}
+
+func toContext(c *context) netcontext.Context {
+        return withContext(netcontext.Background(), c)
+}
+
+func IncomingHeaders(ctx netcontext.Context) http.Header {
+        if c := fromContext(ctx); c != nil {
+                return c.req.Header
+        }
+        return nil
+}
+
+func ReqContext(req *http.Request) netcontext.Context {
+        return req.Context()
+}
+
+func WithContext(parent netcontext.Context, req *http.Request) netcontext.Context {
+        return jointContext{
+                base:       parent,
+                valuesOnly: req.Context(),
+        }
+}
+
+// DefaultTicket returns a ticket used for background context or dev_appserver.
+func DefaultTicket() string {
+        defaultTicketOnce.Do(func() {
+                if IsDevAppServer() {
+                        defaultTicket = "testapp" + defaultTicketSuffix
+                        return
+                }
+                appID := partitionlessAppID()
+                escAppID := strings.Replace(strings.Replace(appID, ":", "_", -1), ".", "_", -1)
+                majVersion := VersionID(nil)
+                if i := strings.Index(majVersion, "."); i > 0 {
+                        majVersion = majVersion[:i]
+                }
+                defaultTicket = fmt.Sprintf("%s/%s.%s.%s", escAppID, ModuleName(nil), majVersion, InstanceID())
+        })
+        return defaultTicket
+}
+
+func BackgroundContext() netcontext.Context {
+        backgroundContextOnce.Do(func() {
+                // Compute background security ticket.
+                ticket := DefaultTicket()
+
+                c := &context{
+                        req: &http.Request{
+                                Header: http.Header{
+                                        ticketHeader: []string{ticket},
+                                },
+                        },
+                        apiURL: apiURL(),
+                }
+                backgroundContext = toContext(c)
+
+                // TODO(dsymonds): Wire up the shutdown handler to do a final flush.
+                go c.logFlusher(make(chan int))
+        })
+
+        return backgroundContext
+}
+
+// RegisterTestRequest registers the HTTP request req for testing, such that
+// any API calls are sent to the provided URL. It returns a closure to delete
+// the registration.
+// It should only be used by aetest package.
+func RegisterTestRequest(req *http.Request, apiURL *url.URL, decorate func(netcontext.Context) netcontext.Context) (*http.Request, func()) {
+        c := &context{
+                req:    req,
+                apiURL: apiURL,
+        }
+        ctx := withContext(decorate(req.Context()), c)
+        req = req.WithContext(ctx)
+        c.req = req
+        return req, func() {}
+}
+
+var errTimeout = &CallError{
+        Detail:  "Deadline exceeded",
+        Code:    int32(remotepb.RpcError_CANCELLED),
+        Timeout: true,
+}
+
+func (c *context) Header() http.Header { return c.outHeader }
+
+// Copied from $GOROOT/src/pkg/net/http/transfer.go. Some response status
+// codes do not permit a response body (nor response entity headers such as
+// Content-Length, Content-Type, etc).
+func bodyAllowedForStatus(status int) bool {
+        switch {
+        case status >= 100 && status <= 199:
+                return false
+        case status == 204:
+                return false
+        case status == 304:
+                return false
+        }
+        return true
+}
+
+func (c *context) Write(b []byte) (int, error) {
+        if c.outCode == 0 {
+                c.WriteHeader(http.StatusOK)
+        }
+        if len(b) > 0 && !bodyAllowedForStatus(c.outCode) {
+                return 0, http.ErrBodyNotAllowed
+        }
+        c.outBody = append(c.outBody, b...)
+        return len(b), nil
+}
+
+func (c *context) WriteHeader(code int) {
+        if c.outCode != 0 {
+                logf(c, 3, "WriteHeader called multiple times on request.") // error level
+                return
+        }
+        c.outCode = code
+}
+
+func (c *context) post(body []byte, timeout time.Duration) (b []byte, err error) {
+        hreq := &http.Request{
+                Method: "POST",
+                URL:    c.apiURL,
+                Header: http.Header{
+                        apiEndpointHeader: apiEndpointHeaderValue,
+                        apiMethodHeader:   apiMethodHeaderValue,
+                        apiContentType:    apiContentTypeValue,
+                        apiDeadlineHeader: []string{strconv.FormatFloat(timeout.Seconds(), 'f', -1, 64)},
+                },
+                Body:          ioutil.NopCloser(bytes.NewReader(body)),
+                ContentLength: int64(len(body)),
+                Host:          c.apiURL.Host,
+        }
+        if info := c.req.Header.Get(dapperHeader); info != "" {
+                hreq.Header.Set(dapperHeader, info)
+        }
+        if info := c.req.Header.Get(traceHeader); info != "" {
+                hreq.Header.Set(traceHeader, info)
+        }
+
+        tr := apiHTTPClient.Transport.(*http.Transport)
+
+        var timedOut int32 // atomic; set to 1 if timed out
+        t := time.AfterFunc(timeout, func() {
+                atomic.StoreInt32(&timedOut, 1)
+                tr.CancelRequest(hreq)
+        })
+        defer t.Stop()
+        defer func() {
+                // Check if timeout was exceeded.
+                if atomic.LoadInt32(&timedOut) != 0 {
+                        err = errTimeout
+                }
+        }()
+
+        hresp, err := apiHTTPClient.Do(hreq)
+        if err != nil {
+                return nil, &CallError{
+                        Detail: fmt.Sprintf("service bridge HTTP failed: %v", err),
+                        Code:   int32(remotepb.RpcError_UNKNOWN),
+                }
+        }
+        defer hresp.Body.Close()
+        hrespBody, err := ioutil.ReadAll(hresp.Body)
+        if hresp.StatusCode != 200 {
+                return nil, &CallError{
+                        Detail: fmt.Sprintf("service bridge returned HTTP %d (%q)", hresp.StatusCode, hrespBody),
+                        Code:   int32(remotepb.RpcError_UNKNOWN),
+                }
+        }
+        if err != nil {
+                return nil, &CallError{
+                        Detail: fmt.Sprintf("service bridge response bad: %v", err),
+                        Code:   int32(remotepb.RpcError_UNKNOWN),
+                }
+        }
+        return hrespBody, nil
+}
+
+func Call(ctx netcontext.Context, service, method string, in, out proto.Message) error {
+        if ns := NamespaceFromContext(ctx); ns != "" {
+                if fn, ok := NamespaceMods[service]; ok {
+                        fn(in, ns)
+                }
+        }
+
+        if f, ctx, ok := callOverrideFromContext(ctx); ok {
+                return f(ctx, service, method, in, out)
+        }
+
+        // Handle already-done contexts quickly.
+        select {
+        case <-ctx.Done():
+                return ctx.Err()
+        default:
+        }
+
+        c := fromContext(ctx)
+        if c == nil {
+                // Give a good error message rather than a panic lower down.
+                return errNotAppEngineContext
+        }
+
+        // Apply transaction modifications if we're in a transaction.
+        if t := transactionFromContext(ctx); t != nil {
+                if t.finished {
+                        return errors.New("transaction context has expired")
+                }
+                applyTransaction(in, &t.transaction)
+        }
+
+        // Default RPC timeout is 60s.
+        timeout := 60 * time.Second
+        if deadline, ok := ctx.Deadline(); ok {
+                timeout = deadline.Sub(time.Now())
+        }
+
+        data, err := proto.Marshal(in)
+        if err != nil {
+                return err
+        }
+
+        ticket := c.req.Header.Get(ticketHeader)
+        // Use a test ticket under test environment.
+        if ticket == "" {
+                if appid := ctx.Value(&appIDOverrideKey); appid != nil {
+                        ticket = appid.(string) + defaultTicketSuffix
+                }
+        }
+        // Fall back to use background ticket when the request ticket is not available in Flex or dev_appserver.
+        if ticket == "" {
+                ticket = DefaultTicket()
+        }
+        req := &remotepb.Request{
+                ServiceName: &service,
+                Method:      &method,
+                Request:     data,
+                RequestId:   &ticket,
+        }
+        hreqBody, err := proto.Marshal(req)
+        if err != nil {
+                return err
+        }
+
+        hrespBody, err := c.post(hreqBody, timeout)
+        if err != nil {
+                return err
+        }
+
+        res := &remotepb.Response{}
+        if err := proto.Unmarshal(hrespBody, res); err != nil {
+                return err
+        }
+        if res.RpcError != nil {
+                ce := &CallError{
+                        Detail: res.RpcError.GetDetail(),
+                        Code:   *res.RpcError.Code,
+                }
+                switch remotepb.RpcError_ErrorCode(ce.Code) {
+                case remotepb.RpcError_CANCELLED, remotepb.RpcError_DEADLINE_EXCEEDED:
+                        ce.Timeout = true
+                }
+                return ce
+        }
+        if res.ApplicationError != nil {
+                return &APIError{
+                        Service: *req.ServiceName,
+                        Detail:  res.ApplicationError.GetDetail(),
+                        Code:    *res.ApplicationError.Code,
+                }
+        }
+        if res.Exception != nil || res.JavaException != nil {
+                // This shouldn't happen, but let's be defensive.
+                return &CallError{
+                        Detail: "service bridge returned exception",
+                        Code:   int32(remotepb.RpcError_UNKNOWN),
+                }
+        }
+        return proto.Unmarshal(res.Response, out)
+}
+
+func (c *context) Request() *http.Request {
+        return c.req
+}
+
+func (c *context) addLogLine(ll *logpb.UserAppLogLine) {
+        // Truncate long log lines.
+        // TODO(dsymonds): Check if this is still necessary.
+        const lim = 8 << 10
+        if len(*ll.Message) > lim {
+                suffix := fmt.Sprintf("...(length %d)", len(*ll.Message))
+                ll.Message = proto.String((*ll.Message)[:lim-len(suffix)] + suffix)
+        }
+
+        c.pendingLogs.Lock()
+        c.pendingLogs.lines = append(c.pendingLogs.lines, ll)
+        c.pendingLogs.Unlock()
+}
+
+var logLevelName = map[int64]string{
+        0: "DEBUG",
+        1: "INFO",
+        2: "WARNING",
+        3: "ERROR",
+        4: "CRITICAL",
+}
+
+func logf(c *context, level int64, format string, args ...interface{}) {
+        if c == nil {
+                panic("not an App Engine context")
+        }
+        s := fmt.Sprintf(format, args...)
+        s = strings.TrimRight(s, "\n") // Remove any trailing newline characters.
+        c.addLogLine(&logpb.UserAppLogLine{
+                TimestampUsec: proto.Int64(time.Now().UnixNano() / 1e3),
+                Level:         &level,
+                Message:       &s,
+        })
+        // Only duplicate log to stderr if not running on App Engine second generation
+        if !IsSecondGen() {
+                log.Print(logLevelName[level] + ": " + s)
+        }
+}
+
+// flushLog attempts to flush any pending logs to the appserver.
+// It should not be called concurrently.
+func (c *context) flushLog(force bool) (flushed bool) {
+        c.pendingLogs.Lock()
+        // Grab up to 30 MB. We can get away with up to 32 MB, but let's be cautious.
+        n, rem := 0, 30<<20
+        for ; n < len(c.pendingLogs.lines); n++ {
+                ll := c.pendingLogs.lines[n]
+                // Each log line will require about 3 bytes of overhead.
+                nb := proto.Size(ll) + 3
+                if nb > rem {
+                        break
+                }
+                rem -= nb
+        }
+        lines := c.pendingLogs.lines[:n]
+        c.pendingLogs.lines = c.pendingLogs.lines[n:]
+        c.pendingLogs.Unlock()
+
+        if len(lines) == 0 && !force {
+                // Nothing to flush.
+                return false
+        }
+
+        rescueLogs := false
+        defer func() {
+                if rescueLogs {
+                        c.pendingLogs.Lock()
+                        c.pendingLogs.lines = append(lines, c.pendingLogs.lines...)
+                        c.pendingLogs.Unlock()
+                }
+        }()
+
+        buf, err := proto.Marshal(&logpb.UserAppLogGroup{
+                LogLine: lines,
+        })
+        if err != nil {
+                log.Printf("internal.flushLog: marshaling UserAppLogGroup: %v", err)
+                rescueLogs = true
+                return false
+        }
+
+        req := &logpb.FlushRequest{
+                Logs: buf,
+        }
+        res := &basepb.VoidProto{}
+        c.pendingLogs.Lock()
+        c.pendingLogs.flushes++
+        c.pendingLogs.Unlock()
+        if err := Call(toContext(c), "logservice", "Flush", req, res); err != nil {
+                log.Printf("internal.flushLog: Flush RPC: %v", err)
+                rescueLogs = true
+                return false
+        }
+        return true
+}
+
+const (
+        // Log flushing parameters.
+        flushInterval      = 1 * time.Second
+        forceFlushInterval = 60 * time.Second
+)
+
+func (c *context) logFlusher(stop <-chan int) {
+        lastFlush := time.Now()
+        tick := time.NewTicker(flushInterval)
+        for {
+                select {
+                case <-stop:
+                        // Request finished.
+                        tick.Stop()
+                        return
+                case <-tick.C:
+                        force := time.Now().Sub(lastFlush) > forceFlushInterval
+                        if c.flushLog(force) {
+                                lastFlush = time.Now()
+                        }
+                }
+        }
+}
+
+func ContextForTesting(req *http.Request) netcontext.Context {
+        return toContext(&context{req: req})
+}
diff --git a/vendor/google.golang.org/appengine/internal/api_classic.go b/vendor/google.golang.org/appengine/internal/api_classic.go
new file mode 100644
index 0000000..f0f40b2
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/api_classic.go
@@ -0,0 +1,169 @@
+// Copyright 2015 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+package internal
+
+import (
+        "errors"
+        "fmt"
+        "net/http"
+        "time"
+
+        "appengine"
+        "appengine_internal"
+        basepb "appengine_internal/base"
+
+        "github.com/golang/protobuf/proto"
+        netcontext "golang.org/x/net/context"
+)
+
+var contextKey = "holds an appengine.Context"
+
+// fromContext returns the App Engine context or nil if ctx is not
+// derived from an App Engine context.
+func fromContext(ctx netcontext.Context) appengine.Context {
+        c, _ := ctx.Value(&contextKey).(appengine.Context)
+        return c
+}
+
+// This is only for classic App Engine adapters.
+func ClassicContextFromContext(ctx netcontext.Context) (appengine.Context, error) {
+        c := fromContext(ctx)
+        if c == nil {
+                return nil, errNotAppEngineContext
+        }
+        return c, nil
+}
+
+func withContext(parent netcontext.Context, c appengine.Context) netcontext.Context {
+        ctx := netcontext.WithValue(parent, &contextKey, c)
+
+        s := &basepb.StringProto{}
+        c.Call("__go__", "GetNamespace", &basepb.VoidProto{}, s, nil)
+        if ns := s.GetValue(); ns != "" {
+                ctx = NamespacedContext(ctx, ns)
+        }
+
+        return ctx
+}
+
+func IncomingHeaders(ctx netcontext.Context) http.Header {
+        if c := fromContext(ctx); c != nil {
+                if req, ok := c.Request().(*http.Request); ok {
+                        return req.Header
+                }
+        }
+        return nil
+}
+
+func ReqContext(req *http.Request) netcontext.Context {
+        return WithContext(netcontext.Background(), req)
+}
+
+func WithContext(parent netcontext.Context, req *http.Request) netcontext.Context {
+        c := appengine.NewContext(req)
+        return withContext(parent, c)
+}
+
+type testingContext struct {
+        appengine.Context
+
+        req *http.Request
+}
+
+func (t *testingContext) FullyQualifiedAppID() string { return "dev~testcontext" }
+func (t *testingContext) Call(service, method string, _, _ appengine_internal.ProtoMessage, _ *appengine_internal.CallOptions) error {
+        if service == "__go__" && method == "GetNamespace" {
+                return nil
+        }
+        return fmt.Errorf("testingContext: unsupported Call")
+}
+func (t *testingContext) Request() interface{} { return t.req }
+
+func ContextForTesting(req *http.Request) netcontext.Context {
+        return withContext(netcontext.Background(), &testingContext{req: req})
+}
+
+func Call(ctx netcontext.Context, service, method string, in, out proto.Message) error {
+        if ns := NamespaceFromContext(ctx); ns != "" {
+                if fn, ok := NamespaceMods[service]; ok {
+                        fn(in, ns)
+                }
+        }
+
+        if f, ctx, ok := callOverrideFromContext(ctx); ok {
+                return f(ctx, service, method, in, out)
+        }
+
+        // Handle already-done contexts quickly.
+        select {
+        case <-ctx.Done():
+                return ctx.Err()
+        default:
+        }
+
+        c := fromContext(ctx)
+        if c == nil {
+                // Give a good error message rather than a panic lower down.
+                return errNotAppEngineContext
+        }
+
+        // Apply transaction modifications if we're in a transaction.
+        if t := transactionFromContext(ctx); t != nil {
+                if t.finished {
+                        return errors.New("transaction context has expired")
+                }
+                applyTransaction(in, &t.transaction)
+        }
+
+        var opts *appengine_internal.CallOptions
+        if d, ok := ctx.Deadline(); ok {
+                opts = &appengine_internal.CallOptions{
+                        Timeout: d.Sub(time.Now()),
+                }
+        }
+
+        err := c.Call(service, method, in, out, opts)
+        switch v := err.(type) {
+        case *appengine_internal.APIError:
+                return &APIError{
+                        Service: v.Service,
+                        Detail:  v.Detail,
+                        Code:    v.Code,
+                }
+        case *appengine_internal.CallError:
+                return &CallError{
+                        Detail:  v.Detail,
+                        Code:    v.Code,
+                        Timeout: v.Timeout,
+                }
+        }
+        return err
+}
+
+func handleHTTP(w http.ResponseWriter, r *http.Request) {
+        panic("handleHTTP called; this should be impossible")
+}
+
+func logf(c appengine.Context, level int64, format string, args ...interface{}) {
+        var fn func(format string, args ...interface{})
+        switch level {
+        case 0:
+                fn = c.Debugf
+        case 1:
+                fn = c.Infof
+        case 2:
+                fn = c.Warningf
+        case 3:
+                fn = c.Errorf
+        case 4:
+                fn = c.Criticalf
+        default:
+                // This shouldn't happen.
+                fn = c.Criticalf
+        }
+        fn(format, args...)
+}
diff --git a/vendor/google.golang.org/appengine/internal/api_common.go b/vendor/google.golang.org/appengine/internal/api_common.go
new file mode 100644
index 0000000..e0c0b21
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/api_common.go
@@ -0,0 +1,123 @@
+// Copyright 2015 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package internal
+
+import (
+        "errors"
+        "os"
+
+        "github.com/golang/protobuf/proto"
+        netcontext "golang.org/x/net/context"
+)
+
+var errNotAppEngineContext = errors.New("not an App Engine context")
+
+type CallOverrideFunc func(ctx netcontext.Context, service, method string, in, out proto.Message) error
+
+var callOverrideKey = "holds []CallOverrideFunc"
+
+func WithCallOverride(ctx netcontext.Context, f CallOverrideFunc) netcontext.Context {
+        // We avoid appending to any existing call override
+        // so we don't risk overwriting a popped stack below.
+        var cofs []CallOverrideFunc
+        if uf, ok := ctx.Value(&callOverrideKey).([]CallOverrideFunc); ok {
+                cofs = append(cofs, uf...)
+        }
+        cofs = append(cofs, f)
+        return netcontext.WithValue(ctx, &callOverrideKey, cofs)
+}
+
+func callOverrideFromContext(ctx netcontext.Context) (CallOverrideFunc, netcontext.Context, bool) {
+        cofs, _ := ctx.Value(&callOverrideKey).([]CallOverrideFunc)
+        if len(cofs) == 0 {
+                return nil, nil, false
+        }
+        // We found a list of overrides; grab the last, and reconstitute a
+        // context that will hide it.
+        f := cofs[len(cofs)-1]
+        ctx = netcontext.WithValue(ctx, &callOverrideKey, cofs[:len(cofs)-1])
+        return f, ctx, true
+}
+
+type logOverrideFunc func(level int64, format string, args ...interface{})
+
+var logOverrideKey = "holds a logOverrideFunc"
+
+func WithLogOverride(ctx netcontext.Context, f logOverrideFunc) netcontext.Context {
+        return netcontext.WithValue(ctx, &logOverrideKey, f)
+}
+
+var appIDOverrideKey = "holds a string, being the full app ID"
+
+func WithAppIDOverride(ctx netcontext.Context, appID string) netcontext.Context {
+        return netcontext.WithValue(ctx, &appIDOverrideKey, appID)
+}
+
+var namespaceKey = "holds the namespace string"
+
+func withNamespace(ctx netcontext.Context, ns string) netcontext.Context {
+        return netcontext.WithValue(ctx, &namespaceKey, ns)
+}
+
+func NamespaceFromContext(ctx netcontext.Context) string {
+        // If there's no namespace, return the empty string.
+        ns, _ := ctx.Value(&namespaceKey).(string)
+        return ns
+}
+
+// FullyQualifiedAppID returns the fully-qualified application ID.
+// This may contain a partition prefix (e.g. "s~" for High Replication apps),
+// or a domain prefix (e.g. "example.com:").
+func FullyQualifiedAppID(ctx netcontext.Context) string {
+        if id, ok := ctx.Value(&appIDOverrideKey).(string); ok {
+                return id
+        }
+        return fullyQualifiedAppID(ctx)
+}
+
+func Logf(ctx netcontext.Context, level int64, format string, args ...interface{}) {
+        if f, ok := ctx.Value(&logOverrideKey).(logOverrideFunc); ok {
+                f(level, format, args...)
+                return
+        }
+        c := fromContext(ctx)
+        if c == nil {
+                panic(errNotAppEngineContext)
+        }
+        logf(c, level, format, args...)
+}
+
+// NamespacedContext wraps a Context to support namespaces.
+func NamespacedContext(ctx netcontext.Context, namespace string) netcontext.Context {
+        return withNamespace(ctx, namespace)
+}
+
+// SetTestEnv sets the env variables for testing background ticket in Flex.
+func SetTestEnv() func() {
+        var environ = []struct {
+                key, value string
+        }{
+                {"GAE_LONG_APP_ID", "my-app-id"},
+                {"GAE_MINOR_VERSION", "067924799508853122"},
+                {"GAE_MODULE_INSTANCE", "0"},
+                {"GAE_MODULE_NAME", "default"},
+                {"GAE_MODULE_VERSION", "20150612t184001"},
+        }
+
+        for _, v := range environ {
+                old := os.Getenv(v.key)
+                os.Setenv(v.key, v.value)
+                v.value = old
+        }
+        return func() { // Restore old environment after the test completes.
+                for _, v := range environ {
+                        if v.value == "" {
+                                os.Unsetenv(v.key)
+                                continue
+                        }
+                        os.Setenv(v.key, v.value)
+                }
+        }
+}
diff --git a/vendor/google.golang.org/appengine/internal/app_id.go b/vendor/google.golang.org/appengine/internal/app_id.go
new file mode 100644
index 0000000..11df8c0
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/app_id.go
@@ -0,0 +1,28 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package internal
+
+import (
+        "strings"
+)
+
+func parseFullAppID(appid string) (partition, domain, displayID string) {
+        if i := strings.Index(appid, "~"); i != -1 {
+                partition, appid = appid[:i], appid[i+1:]
+        }
+        if i := strings.Index(appid, ":"); i != -1 {
+                domain, appid = appid[:i], appid[i+1:]
+        }
+        return partition, domain, appid
+}
+
+// appID returns "appid" or "domain.com:appid".
+func appID(fullAppID string) string {
+        _, dom, dis := parseFullAppID(fullAppID)
+        if dom != "" {
+                return dom + ":" + dis
+        }
+        return dis
+}
diff --git a/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.go b/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.go
new file mode 100644
index 0000000..9a2ff77
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.go
@@ -0,0 +1,611 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google.golang.org/appengine/internal/app_identity/app_identity_service.proto
+
+package app_identity
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type AppIdentityServiceError_ErrorCode int32
+
+const (
+        AppIdentityServiceError_SUCCESS           AppIdentityServiceError_ErrorCode = 0
+        AppIdentityServiceError_UNKNOWN_SCOPE     AppIdentityServiceError_ErrorCode = 9
+        AppIdentityServiceError_BLOB_TOO_LARGE    AppIdentityServiceError_ErrorCode = 1000
+        AppIdentityServiceError_DEADLINE_EXCEEDED AppIdentityServiceError_ErrorCode = 1001
+        AppIdentityServiceError_NOT_A_VALID_APP   AppIdentityServiceError_ErrorCode = 1002
+        AppIdentityServiceError_UNKNOWN_ERROR     AppIdentityServiceError_ErrorCode = 1003
+        AppIdentityServiceError_NOT_ALLOWED       AppIdentityServiceError_ErrorCode = 1005
+        AppIdentityServiceError_NOT_IMPLEMENTED   AppIdentityServiceError_ErrorCode = 1006
+)
+
+var AppIdentityServiceError_ErrorCode_name = map[int32]string{
+        0:    "SUCCESS",
+        9:    "UNKNOWN_SCOPE",
+        1000: "BLOB_TOO_LARGE",
+        1001: "DEADLINE_EXCEEDED",
+        1002: "NOT_A_VALID_APP",
+        1003: "UNKNOWN_ERROR",
+        1005: "NOT_ALLOWED",
+        1006: "NOT_IMPLEMENTED",
+}
+var AppIdentityServiceError_ErrorCode_value = map[string]int32{
+        "SUCCESS":           0,
+        "UNKNOWN_SCOPE":     9,
+        "BLOB_TOO_LARGE":    1000,
+        "DEADLINE_EXCEEDED": 1001,
+        "NOT_A_VALID_APP":   1002,
+        "UNKNOWN_ERROR":     1003,
+        "NOT_ALLOWED":       1005,
+        "NOT_IMPLEMENTED":   1006,
+}
+
+func (x AppIdentityServiceError_ErrorCode) Enum() *AppIdentityServiceError_ErrorCode {
+        p := new(AppIdentityServiceError_ErrorCode)
+        *p = x
+        return p
+}
+func (x AppIdentityServiceError_ErrorCode) String() string {
+        return proto.EnumName(AppIdentityServiceError_ErrorCode_name, int32(x))
+}
+func (x *AppIdentityServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(AppIdentityServiceError_ErrorCode_value, data, "AppIdentityServiceError_ErrorCode")
+        if err != nil {
+                return err
+        }
+        *x = AppIdentityServiceError_ErrorCode(value)
+        return nil
+}
+func (AppIdentityServiceError_ErrorCode) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{0, 0}
+}
+
+type AppIdentityServiceError struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *AppIdentityServiceError) Reset()         { *m = AppIdentityServiceError{} }
+func (m *AppIdentityServiceError) String() string { return proto.CompactTextString(m) }
+func (*AppIdentityServiceError) ProtoMessage()    {}
+func (*AppIdentityServiceError) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{0}
+}
+func (m *AppIdentityServiceError) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_AppIdentityServiceError.Unmarshal(m, b)
+}
+func (m *AppIdentityServiceError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_AppIdentityServiceError.Marshal(b, m, deterministic)
+}
+func (dst *AppIdentityServiceError) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_AppIdentityServiceError.Merge(dst, src)
+}
+func (m *AppIdentityServiceError) XXX_Size() int {
+        return xxx_messageInfo_AppIdentityServiceError.Size(m)
+}
+func (m *AppIdentityServiceError) XXX_DiscardUnknown() {
+        xxx_messageInfo_AppIdentityServiceError.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AppIdentityServiceError proto.InternalMessageInfo
+
+type SignForAppRequest struct {
+        BytesToSign          []byte   `protobuf:"bytes,1,opt,name=bytes_to_sign,json=bytesToSign" json:"bytes_to_sign,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SignForAppRequest) Reset()         { *m = SignForAppRequest{} }
+func (m *SignForAppRequest) String() string { return proto.CompactTextString(m) }
+func (*SignForAppRequest) ProtoMessage()    {}
+func (*SignForAppRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{1}
+}
+func (m *SignForAppRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_SignForAppRequest.Unmarshal(m, b)
+}
+func (m *SignForAppRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_SignForAppRequest.Marshal(b, m, deterministic)
+}
+func (dst *SignForAppRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_SignForAppRequest.Merge(dst, src)
+}
+func (m *SignForAppRequest) XXX_Size() int {
+        return xxx_messageInfo_SignForAppRequest.Size(m)
+}
+func (m *SignForAppRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_SignForAppRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SignForAppRequest proto.InternalMessageInfo
+
+func (m *SignForAppRequest) GetBytesToSign() []byte {
+        if m != nil {
+                return m.BytesToSign
+        }
+        return nil
+}
+
+type SignForAppResponse struct {
+        KeyName              *string  `protobuf:"bytes,1,opt,name=key_name,json=keyName" json:"key_name,omitempty"`
+        SignatureBytes       []byte   `protobuf:"bytes,2,opt,name=signature_bytes,json=signatureBytes" json:"signature_bytes,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SignForAppResponse) Reset()         { *m = SignForAppResponse{} }
+func (m *SignForAppResponse) String() string { return proto.CompactTextString(m) }
+func (*SignForAppResponse) ProtoMessage()    {}
+func (*SignForAppResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{2}
+}
+func (m *SignForAppResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_SignForAppResponse.Unmarshal(m, b)
+}
+func (m *SignForAppResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_SignForAppResponse.Marshal(b, m, deterministic)
+}
+func (dst *SignForAppResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_SignForAppResponse.Merge(dst, src)
+}
+func (m *SignForAppResponse) XXX_Size() int {
+        return xxx_messageInfo_SignForAppResponse.Size(m)
+}
+func (m *SignForAppResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_SignForAppResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SignForAppResponse proto.InternalMessageInfo
+
+func (m *SignForAppResponse) GetKeyName() string {
+        if m != nil && m.KeyName != nil {
+                return *m.KeyName
+        }
+        return ""
+}
+
+func (m *SignForAppResponse) GetSignatureBytes() []byte {
+        if m != nil {
+                return m.SignatureBytes
+        }
+        return nil
+}
+
+type GetPublicCertificateForAppRequest struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetPublicCertificateForAppRequest) Reset()         { *m = GetPublicCertificateForAppRequest{} }
+func (m *GetPublicCertificateForAppRequest) String() string { return proto.CompactTextString(m) }
+func (*GetPublicCertificateForAppRequest) ProtoMessage()    {}
+func (*GetPublicCertificateForAppRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{3}
+}
+func (m *GetPublicCertificateForAppRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetPublicCertificateForAppRequest.Unmarshal(m, b)
+}
+func (m *GetPublicCertificateForAppRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetPublicCertificateForAppRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetPublicCertificateForAppRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetPublicCertificateForAppRequest.Merge(dst, src)
+}
+func (m *GetPublicCertificateForAppRequest) XXX_Size() int {
+        return xxx_messageInfo_GetPublicCertificateForAppRequest.Size(m)
+}
+func (m *GetPublicCertificateForAppRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetPublicCertificateForAppRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetPublicCertificateForAppRequest proto.InternalMessageInfo
+
+type PublicCertificate struct {
+        KeyName              *string  `protobuf:"bytes,1,opt,name=key_name,json=keyName" json:"key_name,omitempty"`
+        X509CertificatePem   *string  `protobuf:"bytes,2,opt,name=x509_certificate_pem,json=x509CertificatePem" json:"x509_certificate_pem,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PublicCertificate) Reset()         { *m = PublicCertificate{} }
+func (m *PublicCertificate) String() string { return proto.CompactTextString(m) }
+func (*PublicCertificate) ProtoMessage()    {}
+func (*PublicCertificate) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{4}
+}
+func (m *PublicCertificate) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_PublicCertificate.Unmarshal(m, b)
+}
+func (m *PublicCertificate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_PublicCertificate.Marshal(b, m, deterministic)
+}
+func (dst *PublicCertificate) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_PublicCertificate.Merge(dst, src)
+}
+func (m *PublicCertificate) XXX_Size() int {
+        return xxx_messageInfo_PublicCertificate.Size(m)
+}
+func (m *PublicCertificate) XXX_DiscardUnknown() {
+        xxx_messageInfo_PublicCertificate.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PublicCertificate proto.InternalMessageInfo
+
+func (m *PublicCertificate) GetKeyName() string {
+        if m != nil && m.KeyName != nil {
+                return *m.KeyName
+        }
+        return ""
+}
+
+func (m *PublicCertificate) GetX509CertificatePem() string {
+        if m != nil && m.X509CertificatePem != nil {
+                return *m.X509CertificatePem
+        }
+        return ""
+}
+
+type GetPublicCertificateForAppResponse struct {
+        PublicCertificateList      []*PublicCertificate `protobuf:"bytes,1,rep,name=public_certificate_list,json=publicCertificateList" json:"public_certificate_list,omitempty"`
+        MaxClientCacheTimeInSecond *int64               `protobuf:"varint,2,opt,name=max_client_cache_time_in_second,json=maxClientCacheTimeInSecond" json:"max_client_cache_time_in_second,omitempty"`
+        XXX_NoUnkeyedLiteral       struct{}             `json:"-"`
+        XXX_unrecognized           []byte               `json:"-"`
+        XXX_sizecache              int32                `json:"-"`
+}
+
+func (m *GetPublicCertificateForAppResponse) Reset()         { *m = GetPublicCertificateForAppResponse{} }
+func (m *GetPublicCertificateForAppResponse) String() string { return proto.CompactTextString(m) }
+func (*GetPublicCertificateForAppResponse) ProtoMessage()    {}
+func (*GetPublicCertificateForAppResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{5}
+}
+func (m *GetPublicCertificateForAppResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetPublicCertificateForAppResponse.Unmarshal(m, b)
+}
+func (m *GetPublicCertificateForAppResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetPublicCertificateForAppResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetPublicCertificateForAppResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetPublicCertificateForAppResponse.Merge(dst, src)
+}
+func (m *GetPublicCertificateForAppResponse) XXX_Size() int {
+        return xxx_messageInfo_GetPublicCertificateForAppResponse.Size(m)
+}
+func (m *GetPublicCertificateForAppResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetPublicCertificateForAppResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetPublicCertificateForAppResponse proto.InternalMessageInfo
+
+func (m *GetPublicCertificateForAppResponse) GetPublicCertificateList() []*PublicCertificate {
+        if m != nil {
+                return m.PublicCertificateList
+        }
+        return nil
+}
+
+func (m *GetPublicCertificateForAppResponse) GetMaxClientCacheTimeInSecond() int64 {
+        if m != nil && m.MaxClientCacheTimeInSecond != nil {
+                return *m.MaxClientCacheTimeInSecond
+        }
+        return 0
+}
+
+type GetServiceAccountNameRequest struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetServiceAccountNameRequest) Reset()         { *m = GetServiceAccountNameRequest{} }
+func (m *GetServiceAccountNameRequest) String() string { return proto.CompactTextString(m) }
+func (*GetServiceAccountNameRequest) ProtoMessage()    {}
+func (*GetServiceAccountNameRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{6}
+}
+func (m *GetServiceAccountNameRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetServiceAccountNameRequest.Unmarshal(m, b)
+}
+func (m *GetServiceAccountNameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetServiceAccountNameRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetServiceAccountNameRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetServiceAccountNameRequest.Merge(dst, src)
+}
+func (m *GetServiceAccountNameRequest) XXX_Size() int {
+        return xxx_messageInfo_GetServiceAccountNameRequest.Size(m)
+}
+func (m *GetServiceAccountNameRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetServiceAccountNameRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetServiceAccountNameRequest proto.InternalMessageInfo
+
+type GetServiceAccountNameResponse struct {
+        ServiceAccountName   *string  `protobuf:"bytes,1,opt,name=service_account_name,json=serviceAccountName" json:"service_account_name,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetServiceAccountNameResponse) Reset()         { *m = GetServiceAccountNameResponse{} }
+func (m *GetServiceAccountNameResponse) String() string { return proto.CompactTextString(m) }
+func (*GetServiceAccountNameResponse) ProtoMessage()    {}
+func (*GetServiceAccountNameResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{7}
+}
+func (m *GetServiceAccountNameResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetServiceAccountNameResponse.Unmarshal(m, b)
+}
+func (m *GetServiceAccountNameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetServiceAccountNameResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetServiceAccountNameResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetServiceAccountNameResponse.Merge(dst, src)
+}
+func (m *GetServiceAccountNameResponse) XXX_Size() int {
+        return xxx_messageInfo_GetServiceAccountNameResponse.Size(m)
+}
+func (m *GetServiceAccountNameResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetServiceAccountNameResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetServiceAccountNameResponse proto.InternalMessageInfo
+
+func (m *GetServiceAccountNameResponse) GetServiceAccountName() string {
+        if m != nil && m.ServiceAccountName != nil {
+                return *m.ServiceAccountName
+        }
+        return ""
+}
+
+type GetAccessTokenRequest struct {
+        Scope                []string `protobuf:"bytes,1,rep,name=scope" json:"scope,omitempty"`
+        ServiceAccountId     *int64   `protobuf:"varint,2,opt,name=service_account_id,json=serviceAccountId" json:"service_account_id,omitempty"`
+        ServiceAccountName   *string  `protobuf:"bytes,3,opt,name=service_account_name,json=serviceAccountName" json:"service_account_name,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetAccessTokenRequest) Reset()         { *m = GetAccessTokenRequest{} }
+func (m *GetAccessTokenRequest) String() string { return proto.CompactTextString(m) }
+func (*GetAccessTokenRequest) ProtoMessage()    {}
+func (*GetAccessTokenRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{8}
+}
+func (m *GetAccessTokenRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetAccessTokenRequest.Unmarshal(m, b)
+}
+func (m *GetAccessTokenRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetAccessTokenRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetAccessTokenRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetAccessTokenRequest.Merge(dst, src)
+}
+func (m *GetAccessTokenRequest) XXX_Size() int {
+        return xxx_messageInfo_GetAccessTokenRequest.Size(m)
+}
+func (m *GetAccessTokenRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetAccessTokenRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetAccessTokenRequest proto.InternalMessageInfo
+
+func (m *GetAccessTokenRequest) GetScope() []string {
+        if m != nil {
+                return m.Scope
+        }
+        return nil
+}
+
+func (m *GetAccessTokenRequest) GetServiceAccountId() int64 {
+        if m != nil && m.ServiceAccountId != nil {
+                return *m.ServiceAccountId
+        }
+        return 0
+}
+
+func (m *GetAccessTokenRequest) GetServiceAccountName() string {
+        if m != nil && m.ServiceAccountName != nil {
+                return *m.ServiceAccountName
+        }
+        return ""
+}
+
+type GetAccessTokenResponse struct {
+        AccessToken          *string  `protobuf:"bytes,1,opt,name=access_token,json=accessToken" json:"access_token,omitempty"`
+        ExpirationTime       *int64   `protobuf:"varint,2,opt,name=expiration_time,json=expirationTime" json:"expiration_time,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetAccessTokenResponse) Reset()         { *m = GetAccessTokenResponse{} }
+func (m *GetAccessTokenResponse) String() string { return proto.CompactTextString(m) }
+func (*GetAccessTokenResponse) ProtoMessage()    {}
+func (*GetAccessTokenResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{9}
+}
+func (m *GetAccessTokenResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetAccessTokenResponse.Unmarshal(m, b)
+}
+func (m *GetAccessTokenResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetAccessTokenResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetAccessTokenResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetAccessTokenResponse.Merge(dst, src)
+}
+func (m *GetAccessTokenResponse) XXX_Size() int {
+        return xxx_messageInfo_GetAccessTokenResponse.Size(m)
+}
+func (m *GetAccessTokenResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetAccessTokenResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetAccessTokenResponse proto.InternalMessageInfo
+
+func (m *GetAccessTokenResponse) GetAccessToken() string {
+        if m != nil && m.AccessToken != nil {
+                return *m.AccessToken
+        }
+        return ""
+}
+
+func (m *GetAccessTokenResponse) GetExpirationTime() int64 {
+        if m != nil && m.ExpirationTime != nil {
+                return *m.ExpirationTime
+        }
+        return 0
+}
+
+type GetDefaultGcsBucketNameRequest struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetDefaultGcsBucketNameRequest) Reset()         { *m = GetDefaultGcsBucketNameRequest{} }
+func (m *GetDefaultGcsBucketNameRequest) String() string { return proto.CompactTextString(m) }
+func (*GetDefaultGcsBucketNameRequest) ProtoMessage()    {}
+func (*GetDefaultGcsBucketNameRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{10}
+}
+func (m *GetDefaultGcsBucketNameRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetDefaultGcsBucketNameRequest.Unmarshal(m, b)
+}
+func (m *GetDefaultGcsBucketNameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetDefaultGcsBucketNameRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetDefaultGcsBucketNameRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetDefaultGcsBucketNameRequest.Merge(dst, src)
+}
+func (m *GetDefaultGcsBucketNameRequest) XXX_Size() int {
+        return xxx_messageInfo_GetDefaultGcsBucketNameRequest.Size(m)
+}
+func (m *GetDefaultGcsBucketNameRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetDefaultGcsBucketNameRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetDefaultGcsBucketNameRequest proto.InternalMessageInfo
+
+type GetDefaultGcsBucketNameResponse struct {
+        DefaultGcsBucketName *string  `protobuf:"bytes,1,opt,name=default_gcs_bucket_name,json=defaultGcsBucketName" json:"default_gcs_bucket_name,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetDefaultGcsBucketNameResponse) Reset()         { *m = GetDefaultGcsBucketNameResponse{} }
+func (m *GetDefaultGcsBucketNameResponse) String() string { return proto.CompactTextString(m) }
+func (*GetDefaultGcsBucketNameResponse) ProtoMessage()    {}
+func (*GetDefaultGcsBucketNameResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{11}
+}
+func (m *GetDefaultGcsBucketNameResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetDefaultGcsBucketNameResponse.Unmarshal(m, b)
+}
+func (m *GetDefaultGcsBucketNameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetDefaultGcsBucketNameResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetDefaultGcsBucketNameResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetDefaultGcsBucketNameResponse.Merge(dst, src)
+}
+func (m *GetDefaultGcsBucketNameResponse) XXX_Size() int {
+        return xxx_messageInfo_GetDefaultGcsBucketNameResponse.Size(m)
+}
+func (m *GetDefaultGcsBucketNameResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetDefaultGcsBucketNameResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetDefaultGcsBucketNameResponse proto.InternalMessageInfo
+
+func (m *GetDefaultGcsBucketNameResponse) GetDefaultGcsBucketName() string {
+        if m != nil && m.DefaultGcsBucketName != nil {
+                return *m.DefaultGcsBucketName
+        }
+        return ""
+}
+
+func init() {
+        proto.RegisterType((*AppIdentityServiceError)(nil), "appengine.AppIdentityServiceError")
+        proto.RegisterType((*SignForAppRequest)(nil), "appengine.SignForAppRequest")
+        proto.RegisterType((*SignForAppResponse)(nil), "appengine.SignForAppResponse")
+        proto.RegisterType((*GetPublicCertificateForAppRequest)(nil), "appengine.GetPublicCertificateForAppRequest")
+        proto.RegisterType((*PublicCertificate)(nil), "appengine.PublicCertificate")
+        proto.RegisterType((*GetPublicCertificateForAppResponse)(nil), "appengine.GetPublicCertificateForAppResponse")
+        proto.RegisterType((*GetServiceAccountNameRequest)(nil), "appengine.GetServiceAccountNameRequest")
+        proto.RegisterType((*GetServiceAccountNameResponse)(nil), "appengine.GetServiceAccountNameResponse")
+        proto.RegisterType((*GetAccessTokenRequest)(nil), "appengine.GetAccessTokenRequest")
+        proto.RegisterType((*GetAccessTokenResponse)(nil), "appengine.GetAccessTokenResponse")
+        proto.RegisterType((*GetDefaultGcsBucketNameRequest)(nil), "appengine.GetDefaultGcsBucketNameRequest")
+        proto.RegisterType((*GetDefaultGcsBucketNameResponse)(nil), "appengine.GetDefaultGcsBucketNameResponse")
+}
+
+func init() {
+        proto.RegisterFile("google.golang.org/appengine/internal/app_identity/app_identity_service.proto", fileDescriptor_app_identity_service_08a6e3f74b04cfa4)
+}
+
+var fileDescriptor_app_identity_service_08a6e3f74b04cfa4 = []byte{
+        // 676 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x54, 0xdb, 0x6e, 0xda, 0x58,
+        0x14, 0x1d, 0x26, 0x1a, 0x31, 0x6c, 0x12, 0x62, 0xce, 0x90, 0xcb, 0x8c, 0x32, 0xb9, 0x78, 0x1e,
+        0x26, 0x0f, 0x15, 0x89, 0x2a, 0x45, 0x55, 0x1f, 0x8d, 0xed, 0x22, 0x54, 0x07, 0x53, 0x43, 0x9a,
+        0xa8, 0x2f, 0xa7, 0xce, 0x61, 0xc7, 0x3d, 0x02, 0x9f, 0xe3, 0xda, 0x87, 0x0a, 0x3e, 0xa2, 0x3f,
+        0xd2, 0x9f, 0xe8, 0x5b, 0xbf, 0xa5, 0x17, 0xb5, 0xdf, 0x50, 0xd9, 0x38, 0x5c, 0x92, 0x92, 0x37,
+        0xbc, 0xf6, 0x5a, 0xcb, 0x6b, 0x2f, 0x6d, 0x0c, 0x4e, 0x20, 0x65, 0x30, 0xc4, 0x7a, 0x20, 0x87,
+        0xbe, 0x08, 0xea, 0x32, 0x0e, 0x4e, 0xfc, 0x28, 0x42, 0x11, 0x70, 0x81, 0x27, 0x5c, 0x28, 0x8c,
+        0x85, 0x3f, 0x4c, 0x21, 0xca, 0xfb, 0x28, 0x14, 0x57, 0x93, 0xa5, 0x07, 0x9a, 0x60, 0xfc, 0x8e,
+        0x33, 0xac, 0x47, 0xb1, 0x54, 0x92, 0x94, 0x66, 0x5a, 0xfd, 0x53, 0x01, 0x76, 0x8c, 0x28, 0x6a,
+        0xe5, 0xc4, 0xee, 0x94, 0x67, 0xc7, 0xb1, 0x8c, 0xf5, 0x0f, 0x05, 0x28, 0x65, 0xbf, 0x4c, 0xd9,
+        0x47, 0x52, 0x86, 0x62, 0xf7, 0xc2, 0x34, 0xed, 0x6e, 0x57, 0xfb, 0x8d, 0x54, 0x61, 0xe3, 0xa2,
+        0xfd, 0xbc, 0xed, 0x5e, 0xb6, 0x69, 0xd7, 0x74, 0x3b, 0xb6, 0x56, 0x22, 0x7f, 0x41, 0xa5, 0xe1,
+        0xb8, 0x0d, 0xda, 0x73, 0x5d, 0xea, 0x18, 0x5e, 0xd3, 0xd6, 0x3e, 0x17, 0xc9, 0x36, 0x54, 0x2d,
+        0xdb, 0xb0, 0x9c, 0x56, 0xdb, 0xa6, 0xf6, 0x95, 0x69, 0xdb, 0x96, 0x6d, 0x69, 0x5f, 0x8a, 0xa4,
+        0x06, 0x9b, 0x6d, 0xb7, 0x47, 0x0d, 0xfa, 0xd2, 0x70, 0x5a, 0x16, 0x35, 0x3a, 0x1d, 0xed, 0x6b,
+        0x91, 0x90, 0xb9, 0xab, 0xed, 0x79, 0xae, 0xa7, 0x7d, 0x2b, 0x12, 0x0d, 0xca, 0x19, 0xd3, 0x71,
+        0xdc, 0x4b, 0xdb, 0xd2, 0xbe, 0xcf, 0xb4, 0xad, 0xf3, 0x8e, 0x63, 0x9f, 0xdb, 0xed, 0x9e, 0x6d,
+        0x69, 0x3f, 0x8a, 0xfa, 0x13, 0xa8, 0x76, 0x79, 0x20, 0x9e, 0xc9, 0xd8, 0x88, 0x22, 0x0f, 0xdf,
+        0x8e, 0x30, 0x51, 0x44, 0x87, 0x8d, 0xeb, 0x89, 0xc2, 0x84, 0x2a, 0x49, 0x13, 0x1e, 0x88, 0xdd,
+        0xc2, 0x61, 0xe1, 0x78, 0xdd, 0x2b, 0x67, 0x60, 0x4f, 0xa6, 0x02, 0xfd, 0x0a, 0xc8, 0xa2, 0x30,
+        0x89, 0xa4, 0x48, 0x90, 0xfc, 0x0d, 0x7f, 0x0e, 0x70, 0x42, 0x85, 0x1f, 0x62, 0x26, 0x2a, 0x79,
+        0xc5, 0x01, 0x4e, 0xda, 0x7e, 0x88, 0xe4, 0x7f, 0xd8, 0x4c, 0xbd, 0x7c, 0x35, 0x8a, 0x91, 0x66,
+        0x4e, 0xbb, 0xbf, 0x67, 0xb6, 0x95, 0x19, 0xdc, 0x48, 0x51, 0xfd, 0x3f, 0x38, 0x6a, 0xa2, 0xea,
+        0x8c, 0xae, 0x87, 0x9c, 0x99, 0x18, 0x2b, 0x7e, 0xc3, 0x99, 0xaf, 0x70, 0x29, 0xa2, 0xfe, 0x1a,
+        0xaa, 0xf7, 0x18, 0x0f, 0xbd, 0xfd, 0x14, 0x6a, 0xe3, 0xb3, 0xd3, 0xa7, 0x94, 0xcd, 0xe9, 0x34,
+        0xc2, 0x30, 0x8b, 0x50, 0xf2, 0x48, 0x3a, 0x5b, 0x70, 0xea, 0x60, 0xa8, 0x7f, 0x2c, 0x80, 0xfe,
+        0x50, 0x8e, 0x7c, 0xe3, 0x1e, 0xec, 0x44, 0x19, 0x65, 0xc9, 0x7a, 0xc8, 0x13, 0xb5, 0x5b, 0x38,
+        0x5c, 0x3b, 0x2e, 0x3f, 0xde, 0xab, 0xcf, 0xce, 0xa6, 0x7e, 0xcf, 0xcc, 0xdb, 0x8a, 0xee, 0x42,
+        0x0e, 0x4f, 0x14, 0x31, 0xe1, 0x20, 0xf4, 0xc7, 0x94, 0x0d, 0x39, 0x0a, 0x45, 0x99, 0xcf, 0xde,
+        0x20, 0x55, 0x3c, 0x44, 0xca, 0x05, 0x4d, 0x90, 0x49, 0xd1, 0xcf, 0x92, 0xaf, 0x79, 0xff, 0x84,
+        0xfe, 0xd8, 0xcc, 0x58, 0x66, 0x4a, 0xea, 0xf1, 0x10, 0x5b, 0xa2, 0x9b, 0x31, 0xf4, 0x7d, 0xd8,
+        0x6b, 0xa2, 0xca, 0x6f, 0xd3, 0x60, 0x4c, 0x8e, 0x84, 0x4a, 0xcb, 0xb8, 0xed, 0xf0, 0x05, 0xfc,
+        0xbb, 0x62, 0x9e, 0xef, 0x76, 0x0a, 0xb5, 0xfc, 0x1f, 0x40, 0xfd, 0xe9, 0x78, 0xb1, 0x5b, 0x92,
+        0xdc, 0x53, 0xea, 0xef, 0x0b, 0xb0, 0xd5, 0x44, 0x65, 0x30, 0x86, 0x49, 0xd2, 0x93, 0x03, 0x14,
+        0xb7, 0x37, 0x55, 0x83, 0x3f, 0x12, 0x26, 0x23, 0xcc, 0x5a, 0x29, 0x79, 0xd3, 0x07, 0xf2, 0x08,
+        0xc8, 0xdd, 0x37, 0xf0, 0xdb, 0xd5, 0xb4, 0x65, 0xff, 0x56, 0x7f, 0x65, 0x9e, 0xb5, 0x95, 0x79,
+        0xfa, 0xb0, 0x7d, 0x37, 0x4e, 0xbe, 0xdb, 0x11, 0xac, 0xfb, 0x19, 0x4c, 0x55, 0x8a, 0xe7, 0x3b,
+        0x95, 0xfd, 0x39, 0x35, 0xbd, 0x58, 0x1c, 0x47, 0x3c, 0xf6, 0x15, 0x97, 0x22, 0xab, 0x3f, 0x4f,
+        0x56, 0x99, 0xc3, 0x69, 0xe1, 0xfa, 0x21, 0xec, 0x37, 0x51, 0x59, 0x78, 0xe3, 0x8f, 0x86, 0xaa,
+        0xc9, 0x92, 0xc6, 0x88, 0x0d, 0x70, 0xa9, 0xea, 0x2b, 0x38, 0x58, 0xc9, 0xc8, 0x03, 0x9d, 0xc1,
+        0x4e, 0x7f, 0x3a, 0xa7, 0x01, 0x4b, 0xe8, 0x75, 0xc6, 0x58, 0xec, 0xbb, 0xd6, 0xff, 0x85, 0xbc,
+        0x51, 0x79, 0xb5, 0xbe, 0xf8, 0xc9, 0xfa, 0x19, 0x00, 0x00, 0xff, 0xff, 0x37, 0x4c, 0x56, 0x38,
+        0xf3, 0x04, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.proto b/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.proto
new file mode 100644
index 0000000..19610ca
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.proto
@@ -0,0 +1,64 @@
+syntax = "proto2";
+option go_package = "app_identity";
+
+package appengine;
+
+message AppIdentityServiceError {
+  enum ErrorCode {
+    SUCCESS = 0;
+    UNKNOWN_SCOPE = 9;
+    BLOB_TOO_LARGE = 1000;
+    DEADLINE_EXCEEDED = 1001;
+    NOT_A_VALID_APP = 1002;
+    UNKNOWN_ERROR = 1003;
+    NOT_ALLOWED = 1005;
+    NOT_IMPLEMENTED = 1006;
+  }
+}
+
+message SignForAppRequest {
+  optional bytes bytes_to_sign = 1;
+}
+
+message SignForAppResponse {
+  optional string key_name = 1;
+  optional bytes signature_bytes = 2;
+}
+
+message GetPublicCertificateForAppRequest {
+}
+
+message PublicCertificate {
+  optional string key_name = 1;
+  optional string x509_certificate_pem = 2;
+}
+
+message GetPublicCertificateForAppResponse {
+  repeated PublicCertificate public_certificate_list = 1;
+  optional int64 max_client_cache_time_in_second = 2;
+}
+
+message GetServiceAccountNameRequest {
+}
+
+message GetServiceAccountNameResponse {
+  optional string service_account_name = 1;
+}
+
+message GetAccessTokenRequest {
+  repeated string scope = 1;
+  optional int64 service_account_id = 2;
+  optional string service_account_name = 3;
+}
+
+message GetAccessTokenResponse {
+  optional string access_token = 1;
+  optional int64 expiration_time = 2;
+}
+
+message GetDefaultGcsBucketNameRequest {
+}
+
+message GetDefaultGcsBucketNameResponse {
+  optional string default_gcs_bucket_name = 1;
+}
diff --git a/vendor/google.golang.org/appengine/internal/base/api_base.pb.go b/vendor/google.golang.org/appengine/internal/base/api_base.pb.go
new file mode 100644
index 0000000..db4777e
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/base/api_base.pb.go
@@ -0,0 +1,308 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google.golang.org/appengine/internal/base/api_base.proto
+
+package base
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type StringProto struct {
+        Value                *string  `protobuf:"bytes,1,req,name=value" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *StringProto) Reset()         { *m = StringProto{} }
+func (m *StringProto) String() string { return proto.CompactTextString(m) }
+func (*StringProto) ProtoMessage()    {}
+func (*StringProto) Descriptor() ([]byte, []int) {
+        return fileDescriptor_api_base_9d49f8792e0c1140, []int{0}
+}
+func (m *StringProto) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_StringProto.Unmarshal(m, b)
+}
+func (m *StringProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_StringProto.Marshal(b, m, deterministic)
+}
+func (dst *StringProto) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_StringProto.Merge(dst, src)
+}
+func (m *StringProto) XXX_Size() int {
+        return xxx_messageInfo_StringProto.Size(m)
+}
+func (m *StringProto) XXX_DiscardUnknown() {
+        xxx_messageInfo_StringProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StringProto proto.InternalMessageInfo
+
+func (m *StringProto) GetValue() string {
+        if m != nil && m.Value != nil {
+                return *m.Value
+        }
+        return ""
+}
+
+type Integer32Proto struct {
+        Value                *int32   `protobuf:"varint,1,req,name=value" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Integer32Proto) Reset()         { *m = Integer32Proto{} }
+func (m *Integer32Proto) String() string { return proto.CompactTextString(m) }
+func (*Integer32Proto) ProtoMessage()    {}
+func (*Integer32Proto) Descriptor() ([]byte, []int) {
+        return fileDescriptor_api_base_9d49f8792e0c1140, []int{1}
+}
+func (m *Integer32Proto) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Integer32Proto.Unmarshal(m, b)
+}
+func (m *Integer32Proto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Integer32Proto.Marshal(b, m, deterministic)
+}
+func (dst *Integer32Proto) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Integer32Proto.Merge(dst, src)
+}
+func (m *Integer32Proto) XXX_Size() int {
+        return xxx_messageInfo_Integer32Proto.Size(m)
+}
+func (m *Integer32Proto) XXX_DiscardUnknown() {
+        xxx_messageInfo_Integer32Proto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Integer32Proto proto.InternalMessageInfo
+
+func (m *Integer32Proto) GetValue() int32 {
+        if m != nil && m.Value != nil {
+                return *m.Value
+        }
+        return 0
+}
+
+type Integer64Proto struct {
+        Value                *int64   `protobuf:"varint,1,req,name=value" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Integer64Proto) Reset()         { *m = Integer64Proto{} }
+func (m *Integer64Proto) String() string { return proto.CompactTextString(m) }
+func (*Integer64Proto) ProtoMessage()    {}
+func (*Integer64Proto) Descriptor() ([]byte, []int) {
+        return fileDescriptor_api_base_9d49f8792e0c1140, []int{2}
+}
+func (m *Integer64Proto) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Integer64Proto.Unmarshal(m, b)
+}
+func (m *Integer64Proto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Integer64Proto.Marshal(b, m, deterministic)
+}
+func (dst *Integer64Proto) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Integer64Proto.Merge(dst, src)
+}
+func (m *Integer64Proto) XXX_Size() int {
+        return xxx_messageInfo_Integer64Proto.Size(m)
+}
+func (m *Integer64Proto) XXX_DiscardUnknown() {
+        xxx_messageInfo_Integer64Proto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Integer64Proto proto.InternalMessageInfo
+
+func (m *Integer64Proto) GetValue() int64 {
+        if m != nil && m.Value != nil {
+                return *m.Value
+        }
+        return 0
+}
+
+type BoolProto struct {
+        Value                *bool    `protobuf:"varint,1,req,name=value" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *BoolProto) Reset()         { *m = BoolProto{} }
+func (m *BoolProto) String() string { return proto.CompactTextString(m) }
+func (*BoolProto) ProtoMessage()    {}
+func (*BoolProto) Descriptor() ([]byte, []int) {
+        return fileDescriptor_api_base_9d49f8792e0c1140, []int{3}
+}
+func (m *BoolProto) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_BoolProto.Unmarshal(m, b)
+}
+func (m *BoolProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_BoolProto.Marshal(b, m, deterministic)
+}
+func (dst *BoolProto) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_BoolProto.Merge(dst, src)
+}
+func (m *BoolProto) XXX_Size() int {
+        return xxx_messageInfo_BoolProto.Size(m)
+}
+func (m *BoolProto) XXX_DiscardUnknown() {
+        xxx_messageInfo_BoolProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BoolProto proto.InternalMessageInfo
+
+func (m *BoolProto) GetValue() bool {
+        if m != nil && m.Value != nil {
+                return *m.Value
+        }
+        return false
+}
+
+type DoubleProto struct {
+        Value                *float64 `protobuf:"fixed64,1,req,name=value" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *DoubleProto) Reset()         { *m = DoubleProto{} }
+func (m *DoubleProto) String() string { return proto.CompactTextString(m) }
+func (*DoubleProto) ProtoMessage()    {}
+func (*DoubleProto) Descriptor() ([]byte, []int) {
+        return fileDescriptor_api_base_9d49f8792e0c1140, []int{4}
+}
+func (m *DoubleProto) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_DoubleProto.Unmarshal(m, b)
+}
+func (m *DoubleProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_DoubleProto.Marshal(b, m, deterministic)
+}
+func (dst *DoubleProto) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_DoubleProto.Merge(dst, src)
+}
+func (m *DoubleProto) XXX_Size() int {
+        return xxx_messageInfo_DoubleProto.Size(m)
+}
+func (m *DoubleProto) XXX_DiscardUnknown() {
+        xxx_messageInfo_DoubleProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DoubleProto proto.InternalMessageInfo
+
+func (m *DoubleProto) GetValue() float64 {
+        if m != nil && m.Value != nil {
+                return *m.Value
+        }
+        return 0
+}
+
+type BytesProto struct {
+        Value                []byte   `protobuf:"bytes,1,req,name=value" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *BytesProto) Reset()         { *m = BytesProto{} }
+func (m *BytesProto) String() string { return proto.CompactTextString(m) }
+func (*BytesProto) ProtoMessage()    {}
+func (*BytesProto) Descriptor() ([]byte, []int) {
+        return fileDescriptor_api_base_9d49f8792e0c1140, []int{5}
+}
+func (m *BytesProto) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_BytesProto.Unmarshal(m, b)
+}
+func (m *BytesProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_BytesProto.Marshal(b, m, deterministic)
+}
+func (dst *BytesProto) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_BytesProto.Merge(dst, src)
+}
+func (m *BytesProto) XXX_Size() int {
+        return xxx_messageInfo_BytesProto.Size(m)
+}
+func (m *BytesProto) XXX_DiscardUnknown() {
+        xxx_messageInfo_BytesProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BytesProto proto.InternalMessageInfo
+
+func (m *BytesProto) GetValue() []byte {
+        if m != nil {
+                return m.Value
+        }
+        return nil
+}
+
+type VoidProto struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *VoidProto) Reset()         { *m = VoidProto{} }
+func (m *VoidProto) String() string { return proto.CompactTextString(m) }
+func (*VoidProto) ProtoMessage()    {}
+func (*VoidProto) Descriptor() ([]byte, []int) {
+        return fileDescriptor_api_base_9d49f8792e0c1140, []int{6}
+}
+func (m *VoidProto) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_VoidProto.Unmarshal(m, b)
+}
+func (m *VoidProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_VoidProto.Marshal(b, m, deterministic)
+}
+func (dst *VoidProto) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_VoidProto.Merge(dst, src)
+}
+func (m *VoidProto) XXX_Size() int {
+        return xxx_messageInfo_VoidProto.Size(m)
+}
+func (m *VoidProto) XXX_DiscardUnknown() {
+        xxx_messageInfo_VoidProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VoidProto proto.InternalMessageInfo
+
+func init() {
+        proto.RegisterType((*StringProto)(nil), "appengine.base.StringProto")
+        proto.RegisterType((*Integer32Proto)(nil), "appengine.base.Integer32Proto")
+        proto.RegisterType((*Integer64Proto)(nil), "appengine.base.Integer64Proto")
+        proto.RegisterType((*BoolProto)(nil), "appengine.base.BoolProto")
+        proto.RegisterType((*DoubleProto)(nil), "appengine.base.DoubleProto")
+        proto.RegisterType((*BytesProto)(nil), "appengine.base.BytesProto")
+        proto.RegisterType((*VoidProto)(nil), "appengine.base.VoidProto")
+}
+
+func init() {
+        proto.RegisterFile("google.golang.org/appengine/internal/base/api_base.proto", fileDescriptor_api_base_9d49f8792e0c1140)
+}
+
+var fileDescriptor_api_base_9d49f8792e0c1140 = []byte{
+        // 199 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0xcf, 0x3f, 0x4b, 0xc6, 0x30,
+        0x10, 0x06, 0x70, 0x5a, 0xad, 0xb4, 0x57, 0xe9, 0x20, 0x0e, 0x1d, 0xb5, 0x05, 0x71, 0x4a, 0x40,
+        0x45, 0x9c, 0x83, 0x8b, 0x9b, 0x28, 0x38, 0xb8, 0x48, 0x8a, 0xc7, 0x11, 0x08, 0xb9, 0x90, 0xa6,
+        0x82, 0xdf, 0x5e, 0xda, 0xd2, 0xfa, 0xc2, 0x9b, 0xed, 0xfe, 0xfc, 0xe0, 0xe1, 0x81, 0x27, 0x62,
+        0x26, 0x8b, 0x82, 0xd8, 0x6a, 0x47, 0x82, 0x03, 0x49, 0xed, 0x3d, 0x3a, 0x32, 0x0e, 0xa5, 0x71,
+        0x11, 0x83, 0xd3, 0x56, 0x0e, 0x7a, 0x44, 0xa9, 0xbd, 0xf9, 0x9a, 0x07, 0xe1, 0x03, 0x47, 0xbe,
+        0x68, 0x76, 0x27, 0xe6, 0x6b, 0xd7, 0x43, 0xfd, 0x1e, 0x83, 0x71, 0xf4, 0xba, 0xbc, 0x2f, 0xa1,
+        0xf8, 0xd1, 0x76, 0xc2, 0x36, 0xbb, 0xca, 0x6f, 0xab, 0xb7, 0x75, 0xe9, 0x6e, 0xa0, 0x79, 0x71,
+        0x11, 0x09, 0xc3, 0xfd, 0x5d, 0xc2, 0x15, 0xc7, 0xee, 0xf1, 0x21, 0xe1, 0x4e, 0x36, 0x77, 0x0d,
+        0x95, 0x62, 0xb6, 0x09, 0x52, 0x6e, 0xa4, 0x87, 0xfa, 0x99, 0xa7, 0xc1, 0x62, 0x02, 0x65, 0xff,
+        0x79, 0xa0, 0x7e, 0x23, 0x8e, 0xab, 0x69, 0x0f, 0xcd, 0xb9, 0xca, 0xcb, 0xdd, 0xd5, 0x50, 0x7d,
+        0xb0, 0xf9, 0x5e, 0x98, 0x3a, 0xfb, 0x3c, 0x9d, 0x9b, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xba,
+        0x37, 0x25, 0xea, 0x44, 0x01, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/appengine/internal/base/api_base.proto b/vendor/google.golang.org/appengine/internal/base/api_base.proto
new file mode 100644
index 0000000..56cd7a3
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/base/api_base.proto
@@ -0,0 +1,33 @@
+// Built-in base types for API calls. Primarily useful as return types.
+
+syntax = "proto2";
+option go_package = "base";
+
+package appengine.base;
+
+message StringProto {
+  required string value = 1;
+}
+
+message Integer32Proto {
+  required int32 value = 1;
+}
+
+message Integer64Proto {
+  required int64 value = 1;
+}
+
+message BoolProto {
+  required bool value = 1;
+}
+
+message DoubleProto {
+  required double value = 1;
+}
+
+message BytesProto {
+  required bytes value = 1 [ctype=CORD];
+}
+
+message VoidProto {
+}
diff --git a/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go b/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go
new file mode 100644
index 0000000..2fb7482
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go
@@ -0,0 +1,4367 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google.golang.org/appengine/internal/datastore/datastore_v3.proto
+
+package datastore
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type Property_Meaning int32
+
+const (
+        Property_NO_MEANING       Property_Meaning = 0
+        Property_BLOB             Property_Meaning = 14
+        Property_TEXT             Property_Meaning = 15
+        Property_BYTESTRING       Property_Meaning = 16
+        Property_ATOM_CATEGORY    Property_Meaning = 1
+        Property_ATOM_LINK        Property_Meaning = 2
+        Property_ATOM_TITLE       Property_Meaning = 3
+        Property_ATOM_CONTENT     Property_Meaning = 4
+        Property_ATOM_SUMMARY     Property_Meaning = 5
+        Property_ATOM_AUTHOR      Property_Meaning = 6
+        Property_GD_WHEN          Property_Meaning = 7
+        Property_GD_EMAIL         Property_Meaning = 8
+        Property_GEORSS_POINT     Property_Meaning = 9
+        Property_GD_IM            Property_Meaning = 10
+        Property_GD_PHONENUMBER   Property_Meaning = 11
+        Property_GD_POSTALADDRESS Property_Meaning = 12
+        Property_GD_RATING        Property_Meaning = 13
+        Property_BLOBKEY          Property_Meaning = 17
+        Property_ENTITY_PROTO     Property_Meaning = 19
+        Property_INDEX_VALUE      Property_Meaning = 18
+)
+
+var Property_Meaning_name = map[int32]string{
+        0:  "NO_MEANING",
+        14: "BLOB",
+        15: "TEXT",
+        16: "BYTESTRING",
+        1:  "ATOM_CATEGORY",
+        2:  "ATOM_LINK",
+        3:  "ATOM_TITLE",
+        4:  "ATOM_CONTENT",
+        5:  "ATOM_SUMMARY",
+        6:  "ATOM_AUTHOR",
+        7:  "GD_WHEN",
+        8:  "GD_EMAIL",
+        9:  "GEORSS_POINT",
+        10: "GD_IM",
+        11: "GD_PHONENUMBER",
+        12: "GD_POSTALADDRESS",
+        13: "GD_RATING",
+        17: "BLOBKEY",
+        19: "ENTITY_PROTO",
+        18: "INDEX_VALUE",
+}
+var Property_Meaning_value = map[string]int32{
+        "NO_MEANING":       0,
+        "BLOB":             14,
+        "TEXT":             15,
+        "BYTESTRING":       16,
+        "ATOM_CATEGORY":    1,
+        "ATOM_LINK":        2,
+        "ATOM_TITLE":       3,
+        "ATOM_CONTENT":     4,
+        "ATOM_SUMMARY":     5,
+        "ATOM_AUTHOR":      6,
+        "GD_WHEN":          7,
+        "GD_EMAIL":         8,
+        "GEORSS_POINT":     9,
+        "GD_IM":            10,
+        "GD_PHONENUMBER":   11,
+        "GD_POSTALADDRESS": 12,
+        "GD_RATING":        13,
+        "BLOBKEY":          17,
+        "ENTITY_PROTO":     19,
+        "INDEX_VALUE":      18,
+}
+
+func (x Property_Meaning) Enum() *Property_Meaning {
+        p := new(Property_Meaning)
+        *p = x
+        return p
+}
+func (x Property_Meaning) String() string {
+        return proto.EnumName(Property_Meaning_name, int32(x))
+}
+func (x *Property_Meaning) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(Property_Meaning_value, data, "Property_Meaning")
+        if err != nil {
+                return err
+        }
+        *x = Property_Meaning(value)
+        return nil
+}
+func (Property_Meaning) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{2, 0}
+}
+
+type Property_FtsTokenizationOption int32
+
+const (
+        Property_HTML Property_FtsTokenizationOption = 1
+        Property_ATOM Property_FtsTokenizationOption = 2
+)
+
+var Property_FtsTokenizationOption_name = map[int32]string{
+        1: "HTML",
+        2: "ATOM",
+}
+var Property_FtsTokenizationOption_value = map[string]int32{
+        "HTML": 1,
+        "ATOM": 2,
+}
+
+func (x Property_FtsTokenizationOption) Enum() *Property_FtsTokenizationOption {
+        p := new(Property_FtsTokenizationOption)
+        *p = x
+        return p
+}
+func (x Property_FtsTokenizationOption) String() string {
+        return proto.EnumName(Property_FtsTokenizationOption_name, int32(x))
+}
+func (x *Property_FtsTokenizationOption) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(Property_FtsTokenizationOption_value, data, "Property_FtsTokenizationOption")
+        if err != nil {
+                return err
+        }
+        *x = Property_FtsTokenizationOption(value)
+        return nil
+}
+func (Property_FtsTokenizationOption) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{2, 1}
+}
+
+type EntityProto_Kind int32
+
+const (
+        EntityProto_GD_CONTACT EntityProto_Kind = 1
+        EntityProto_GD_EVENT   EntityProto_Kind = 2
+        EntityProto_GD_MESSAGE EntityProto_Kind = 3
+)
+
+var EntityProto_Kind_name = map[int32]string{
+        1: "GD_CONTACT",
+        2: "GD_EVENT",
+        3: "GD_MESSAGE",
+}
+var EntityProto_Kind_value = map[string]int32{
+        "GD_CONTACT": 1,
+        "GD_EVENT":   2,
+        "GD_MESSAGE": 3,
+}
+
+func (x EntityProto_Kind) Enum() *EntityProto_Kind {
+        p := new(EntityProto_Kind)
+        *p = x
+        return p
+}
+func (x EntityProto_Kind) String() string {
+        return proto.EnumName(EntityProto_Kind_name, int32(x))
+}
+func (x *EntityProto_Kind) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(EntityProto_Kind_value, data, "EntityProto_Kind")
+        if err != nil {
+                return err
+        }
+        *x = EntityProto_Kind(value)
+        return nil
+}
+func (EntityProto_Kind) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{6, 0}
+}
+
+type Index_Property_Direction int32
+
+const (
+        Index_Property_ASCENDING  Index_Property_Direction = 1
+        Index_Property_DESCENDING Index_Property_Direction = 2
+)
+
+var Index_Property_Direction_name = map[int32]string{
+        1: "ASCENDING",
+        2: "DESCENDING",
+}
+var Index_Property_Direction_value = map[string]int32{
+        "ASCENDING":  1,
+        "DESCENDING": 2,
+}
+
+func (x Index_Property_Direction) Enum() *Index_Property_Direction {
+        p := new(Index_Property_Direction)
+        *p = x
+        return p
+}
+func (x Index_Property_Direction) String() string {
+        return proto.EnumName(Index_Property_Direction_name, int32(x))
+}
+func (x *Index_Property_Direction) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(Index_Property_Direction_value, data, "Index_Property_Direction")
+        if err != nil {
+                return err
+        }
+        *x = Index_Property_Direction(value)
+        return nil
+}
+func (Index_Property_Direction) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{8, 0, 0}
+}
+
+type CompositeIndex_State int32
+
+const (
+        CompositeIndex_WRITE_ONLY CompositeIndex_State = 1
+        CompositeIndex_READ_WRITE CompositeIndex_State = 2
+        CompositeIndex_DELETED    CompositeIndex_State = 3
+        CompositeIndex_ERROR      CompositeIndex_State = 4
+)
+
+var CompositeIndex_State_name = map[int32]string{
+        1: "WRITE_ONLY",
+        2: "READ_WRITE",
+        3: "DELETED",
+        4: "ERROR",
+}
+var CompositeIndex_State_value = map[string]int32{
+        "WRITE_ONLY": 1,
+        "READ_WRITE": 2,
+        "DELETED":    3,
+        "ERROR":      4,
+}
+
+func (x CompositeIndex_State) Enum() *CompositeIndex_State {
+        p := new(CompositeIndex_State)
+        *p = x
+        return p
+}
+func (x CompositeIndex_State) String() string {
+        return proto.EnumName(CompositeIndex_State_name, int32(x))
+}
+func (x *CompositeIndex_State) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(CompositeIndex_State_value, data, "CompositeIndex_State")
+        if err != nil {
+                return err
+        }
+        *x = CompositeIndex_State(value)
+        return nil
+}
+func (CompositeIndex_State) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{9, 0}
+}
+
+type Snapshot_Status int32
+
+const (
+        Snapshot_INACTIVE Snapshot_Status = 0
+        Snapshot_ACTIVE   Snapshot_Status = 1
+)
+
+var Snapshot_Status_name = map[int32]string{
+        0: "INACTIVE",
+        1: "ACTIVE",
+}
+var Snapshot_Status_value = map[string]int32{
+        "INACTIVE": 0,
+        "ACTIVE":   1,
+}
+
+func (x Snapshot_Status) Enum() *Snapshot_Status {
+        p := new(Snapshot_Status)
+        *p = x
+        return p
+}
+func (x Snapshot_Status) String() string {
+        return proto.EnumName(Snapshot_Status_name, int32(x))
+}
+func (x *Snapshot_Status) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(Snapshot_Status_value, data, "Snapshot_Status")
+        if err != nil {
+                return err
+        }
+        *x = Snapshot_Status(value)
+        return nil
+}
+func (Snapshot_Status) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{12, 0}
+}
+
+type Query_Hint int32
+
+const (
+        Query_ORDER_FIRST    Query_Hint = 1
+        Query_ANCESTOR_FIRST Query_Hint = 2
+        Query_FILTER_FIRST   Query_Hint = 3
+)
+
+var Query_Hint_name = map[int32]string{
+        1: "ORDER_FIRST",
+        2: "ANCESTOR_FIRST",
+        3: "FILTER_FIRST",
+}
+var Query_Hint_value = map[string]int32{
+        "ORDER_FIRST":    1,
+        "ANCESTOR_FIRST": 2,
+        "FILTER_FIRST":   3,
+}
+
+func (x Query_Hint) Enum() *Query_Hint {
+        p := new(Query_Hint)
+        *p = x
+        return p
+}
+func (x Query_Hint) String() string {
+        return proto.EnumName(Query_Hint_name, int32(x))
+}
+func (x *Query_Hint) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(Query_Hint_value, data, "Query_Hint")
+        if err != nil {
+                return err
+        }
+        *x = Query_Hint(value)
+        return nil
+}
+func (Query_Hint) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 0}
+}
+
+type Query_Filter_Operator int32
+
+const (
+        Query_Filter_LESS_THAN             Query_Filter_Operator = 1
+        Query_Filter_LESS_THAN_OR_EQUAL    Query_Filter_Operator = 2
+        Query_Filter_GREATER_THAN          Query_Filter_Operator = 3
+        Query_Filter_GREATER_THAN_OR_EQUAL Query_Filter_Operator = 4
+        Query_Filter_EQUAL                 Query_Filter_Operator = 5
+        Query_Filter_IN                    Query_Filter_Operator = 6
+        Query_Filter_EXISTS                Query_Filter_Operator = 7
+)
+
+var Query_Filter_Operator_name = map[int32]string{
+        1: "LESS_THAN",
+        2: "LESS_THAN_OR_EQUAL",
+        3: "GREATER_THAN",
+        4: "GREATER_THAN_OR_EQUAL",
+        5: "EQUAL",
+        6: "IN",
+        7: "EXISTS",
+}
+var Query_Filter_Operator_value = map[string]int32{
+        "LESS_THAN":             1,
+        "LESS_THAN_OR_EQUAL":    2,
+        "GREATER_THAN":          3,
+        "GREATER_THAN_OR_EQUAL": 4,
+        "EQUAL":                 5,
+        "IN":                    6,
+        "EXISTS":                7,
+}
+
+func (x Query_Filter_Operator) Enum() *Query_Filter_Operator {
+        p := new(Query_Filter_Operator)
+        *p = x
+        return p
+}
+func (x Query_Filter_Operator) String() string {
+        return proto.EnumName(Query_Filter_Operator_name, int32(x))
+}
+func (x *Query_Filter_Operator) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(Query_Filter_Operator_value, data, "Query_Filter_Operator")
+        if err != nil {
+                return err
+        }
+        *x = Query_Filter_Operator(value)
+        return nil
+}
+func (Query_Filter_Operator) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 0, 0}
+}
+
+type Query_Order_Direction int32
+
+const (
+        Query_Order_ASCENDING  Query_Order_Direction = 1
+        Query_Order_DESCENDING Query_Order_Direction = 2
+)
+
+var Query_Order_Direction_name = map[int32]string{
+        1: "ASCENDING",
+        2: "DESCENDING",
+}
+var Query_Order_Direction_value = map[string]int32{
+        "ASCENDING":  1,
+        "DESCENDING": 2,
+}
+
+func (x Query_Order_Direction) Enum() *Query_Order_Direction {
+        p := new(Query_Order_Direction)
+        *p = x
+        return p
+}
+func (x Query_Order_Direction) String() string {
+        return proto.EnumName(Query_Order_Direction_name, int32(x))
+}
+func (x *Query_Order_Direction) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(Query_Order_Direction_value, data, "Query_Order_Direction")
+        if err != nil {
+                return err
+        }
+        *x = Query_Order_Direction(value)
+        return nil
+}
+func (Query_Order_Direction) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 1, 0}
+}
+
+type Error_ErrorCode int32
+
+const (
+        Error_BAD_REQUEST                  Error_ErrorCode = 1
+        Error_CONCURRENT_TRANSACTION       Error_ErrorCode = 2
+        Error_INTERNAL_ERROR               Error_ErrorCode = 3
+        Error_NEED_INDEX                   Error_ErrorCode = 4
+        Error_TIMEOUT                      Error_ErrorCode = 5
+        Error_PERMISSION_DENIED            Error_ErrorCode = 6
+        Error_BIGTABLE_ERROR               Error_ErrorCode = 7
+        Error_COMMITTED_BUT_STILL_APPLYING Error_ErrorCode = 8
+        Error_CAPABILITY_DISABLED          Error_ErrorCode = 9
+        Error_TRY_ALTERNATE_BACKEND        Error_ErrorCode = 10
+        Error_SAFE_TIME_TOO_OLD            Error_ErrorCode = 11
+)
+
+var Error_ErrorCode_name = map[int32]string{
+        1:  "BAD_REQUEST",
+        2:  "CONCURRENT_TRANSACTION",
+        3:  "INTERNAL_ERROR",
+        4:  "NEED_INDEX",
+        5:  "TIMEOUT",
+        6:  "PERMISSION_DENIED",
+        7:  "BIGTABLE_ERROR",
+        8:  "COMMITTED_BUT_STILL_APPLYING",
+        9:  "CAPABILITY_DISABLED",
+        10: "TRY_ALTERNATE_BACKEND",
+        11: "SAFE_TIME_TOO_OLD",
+}
+var Error_ErrorCode_value = map[string]int32{
+        "BAD_REQUEST":                  1,
+        "CONCURRENT_TRANSACTION":       2,
+        "INTERNAL_ERROR":               3,
+        "NEED_INDEX":                   4,
+        "TIMEOUT":                      5,
+        "PERMISSION_DENIED":            6,
+        "BIGTABLE_ERROR":               7,
+        "COMMITTED_BUT_STILL_APPLYING": 8,
+        "CAPABILITY_DISABLED":          9,
+        "TRY_ALTERNATE_BACKEND":        10,
+        "SAFE_TIME_TOO_OLD":            11,
+}
+
+func (x Error_ErrorCode) Enum() *Error_ErrorCode {
+        p := new(Error_ErrorCode)
+        *p = x
+        return p
+}
+func (x Error_ErrorCode) String() string {
+        return proto.EnumName(Error_ErrorCode_name, int32(x))
+}
+func (x *Error_ErrorCode) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(Error_ErrorCode_value, data, "Error_ErrorCode")
+        if err != nil {
+                return err
+        }
+        *x = Error_ErrorCode(value)
+        return nil
+}
+func (Error_ErrorCode) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{19, 0}
+}
+
+type PutRequest_AutoIdPolicy int32
+
+const (
+        PutRequest_CURRENT    PutRequest_AutoIdPolicy = 0
+        PutRequest_SEQUENTIAL PutRequest_AutoIdPolicy = 1
+)
+
+var PutRequest_AutoIdPolicy_name = map[int32]string{
+        0: "CURRENT",
+        1: "SEQUENTIAL",
+}
+var PutRequest_AutoIdPolicy_value = map[string]int32{
+        "CURRENT":    0,
+        "SEQUENTIAL": 1,
+}
+
+func (x PutRequest_AutoIdPolicy) Enum() *PutRequest_AutoIdPolicy {
+        p := new(PutRequest_AutoIdPolicy)
+        *p = x
+        return p
+}
+func (x PutRequest_AutoIdPolicy) String() string {
+        return proto.EnumName(PutRequest_AutoIdPolicy_name, int32(x))
+}
+func (x *PutRequest_AutoIdPolicy) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(PutRequest_AutoIdPolicy_value, data, "PutRequest_AutoIdPolicy")
+        if err != nil {
+                return err
+        }
+        *x = PutRequest_AutoIdPolicy(value)
+        return nil
+}
+func (PutRequest_AutoIdPolicy) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{23, 0}
+}
+
+type BeginTransactionRequest_TransactionMode int32
+
+const (
+        BeginTransactionRequest_UNKNOWN    BeginTransactionRequest_TransactionMode = 0
+        BeginTransactionRequest_READ_ONLY  BeginTransactionRequest_TransactionMode = 1
+        BeginTransactionRequest_READ_WRITE BeginTransactionRequest_TransactionMode = 2
+)
+
+var BeginTransactionRequest_TransactionMode_name = map[int32]string{
+        0: "UNKNOWN",
+        1: "READ_ONLY",
+        2: "READ_WRITE",
+}
+var BeginTransactionRequest_TransactionMode_value = map[string]int32{
+        "UNKNOWN":    0,
+        "READ_ONLY":  1,
+        "READ_WRITE": 2,
+}
+
+func (x BeginTransactionRequest_TransactionMode) Enum() *BeginTransactionRequest_TransactionMode {
+        p := new(BeginTransactionRequest_TransactionMode)
+        *p = x
+        return p
+}
+func (x BeginTransactionRequest_TransactionMode) String() string {
+        return proto.EnumName(BeginTransactionRequest_TransactionMode_name, int32(x))
+}
+func (x *BeginTransactionRequest_TransactionMode) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(BeginTransactionRequest_TransactionMode_value, data, "BeginTransactionRequest_TransactionMode")
+        if err != nil {
+                return err
+        }
+        *x = BeginTransactionRequest_TransactionMode(value)
+        return nil
+}
+func (BeginTransactionRequest_TransactionMode) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{36, 0}
+}
+
+type Action struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Action) Reset()         { *m = Action{} }
+func (m *Action) String() string { return proto.CompactTextString(m) }
+func (*Action) ProtoMessage()    {}
+func (*Action) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{0}
+}
+func (m *Action) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Action.Unmarshal(m, b)
+}
+func (m *Action) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Action.Marshal(b, m, deterministic)
+}
+func (dst *Action) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Action.Merge(dst, src)
+}
+func (m *Action) XXX_Size() int {
+        return xxx_messageInfo_Action.Size(m)
+}
+func (m *Action) XXX_DiscardUnknown() {
+        xxx_messageInfo_Action.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Action proto.InternalMessageInfo
+
+type PropertyValue struct {
+        Int64Value           *int64                        `protobuf:"varint,1,opt,name=int64Value" json:"int64Value,omitempty"`
+        BooleanValue         *bool                         `protobuf:"varint,2,opt,name=booleanValue" json:"booleanValue,omitempty"`
+        StringValue          *string                       `protobuf:"bytes,3,opt,name=stringValue" json:"stringValue,omitempty"`
+        DoubleValue          *float64                      `protobuf:"fixed64,4,opt,name=doubleValue" json:"doubleValue,omitempty"`
+        Pointvalue           *PropertyValue_PointValue     `protobuf:"group,5,opt,name=PointValue,json=pointvalue" json:"pointvalue,omitempty"`
+        Uservalue            *PropertyValue_UserValue      `protobuf:"group,8,opt,name=UserValue,json=uservalue" json:"uservalue,omitempty"`
+        Referencevalue       *PropertyValue_ReferenceValue `protobuf:"group,12,opt,name=ReferenceValue,json=referencevalue" json:"referencevalue,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
+        XXX_unrecognized     []byte                        `json:"-"`
+        XXX_sizecache        int32                         `json:"-"`
+}
+
+func (m *PropertyValue) Reset()         { *m = PropertyValue{} }
+func (m *PropertyValue) String() string { return proto.CompactTextString(m) }
+func (*PropertyValue) ProtoMessage()    {}
+func (*PropertyValue) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1}
+}
+func (m *PropertyValue) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_PropertyValue.Unmarshal(m, b)
+}
+func (m *PropertyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_PropertyValue.Marshal(b, m, deterministic)
+}
+func (dst *PropertyValue) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_PropertyValue.Merge(dst, src)
+}
+func (m *PropertyValue) XXX_Size() int {
+        return xxx_messageInfo_PropertyValue.Size(m)
+}
+func (m *PropertyValue) XXX_DiscardUnknown() {
+        xxx_messageInfo_PropertyValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PropertyValue proto.InternalMessageInfo
+
+func (m *PropertyValue) GetInt64Value() int64 {
+        if m != nil && m.Int64Value != nil {
+                return *m.Int64Value
+        }
+        return 0
+}
+
+func (m *PropertyValue) GetBooleanValue() bool {
+        if m != nil && m.BooleanValue != nil {
+                return *m.BooleanValue
+        }
+        return false
+}
+
+func (m *PropertyValue) GetStringValue() string {
+        if m != nil && m.StringValue != nil {
+                return *m.StringValue
+        }
+        return ""
+}
+
+func (m *PropertyValue) GetDoubleValue() float64 {
+        if m != nil && m.DoubleValue != nil {
+                return *m.DoubleValue
+        }
+        return 0
+}
+
+func (m *PropertyValue) GetPointvalue() *PropertyValue_PointValue {
+        if m != nil {
+                return m.Pointvalue
+        }
+        return nil
+}
+
+func (m *PropertyValue) GetUservalue() *PropertyValue_UserValue {
+        if m != nil {
+                return m.Uservalue
+        }
+        return nil
+}
+
+func (m *PropertyValue) GetReferencevalue() *PropertyValue_ReferenceValue {
+        if m != nil {
+                return m.Referencevalue
+        }
+        return nil
+}
+
+type PropertyValue_PointValue struct {
+        X                    *float64 `protobuf:"fixed64,6,req,name=x" json:"x,omitempty"`
+        Y                    *float64 `protobuf:"fixed64,7,req,name=y" json:"y,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PropertyValue_PointValue) Reset()         { *m = PropertyValue_PointValue{} }
+func (m *PropertyValue_PointValue) String() string { return proto.CompactTextString(m) }
+func (*PropertyValue_PointValue) ProtoMessage()    {}
+func (*PropertyValue_PointValue) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 0}
+}
+func (m *PropertyValue_PointValue) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_PropertyValue_PointValue.Unmarshal(m, b)
+}
+func (m *PropertyValue_PointValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_PropertyValue_PointValue.Marshal(b, m, deterministic)
+}
+func (dst *PropertyValue_PointValue) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_PropertyValue_PointValue.Merge(dst, src)
+}
+func (m *PropertyValue_PointValue) XXX_Size() int {
+        return xxx_messageInfo_PropertyValue_PointValue.Size(m)
+}
+func (m *PropertyValue_PointValue) XXX_DiscardUnknown() {
+        xxx_messageInfo_PropertyValue_PointValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PropertyValue_PointValue proto.InternalMessageInfo
+
+func (m *PropertyValue_PointValue) GetX() float64 {
+        if m != nil && m.X != nil {
+                return *m.X
+        }
+        return 0
+}
+
+func (m *PropertyValue_PointValue) GetY() float64 {
+        if m != nil && m.Y != nil {
+                return *m.Y
+        }
+        return 0
+}
+
+type PropertyValue_UserValue struct {
+        Email                *string  `protobuf:"bytes,9,req,name=email" json:"email,omitempty"`
+        AuthDomain           *string  `protobuf:"bytes,10,req,name=auth_domain,json=authDomain" json:"auth_domain,omitempty"`
+        Nickname             *string  `protobuf:"bytes,11,opt,name=nickname" json:"nickname,omitempty"`
+        FederatedIdentity    *string  `protobuf:"bytes,21,opt,name=federated_identity,json=federatedIdentity" json:"federated_identity,omitempty"`
+        FederatedProvider    *string  `protobuf:"bytes,22,opt,name=federated_provider,json=federatedProvider" json:"federated_provider,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PropertyValue_UserValue) Reset()         { *m = PropertyValue_UserValue{} }
+func (m *PropertyValue_UserValue) String() string { return proto.CompactTextString(m) }
+func (*PropertyValue_UserValue) ProtoMessage()    {}
+func (*PropertyValue_UserValue) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 1}
+}
+func (m *PropertyValue_UserValue) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_PropertyValue_UserValue.Unmarshal(m, b)
+}
+func (m *PropertyValue_UserValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_PropertyValue_UserValue.Marshal(b, m, deterministic)
+}
+func (dst *PropertyValue_UserValue) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_PropertyValue_UserValue.Merge(dst, src)
+}
+func (m *PropertyValue_UserValue) XXX_Size() int {
+        return xxx_messageInfo_PropertyValue_UserValue.Size(m)
+}
+func (m *PropertyValue_UserValue) XXX_DiscardUnknown() {
+        xxx_messageInfo_PropertyValue_UserValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PropertyValue_UserValue proto.InternalMessageInfo
+
+func (m *PropertyValue_UserValue) GetEmail() string {
+        if m != nil && m.Email != nil {
+                return *m.Email
+        }
+        return ""
+}
+
+func (m *PropertyValue_UserValue) GetAuthDomain() string {
+        if m != nil && m.AuthDomain != nil {
+                return *m.AuthDomain
+        }
+        return ""
+}
+
+func (m *PropertyValue_UserValue) GetNickname() string {
+        if m != nil && m.Nickname != nil {
+                return *m.Nickname
+        }
+        return ""
+}
+
+func (m *PropertyValue_UserValue) GetFederatedIdentity() string {
+        if m != nil && m.FederatedIdentity != nil {
+                return *m.FederatedIdentity
+        }
+        return ""
+}
+
+func (m *PropertyValue_UserValue) GetFederatedProvider() string {
+        if m != nil && m.FederatedProvider != nil {
+                return *m.FederatedProvider
+        }
+        return ""
+}
+
+type PropertyValue_ReferenceValue struct {
+        App                  *string                                     `protobuf:"bytes,13,req,name=app" json:"app,omitempty"`
+        NameSpace            *string                                     `protobuf:"bytes,20,opt,name=name_space,json=nameSpace" json:"name_space,omitempty"`
+        Pathelement          []*PropertyValue_ReferenceValue_PathElement `protobuf:"group,14,rep,name=PathElement,json=pathelement" json:"pathelement,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                                    `json:"-"`
+        XXX_unrecognized     []byte                                      `json:"-"`
+        XXX_sizecache        int32                                       `json:"-"`
+}
+
+func (m *PropertyValue_ReferenceValue) Reset()         { *m = PropertyValue_ReferenceValue{} }
+func (m *PropertyValue_ReferenceValue) String() string { return proto.CompactTextString(m) }
+func (*PropertyValue_ReferenceValue) ProtoMessage()    {}
+func (*PropertyValue_ReferenceValue) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 2}
+}
+func (m *PropertyValue_ReferenceValue) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_PropertyValue_ReferenceValue.Unmarshal(m, b)
+}
+func (m *PropertyValue_ReferenceValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_PropertyValue_ReferenceValue.Marshal(b, m, deterministic)
+}
+func (dst *PropertyValue_ReferenceValue) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_PropertyValue_ReferenceValue.Merge(dst, src)
+}
+func (m *PropertyValue_ReferenceValue) XXX_Size() int {
+        return xxx_messageInfo_PropertyValue_ReferenceValue.Size(m)
+}
+func (m *PropertyValue_ReferenceValue) XXX_DiscardUnknown() {
+        xxx_messageInfo_PropertyValue_ReferenceValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PropertyValue_ReferenceValue proto.InternalMessageInfo
+
+func (m *PropertyValue_ReferenceValue) GetApp() string {
+        if m != nil && m.App != nil {
+                return *m.App
+        }
+        return ""
+}
+
+func (m *PropertyValue_ReferenceValue) GetNameSpace() string {
+        if m != nil && m.NameSpace != nil {
+                return *m.NameSpace
+        }
+        return ""
+}
+
+func (m *PropertyValue_ReferenceValue) GetPathelement() []*PropertyValue_ReferenceValue_PathElement {
+        if m != nil {
+                return m.Pathelement
+        }
+        return nil
+}
+
+type PropertyValue_ReferenceValue_PathElement struct {
+        Type                 *string  `protobuf:"bytes,15,req,name=type" json:"type,omitempty"`
+        Id                   *int64   `protobuf:"varint,16,opt,name=id" json:"id,omitempty"`
+        Name                 *string  `protobuf:"bytes,17,opt,name=name" json:"name,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PropertyValue_ReferenceValue_PathElement) Reset() {
+        *m = PropertyValue_ReferenceValue_PathElement{}
+}
+func (m *PropertyValue_ReferenceValue_PathElement) String() string { return proto.CompactTextString(m) }
+func (*PropertyValue_ReferenceValue_PathElement) ProtoMessage()    {}
+func (*PropertyValue_ReferenceValue_PathElement) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 2, 0}
+}
+func (m *PropertyValue_ReferenceValue_PathElement) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Unmarshal(m, b)
+}
+func (m *PropertyValue_ReferenceValue_PathElement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Marshal(b, m, deterministic)
+}
+func (dst *PropertyValue_ReferenceValue_PathElement) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Merge(dst, src)
+}
+func (m *PropertyValue_ReferenceValue_PathElement) XXX_Size() int {
+        return xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Size(m)
+}
+func (m *PropertyValue_ReferenceValue_PathElement) XXX_DiscardUnknown() {
+        xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PropertyValue_ReferenceValue_PathElement proto.InternalMessageInfo
+
+func (m *PropertyValue_ReferenceValue_PathElement) GetType() string {
+        if m != nil && m.Type != nil {
+                return *m.Type
+        }
+        return ""
+}
+
+func (m *PropertyValue_ReferenceValue_PathElement) GetId() int64 {
+        if m != nil && m.Id != nil {
+                return *m.Id
+        }
+        return 0
+}
+
+func (m *PropertyValue_ReferenceValue_PathElement) GetName() string {
+        if m != nil && m.Name != nil {
+                return *m.Name
+        }
+        return ""
+}
+
+type Property struct {
+        Meaning               *Property_Meaning               `protobuf:"varint,1,opt,name=meaning,enum=appengine.Property_Meaning,def=0" json:"meaning,omitempty"`
+        MeaningUri            *string                         `protobuf:"bytes,2,opt,name=meaning_uri,json=meaningUri" json:"meaning_uri,omitempty"`
+        Name                  *string                         `protobuf:"bytes,3,req,name=name" json:"name,omitempty"`
+        Value                 *PropertyValue                  `protobuf:"bytes,5,req,name=value" json:"value,omitempty"`
+        Multiple              *bool                           `protobuf:"varint,4,req,name=multiple" json:"multiple,omitempty"`
+        Searchable            *bool                           `protobuf:"varint,6,opt,name=searchable,def=0" json:"searchable,omitempty"`
+        FtsTokenizationOption *Property_FtsTokenizationOption `protobuf:"varint,8,opt,name=fts_tokenization_option,json=ftsTokenizationOption,enum=appengine.Property_FtsTokenizationOption" json:"fts_tokenization_option,omitempty"`
+        Locale                *string                         `protobuf:"bytes,9,opt,name=locale,def=en" json:"locale,omitempty"`
+        XXX_NoUnkeyedLiteral  struct{}                        `json:"-"`
+        XXX_unrecognized      []byte                          `json:"-"`
+        XXX_sizecache         int32                           `json:"-"`
+}
+
+func (m *Property) Reset()         { *m = Property{} }
+func (m *Property) String() string { return proto.CompactTextString(m) }
+func (*Property) ProtoMessage()    {}
+func (*Property) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{2}
+}
+func (m *Property) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Property.Unmarshal(m, b)
+}
+func (m *Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Property.Marshal(b, m, deterministic)
+}
+func (dst *Property) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Property.Merge(dst, src)
+}
+func (m *Property) XXX_Size() int {
+        return xxx_messageInfo_Property.Size(m)
+}
+func (m *Property) XXX_DiscardUnknown() {
+        xxx_messageInfo_Property.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Property proto.InternalMessageInfo
+
+const Default_Property_Meaning Property_Meaning = Property_NO_MEANING
+const Default_Property_Searchable bool = false
+const Default_Property_Locale string = "en"
+
+func (m *Property) GetMeaning() Property_Meaning {
+        if m != nil && m.Meaning != nil {
+                return *m.Meaning
+        }
+        return Default_Property_Meaning
+}
+
+func (m *Property) GetMeaningUri() string {
+        if m != nil && m.MeaningUri != nil {
+                return *m.MeaningUri
+        }
+        return ""
+}
+
+func (m *Property) GetName() string {
+        if m != nil && m.Name != nil {
+                return *m.Name
+        }
+        return ""
+}
+
+func (m *Property) GetValue() *PropertyValue {
+        if m != nil {
+                return m.Value
+        }
+        return nil
+}
+
+func (m *Property) GetMultiple() bool {
+        if m != nil && m.Multiple != nil {
+                return *m.Multiple
+        }
+        return false
+}
+
+func (m *Property) GetSearchable() bool {
+        if m != nil && m.Searchable != nil {
+                return *m.Searchable
+        }
+        return Default_Property_Searchable
+}
+
+func (m *Property) GetFtsTokenizationOption() Property_FtsTokenizationOption {
+        if m != nil && m.FtsTokenizationOption != nil {
+                return *m.FtsTokenizationOption
+        }
+        return Property_HTML
+}
+
+func (m *Property) GetLocale() string {
+        if m != nil && m.Locale != nil {
+                return *m.Locale
+        }
+        return Default_Property_Locale
+}
+
+type Path struct {
+        Element              []*Path_Element `protobuf:"group,1,rep,name=Element,json=element" json:"element,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+        XXX_unrecognized     []byte          `json:"-"`
+        XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *Path) Reset()         { *m = Path{} }
+func (m *Path) String() string { return proto.CompactTextString(m) }
+func (*Path) ProtoMessage()    {}
+func (*Path) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{3}
+}
+func (m *Path) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Path.Unmarshal(m, b)
+}
+func (m *Path) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Path.Marshal(b, m, deterministic)
+}
+func (dst *Path) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Path.Merge(dst, src)
+}
+func (m *Path) XXX_Size() int {
+        return xxx_messageInfo_Path.Size(m)
+}
+func (m *Path) XXX_DiscardUnknown() {
+        xxx_messageInfo_Path.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Path proto.InternalMessageInfo
+
+func (m *Path) GetElement() []*Path_Element {
+        if m != nil {
+                return m.Element
+        }
+        return nil
+}
+
+type Path_Element struct {
+        Type                 *string  `protobuf:"bytes,2,req,name=type" json:"type,omitempty"`
+        Id                   *int64   `protobuf:"varint,3,opt,name=id" json:"id,omitempty"`
+        Name                 *string  `protobuf:"bytes,4,opt,name=name" json:"name,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Path_Element) Reset()         { *m = Path_Element{} }
+func (m *Path_Element) String() string { return proto.CompactTextString(m) }
+func (*Path_Element) ProtoMessage()    {}
+func (*Path_Element) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{3, 0}
+}
+func (m *Path_Element) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Path_Element.Unmarshal(m, b)
+}
+func (m *Path_Element) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Path_Element.Marshal(b, m, deterministic)
+}
+func (dst *Path_Element) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Path_Element.Merge(dst, src)
+}
+func (m *Path_Element) XXX_Size() int {
+        return xxx_messageInfo_Path_Element.Size(m)
+}
+func (m *Path_Element) XXX_DiscardUnknown() {
+        xxx_messageInfo_Path_Element.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Path_Element proto.InternalMessageInfo
+
+func (m *Path_Element) GetType() string {
+        if m != nil && m.Type != nil {
+                return *m.Type
+        }
+        return ""
+}
+
+func (m *Path_Element) GetId() int64 {
+        if m != nil && m.Id != nil {
+                return *m.Id
+        }
+        return 0
+}
+
+func (m *Path_Element) GetName() string {
+        if m != nil && m.Name != nil {
+                return *m.Name
+        }
+        return ""
+}
+
+type Reference struct {
+        App                  *string  `protobuf:"bytes,13,req,name=app" json:"app,omitempty"`
+        NameSpace            *string  `protobuf:"bytes,20,opt,name=name_space,json=nameSpace" json:"name_space,omitempty"`
+        Path                 *Path    `protobuf:"bytes,14,req,name=path" json:"path,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Reference) Reset()         { *m = Reference{} }
+func (m *Reference) String() string { return proto.CompactTextString(m) }
+func (*Reference) ProtoMessage()    {}
+func (*Reference) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{4}
+}
+func (m *Reference) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Reference.Unmarshal(m, b)
+}
+func (m *Reference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Reference.Marshal(b, m, deterministic)
+}
+func (dst *Reference) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Reference.Merge(dst, src)
+}
+func (m *Reference) XXX_Size() int {
+        return xxx_messageInfo_Reference.Size(m)
+}
+func (m *Reference) XXX_DiscardUnknown() {
+        xxx_messageInfo_Reference.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Reference proto.InternalMessageInfo
+
+func (m *Reference) GetApp() string {
+        if m != nil && m.App != nil {
+                return *m.App
+        }
+        return ""
+}
+
+func (m *Reference) GetNameSpace() string {
+        if m != nil && m.NameSpace != nil {
+                return *m.NameSpace
+        }
+        return ""
+}
+
+func (m *Reference) GetPath() *Path {
+        if m != nil {
+                return m.Path
+        }
+        return nil
+}
+
+type User struct {
+        Email                *string  `protobuf:"bytes,1,req,name=email" json:"email,omitempty"`
+        AuthDomain           *string  `protobuf:"bytes,2,req,name=auth_domain,json=authDomain" json:"auth_domain,omitempty"`
+        Nickname             *string  `protobuf:"bytes,3,opt,name=nickname" json:"nickname,omitempty"`
+        FederatedIdentity    *string  `protobuf:"bytes,6,opt,name=federated_identity,json=federatedIdentity" json:"federated_identity,omitempty"`
+        FederatedProvider    *string  `protobuf:"bytes,7,opt,name=federated_provider,json=federatedProvider" json:"federated_provider,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *User) Reset()         { *m = User{} }
+func (m *User) String() string { return proto.CompactTextString(m) }
+func (*User) ProtoMessage()    {}
+func (*User) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{5}
+}
+func (m *User) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_User.Unmarshal(m, b)
+}
+func (m *User) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_User.Marshal(b, m, deterministic)
+}
+func (dst *User) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_User.Merge(dst, src)
+}
+func (m *User) XXX_Size() int {
+        return xxx_messageInfo_User.Size(m)
+}
+func (m *User) XXX_DiscardUnknown() {
+        xxx_messageInfo_User.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_User proto.InternalMessageInfo
+
+func (m *User) GetEmail() string {
+        if m != nil && m.Email != nil {
+                return *m.Email
+        }
+        return ""
+}
+
+func (m *User) GetAuthDomain() string {
+        if m != nil && m.AuthDomain != nil {
+                return *m.AuthDomain
+        }
+        return ""
+}
+
+func (m *User) GetNickname() string {
+        if m != nil && m.Nickname != nil {
+                return *m.Nickname
+        }
+        return ""
+}
+
+func (m *User) GetFederatedIdentity() string {
+        if m != nil && m.FederatedIdentity != nil {
+                return *m.FederatedIdentity
+        }
+        return ""
+}
+
+func (m *User) GetFederatedProvider() string {
+        if m != nil && m.FederatedProvider != nil {
+                return *m.FederatedProvider
+        }
+        return ""
+}
+
+type EntityProto struct {
+        Key                  *Reference        `protobuf:"bytes,13,req,name=key" json:"key,omitempty"`
+        EntityGroup          *Path             `protobuf:"bytes,16,req,name=entity_group,json=entityGroup" json:"entity_group,omitempty"`
+        Owner                *User             `protobuf:"bytes,17,opt,name=owner" json:"owner,omitempty"`
+        Kind                 *EntityProto_Kind `protobuf:"varint,4,opt,name=kind,enum=appengine.EntityProto_Kind" json:"kind,omitempty"`
+        KindUri              *string           `protobuf:"bytes,5,opt,name=kind_uri,json=kindUri" json:"kind_uri,omitempty"`
+        Property             []*Property       `protobuf:"bytes,14,rep,name=property" json:"property,omitempty"`
+        RawProperty          []*Property       `protobuf:"bytes,15,rep,name=raw_property,json=rawProperty" json:"raw_property,omitempty"`
+        Rank                 *int32            `protobuf:"varint,18,opt,name=rank" json:"rank,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+        XXX_unrecognized     []byte            `json:"-"`
+        XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *EntityProto) Reset()         { *m = EntityProto{} }
+func (m *EntityProto) String() string { return proto.CompactTextString(m) }
+func (*EntityProto) ProtoMessage()    {}
+func (*EntityProto) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{6}
+}
+func (m *EntityProto) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_EntityProto.Unmarshal(m, b)
+}
+func (m *EntityProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_EntityProto.Marshal(b, m, deterministic)
+}
+func (dst *EntityProto) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_EntityProto.Merge(dst, src)
+}
+func (m *EntityProto) XXX_Size() int {
+        return xxx_messageInfo_EntityProto.Size(m)
+}
+func (m *EntityProto) XXX_DiscardUnknown() {
+        xxx_messageInfo_EntityProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EntityProto proto.InternalMessageInfo
+
+func (m *EntityProto) GetKey() *Reference {
+        if m != nil {
+                return m.Key
+        }
+        return nil
+}
+
+func (m *EntityProto) GetEntityGroup() *Path {
+        if m != nil {
+                return m.EntityGroup
+        }
+        return nil
+}
+
+func (m *EntityProto) GetOwner() *User {
+        if m != nil {
+                return m.Owner
+        }
+        return nil
+}
+
+func (m *EntityProto) GetKind() EntityProto_Kind {
+        if m != nil && m.Kind != nil {
+                return *m.Kind
+        }
+        return EntityProto_GD_CONTACT
+}
+
+func (m *EntityProto) GetKindUri() string {
+        if m != nil && m.KindUri != nil {
+                return *m.KindUri
+        }
+        return ""
+}
+
+func (m *EntityProto) GetProperty() []*Property {
+        if m != nil {
+                return m.Property
+        }
+        return nil
+}
+
+func (m *EntityProto) GetRawProperty() []*Property {
+        if m != nil {
+                return m.RawProperty
+        }
+        return nil
+}
+
+func (m *EntityProto) GetRank() int32 {
+        if m != nil && m.Rank != nil {
+                return *m.Rank
+        }
+        return 0
+}
+
+type CompositeProperty struct {
+        IndexId              *int64   `protobuf:"varint,1,req,name=index_id,json=indexId" json:"index_id,omitempty"`
+        Value                []string `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *CompositeProperty) Reset()         { *m = CompositeProperty{} }
+func (m *CompositeProperty) String() string { return proto.CompactTextString(m) }
+func (*CompositeProperty) ProtoMessage()    {}
+func (*CompositeProperty) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{7}
+}
+func (m *CompositeProperty) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompositeProperty.Unmarshal(m, b)
+}
+func (m *CompositeProperty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompositeProperty.Marshal(b, m, deterministic)
+}
+func (dst *CompositeProperty) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompositeProperty.Merge(dst, src)
+}
+func (m *CompositeProperty) XXX_Size() int {
+        return xxx_messageInfo_CompositeProperty.Size(m)
+}
+func (m *CompositeProperty) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompositeProperty.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompositeProperty proto.InternalMessageInfo
+
+func (m *CompositeProperty) GetIndexId() int64 {
+        if m != nil && m.IndexId != nil {
+                return *m.IndexId
+        }
+        return 0
+}
+
+func (m *CompositeProperty) GetValue() []string {
+        if m != nil {
+                return m.Value
+        }
+        return nil
+}
+
+type Index struct {
+        EntityType           *string           `protobuf:"bytes,1,req,name=entity_type,json=entityType" json:"entity_type,omitempty"`
+        Ancestor             *bool             `protobuf:"varint,5,req,name=ancestor" json:"ancestor,omitempty"`
+        Property             []*Index_Property `protobuf:"group,2,rep,name=Property,json=property" json:"property,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+        XXX_unrecognized     []byte            `json:"-"`
+        XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *Index) Reset()         { *m = Index{} }
+func (m *Index) String() string { return proto.CompactTextString(m) }
+func (*Index) ProtoMessage()    {}
+func (*Index) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{8}
+}
+func (m *Index) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Index.Unmarshal(m, b)
+}
+func (m *Index) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Index.Marshal(b, m, deterministic)
+}
+func (dst *Index) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Index.Merge(dst, src)
+}
+func (m *Index) XXX_Size() int {
+        return xxx_messageInfo_Index.Size(m)
+}
+func (m *Index) XXX_DiscardUnknown() {
+        xxx_messageInfo_Index.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Index proto.InternalMessageInfo
+
+func (m *Index) GetEntityType() string {
+        if m != nil && m.EntityType != nil {
+                return *m.EntityType
+        }
+        return ""
+}
+
+func (m *Index) GetAncestor() bool {
+        if m != nil && m.Ancestor != nil {
+                return *m.Ancestor
+        }
+        return false
+}
+
+func (m *Index) GetProperty() []*Index_Property {
+        if m != nil {
+                return m.Property
+        }
+        return nil
+}
+
+type Index_Property struct {
+        Name                 *string                   `protobuf:"bytes,3,req,name=name" json:"name,omitempty"`
+        Direction            *Index_Property_Direction `protobuf:"varint,4,opt,name=direction,enum=appengine.Index_Property_Direction,def=1" json:"direction,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
+        XXX_unrecognized     []byte                    `json:"-"`
+        XXX_sizecache        int32                     `json:"-"`
+}
+
+func (m *Index_Property) Reset()         { *m = Index_Property{} }
+func (m *Index_Property) String() string { return proto.CompactTextString(m) }
+func (*Index_Property) ProtoMessage()    {}
+func (*Index_Property) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{8, 0}
+}
+func (m *Index_Property) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Index_Property.Unmarshal(m, b)
+}
+func (m *Index_Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Index_Property.Marshal(b, m, deterministic)
+}
+func (dst *Index_Property) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Index_Property.Merge(dst, src)
+}
+func (m *Index_Property) XXX_Size() int {
+        return xxx_messageInfo_Index_Property.Size(m)
+}
+func (m *Index_Property) XXX_DiscardUnknown() {
+        xxx_messageInfo_Index_Property.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Index_Property proto.InternalMessageInfo
+
+const Default_Index_Property_Direction Index_Property_Direction = Index_Property_ASCENDING
+
+func (m *Index_Property) GetName() string {
+        if m != nil && m.Name != nil {
+                return *m.Name
+        }
+        return ""
+}
+
+func (m *Index_Property) GetDirection() Index_Property_Direction {
+        if m != nil && m.Direction != nil {
+                return *m.Direction
+        }
+        return Default_Index_Property_Direction
+}
+
+type CompositeIndex struct {
+        AppId                *string               `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
+        Id                   *int64                `protobuf:"varint,2,req,name=id" json:"id,omitempty"`
+        Definition           *Index                `protobuf:"bytes,3,req,name=definition" json:"definition,omitempty"`
+        State                *CompositeIndex_State `protobuf:"varint,4,req,name=state,enum=appengine.CompositeIndex_State" json:"state,omitempty"`
+        OnlyUseIfRequired    *bool                 `protobuf:"varint,6,opt,name=only_use_if_required,json=onlyUseIfRequired,def=0" json:"only_use_if_required,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}              `json:"-"`
+        XXX_unrecognized     []byte                `json:"-"`
+        XXX_sizecache        int32                 `json:"-"`
+}
+
+func (m *CompositeIndex) Reset()         { *m = CompositeIndex{} }
+func (m *CompositeIndex) String() string { return proto.CompactTextString(m) }
+func (*CompositeIndex) ProtoMessage()    {}
+func (*CompositeIndex) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{9}
+}
+func (m *CompositeIndex) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompositeIndex.Unmarshal(m, b)
+}
+func (m *CompositeIndex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompositeIndex.Marshal(b, m, deterministic)
+}
+func (dst *CompositeIndex) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompositeIndex.Merge(dst, src)
+}
+func (m *CompositeIndex) XXX_Size() int {
+        return xxx_messageInfo_CompositeIndex.Size(m)
+}
+func (m *CompositeIndex) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompositeIndex.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompositeIndex proto.InternalMessageInfo
+
+const Default_CompositeIndex_OnlyUseIfRequired bool = false
+
+func (m *CompositeIndex) GetAppId() string {
+        if m != nil && m.AppId != nil {
+                return *m.AppId
+        }
+        return ""
+}
+
+func (m *CompositeIndex) GetId() int64 {
+        if m != nil && m.Id != nil {
+                return *m.Id
+        }
+        return 0
+}
+
+func (m *CompositeIndex) GetDefinition() *Index {
+        if m != nil {
+                return m.Definition
+        }
+        return nil
+}
+
+func (m *CompositeIndex) GetState() CompositeIndex_State {
+        if m != nil && m.State != nil {
+                return *m.State
+        }
+        return CompositeIndex_WRITE_ONLY
+}
+
+func (m *CompositeIndex) GetOnlyUseIfRequired() bool {
+        if m != nil && m.OnlyUseIfRequired != nil {
+                return *m.OnlyUseIfRequired
+        }
+        return Default_CompositeIndex_OnlyUseIfRequired
+}
+
+type IndexPostfix struct {
+        IndexValue           []*IndexPostfix_IndexValue `protobuf:"bytes,1,rep,name=index_value,json=indexValue" json:"index_value,omitempty"`
+        Key                  *Reference                 `protobuf:"bytes,2,opt,name=key" json:"key,omitempty"`
+        Before               *bool                      `protobuf:"varint,3,opt,name=before,def=1" json:"before,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
+        XXX_unrecognized     []byte                     `json:"-"`
+        XXX_sizecache        int32                      `json:"-"`
+}
+
+func (m *IndexPostfix) Reset()         { *m = IndexPostfix{} }
+func (m *IndexPostfix) String() string { return proto.CompactTextString(m) }
+func (*IndexPostfix) ProtoMessage()    {}
+func (*IndexPostfix) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{10}
+}
+func (m *IndexPostfix) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_IndexPostfix.Unmarshal(m, b)
+}
+func (m *IndexPostfix) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_IndexPostfix.Marshal(b, m, deterministic)
+}
+func (dst *IndexPostfix) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_IndexPostfix.Merge(dst, src)
+}
+func (m *IndexPostfix) XXX_Size() int {
+        return xxx_messageInfo_IndexPostfix.Size(m)
+}
+func (m *IndexPostfix) XXX_DiscardUnknown() {
+        xxx_messageInfo_IndexPostfix.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IndexPostfix proto.InternalMessageInfo
+
+const Default_IndexPostfix_Before bool = true
+
+func (m *IndexPostfix) GetIndexValue() []*IndexPostfix_IndexValue {
+        if m != nil {
+                return m.IndexValue
+        }
+        return nil
+}
+
+func (m *IndexPostfix) GetKey() *Reference {
+        if m != nil {
+                return m.Key
+        }
+        return nil
+}
+
+func (m *IndexPostfix) GetBefore() bool {
+        if m != nil && m.Before != nil {
+                return *m.Before
+        }
+        return Default_IndexPostfix_Before
+}
+
+type IndexPostfix_IndexValue struct {
+        PropertyName         *string        `protobuf:"bytes,1,req,name=property_name,json=propertyName" json:"property_name,omitempty"`
+        Value                *PropertyValue `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}       `json:"-"`
+        XXX_unrecognized     []byte         `json:"-"`
+        XXX_sizecache        int32          `json:"-"`
+}
+
+func (m *IndexPostfix_IndexValue) Reset()         { *m = IndexPostfix_IndexValue{} }
+func (m *IndexPostfix_IndexValue) String() string { return proto.CompactTextString(m) }
+func (*IndexPostfix_IndexValue) ProtoMessage()    {}
+func (*IndexPostfix_IndexValue) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{10, 0}
+}
+func (m *IndexPostfix_IndexValue) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_IndexPostfix_IndexValue.Unmarshal(m, b)
+}
+func (m *IndexPostfix_IndexValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_IndexPostfix_IndexValue.Marshal(b, m, deterministic)
+}
+func (dst *IndexPostfix_IndexValue) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_IndexPostfix_IndexValue.Merge(dst, src)
+}
+func (m *IndexPostfix_IndexValue) XXX_Size() int {
+        return xxx_messageInfo_IndexPostfix_IndexValue.Size(m)
+}
+func (m *IndexPostfix_IndexValue) XXX_DiscardUnknown() {
+        xxx_messageInfo_IndexPostfix_IndexValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IndexPostfix_IndexValue proto.InternalMessageInfo
+
+func (m *IndexPostfix_IndexValue) GetPropertyName() string {
+        if m != nil && m.PropertyName != nil {
+                return *m.PropertyName
+        }
+        return ""
+}
+
+func (m *IndexPostfix_IndexValue) GetValue() *PropertyValue {
+        if m != nil {
+                return m.Value
+        }
+        return nil
+}
+
+type IndexPosition struct {
+        Key                  *string  `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
+        Before               *bool    `protobuf:"varint,2,opt,name=before,def=1" json:"before,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *IndexPosition) Reset()         { *m = IndexPosition{} }
+func (m *IndexPosition) String() string { return proto.CompactTextString(m) }
+func (*IndexPosition) ProtoMessage()    {}
+func (*IndexPosition) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{11}
+}
+func (m *IndexPosition) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_IndexPosition.Unmarshal(m, b)
+}
+func (m *IndexPosition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_IndexPosition.Marshal(b, m, deterministic)
+}
+func (dst *IndexPosition) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_IndexPosition.Merge(dst, src)
+}
+func (m *IndexPosition) XXX_Size() int {
+        return xxx_messageInfo_IndexPosition.Size(m)
+}
+func (m *IndexPosition) XXX_DiscardUnknown() {
+        xxx_messageInfo_IndexPosition.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IndexPosition proto.InternalMessageInfo
+
+const Default_IndexPosition_Before bool = true
+
+func (m *IndexPosition) GetKey() string {
+        if m != nil && m.Key != nil {
+                return *m.Key
+        }
+        return ""
+}
+
+func (m *IndexPosition) GetBefore() bool {
+        if m != nil && m.Before != nil {
+                return *m.Before
+        }
+        return Default_IndexPosition_Before
+}
+
+type Snapshot struct {
+        Ts                   *int64   `protobuf:"varint,1,req,name=ts" json:"ts,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Snapshot) Reset()         { *m = Snapshot{} }
+func (m *Snapshot) String() string { return proto.CompactTextString(m) }
+func (*Snapshot) ProtoMessage()    {}
+func (*Snapshot) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{12}
+}
+func (m *Snapshot) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Snapshot.Unmarshal(m, b)
+}
+func (m *Snapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Snapshot.Marshal(b, m, deterministic)
+}
+func (dst *Snapshot) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Snapshot.Merge(dst, src)
+}
+func (m *Snapshot) XXX_Size() int {
+        return xxx_messageInfo_Snapshot.Size(m)
+}
+func (m *Snapshot) XXX_DiscardUnknown() {
+        xxx_messageInfo_Snapshot.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Snapshot proto.InternalMessageInfo
+
+func (m *Snapshot) GetTs() int64 {
+        if m != nil && m.Ts != nil {
+                return *m.Ts
+        }
+        return 0
+}
+
+type InternalHeader struct {
+        Qos                  *string  `protobuf:"bytes,1,opt,name=qos" json:"qos,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *InternalHeader) Reset()         { *m = InternalHeader{} }
+func (m *InternalHeader) String() string { return proto.CompactTextString(m) }
+func (*InternalHeader) ProtoMessage()    {}
+func (*InternalHeader) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{13}
+}
+func (m *InternalHeader) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_InternalHeader.Unmarshal(m, b)
+}
+func (m *InternalHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_InternalHeader.Marshal(b, m, deterministic)
+}
+func (dst *InternalHeader) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_InternalHeader.Merge(dst, src)
+}
+func (m *InternalHeader) XXX_Size() int {
+        return xxx_messageInfo_InternalHeader.Size(m)
+}
+func (m *InternalHeader) XXX_DiscardUnknown() {
+        xxx_messageInfo_InternalHeader.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_InternalHeader proto.InternalMessageInfo
+
+func (m *InternalHeader) GetQos() string {
+        if m != nil && m.Qos != nil {
+                return *m.Qos
+        }
+        return ""
+}
+
+type Transaction struct {
+        Header               *InternalHeader `protobuf:"bytes,4,opt,name=header" json:"header,omitempty"`
+        Handle               *uint64         `protobuf:"fixed64,1,req,name=handle" json:"handle,omitempty"`
+        App                  *string         `protobuf:"bytes,2,req,name=app" json:"app,omitempty"`
+        MarkChanges          *bool           `protobuf:"varint,3,opt,name=mark_changes,json=markChanges,def=0" json:"mark_changes,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+        XXX_unrecognized     []byte          `json:"-"`
+        XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *Transaction) Reset()         { *m = Transaction{} }
+func (m *Transaction) String() string { return proto.CompactTextString(m) }
+func (*Transaction) ProtoMessage()    {}
+func (*Transaction) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{14}
+}
+func (m *Transaction) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Transaction.Unmarshal(m, b)
+}
+func (m *Transaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Transaction.Marshal(b, m, deterministic)
+}
+func (dst *Transaction) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Transaction.Merge(dst, src)
+}
+func (m *Transaction) XXX_Size() int {
+        return xxx_messageInfo_Transaction.Size(m)
+}
+func (m *Transaction) XXX_DiscardUnknown() {
+        xxx_messageInfo_Transaction.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Transaction proto.InternalMessageInfo
+
+const Default_Transaction_MarkChanges bool = false
+
+func (m *Transaction) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *Transaction) GetHandle() uint64 {
+        if m != nil && m.Handle != nil {
+                return *m.Handle
+        }
+        return 0
+}
+
+func (m *Transaction) GetApp() string {
+        if m != nil && m.App != nil {
+                return *m.App
+        }
+        return ""
+}
+
+func (m *Transaction) GetMarkChanges() bool {
+        if m != nil && m.MarkChanges != nil {
+                return *m.MarkChanges
+        }
+        return Default_Transaction_MarkChanges
+}
+
+type Query struct {
+        Header               *InternalHeader   `protobuf:"bytes,39,opt,name=header" json:"header,omitempty"`
+        App                  *string           `protobuf:"bytes,1,req,name=app" json:"app,omitempty"`
+        NameSpace            *string           `protobuf:"bytes,29,opt,name=name_space,json=nameSpace" json:"name_space,omitempty"`
+        Kind                 *string           `protobuf:"bytes,3,opt,name=kind" json:"kind,omitempty"`
+        Ancestor             *Reference        `protobuf:"bytes,17,opt,name=ancestor" json:"ancestor,omitempty"`
+        Filter               []*Query_Filter   `protobuf:"group,4,rep,name=Filter,json=filter" json:"filter,omitempty"`
+        SearchQuery          *string           `protobuf:"bytes,8,opt,name=search_query,json=searchQuery" json:"search_query,omitempty"`
+        Order                []*Query_Order    `protobuf:"group,9,rep,name=Order,json=order" json:"order,omitempty"`
+        Hint                 *Query_Hint       `protobuf:"varint,18,opt,name=hint,enum=appengine.Query_Hint" json:"hint,omitempty"`
+        Count                *int32            `protobuf:"varint,23,opt,name=count" json:"count,omitempty"`
+        Offset               *int32            `protobuf:"varint,12,opt,name=offset,def=0" json:"offset,omitempty"`
+        Limit                *int32            `protobuf:"varint,16,opt,name=limit" json:"limit,omitempty"`
+        CompiledCursor       *CompiledCursor   `protobuf:"bytes,30,opt,name=compiled_cursor,json=compiledCursor" json:"compiled_cursor,omitempty"`
+        EndCompiledCursor    *CompiledCursor   `protobuf:"bytes,31,opt,name=end_compiled_cursor,json=endCompiledCursor" json:"end_compiled_cursor,omitempty"`
+        CompositeIndex       []*CompositeIndex `protobuf:"bytes,19,rep,name=composite_index,json=compositeIndex" json:"composite_index,omitempty"`
+        RequirePerfectPlan   *bool             `protobuf:"varint,20,opt,name=require_perfect_plan,json=requirePerfectPlan,def=0" json:"require_perfect_plan,omitempty"`
+        KeysOnly             *bool             `protobuf:"varint,21,opt,name=keys_only,json=keysOnly,def=0" json:"keys_only,omitempty"`
+        Transaction          *Transaction      `protobuf:"bytes,22,opt,name=transaction" json:"transaction,omitempty"`
+        Compile              *bool             `protobuf:"varint,25,opt,name=compile,def=0" json:"compile,omitempty"`
+        FailoverMs           *int64            `protobuf:"varint,26,opt,name=failover_ms,json=failoverMs" json:"failover_ms,omitempty"`
+        Strong               *bool             `protobuf:"varint,32,opt,name=strong" json:"strong,omitempty"`
+        PropertyName         []string          `protobuf:"bytes,33,rep,name=property_name,json=propertyName" json:"property_name,omitempty"`
+        GroupByPropertyName  []string          `protobuf:"bytes,34,rep,name=group_by_property_name,json=groupByPropertyName" json:"group_by_property_name,omitempty"`
+        Distinct             *bool             `protobuf:"varint,24,opt,name=distinct" json:"distinct,omitempty"`
+        MinSafeTimeSeconds   *int64            `protobuf:"varint,35,opt,name=min_safe_time_seconds,json=minSafeTimeSeconds" json:"min_safe_time_seconds,omitempty"`
+        SafeReplicaName      []string          `protobuf:"bytes,36,rep,name=safe_replica_name,json=safeReplicaName" json:"safe_replica_name,omitempty"`
+        PersistOffset        *bool             `protobuf:"varint,37,opt,name=persist_offset,json=persistOffset,def=0" json:"persist_offset,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+        XXX_unrecognized     []byte            `json:"-"`
+        XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *Query) Reset()         { *m = Query{} }
+func (m *Query) String() string { return proto.CompactTextString(m) }
+func (*Query) ProtoMessage()    {}
+func (*Query) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15}
+}
+func (m *Query) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Query.Unmarshal(m, b)
+}
+func (m *Query) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Query.Marshal(b, m, deterministic)
+}
+func (dst *Query) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Query.Merge(dst, src)
+}
+func (m *Query) XXX_Size() int {
+        return xxx_messageInfo_Query.Size(m)
+}
+func (m *Query) XXX_DiscardUnknown() {
+        xxx_messageInfo_Query.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Query proto.InternalMessageInfo
+
+const Default_Query_Offset int32 = 0
+const Default_Query_RequirePerfectPlan bool = false
+const Default_Query_KeysOnly bool = false
+const Default_Query_Compile bool = false
+const Default_Query_PersistOffset bool = false
+
+func (m *Query) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *Query) GetApp() string {
+        if m != nil && m.App != nil {
+                return *m.App
+        }
+        return ""
+}
+
+func (m *Query) GetNameSpace() string {
+        if m != nil && m.NameSpace != nil {
+                return *m.NameSpace
+        }
+        return ""
+}
+
+func (m *Query) GetKind() string {
+        if m != nil && m.Kind != nil {
+                return *m.Kind
+        }
+        return ""
+}
+
+func (m *Query) GetAncestor() *Reference {
+        if m != nil {
+                return m.Ancestor
+        }
+        return nil
+}
+
+func (m *Query) GetFilter() []*Query_Filter {
+        if m != nil {
+                return m.Filter
+        }
+        return nil
+}
+
+func (m *Query) GetSearchQuery() string {
+        if m != nil && m.SearchQuery != nil {
+                return *m.SearchQuery
+        }
+        return ""
+}
+
+func (m *Query) GetOrder() []*Query_Order {
+        if m != nil {
+                return m.Order
+        }
+        return nil
+}
+
+func (m *Query) GetHint() Query_Hint {
+        if m != nil && m.Hint != nil {
+                return *m.Hint
+        }
+        return Query_ORDER_FIRST
+}
+
+func (m *Query) GetCount() int32 {
+        if m != nil && m.Count != nil {
+                return *m.Count
+        }
+        return 0
+}
+
+func (m *Query) GetOffset() int32 {
+        if m != nil && m.Offset != nil {
+                return *m.Offset
+        }
+        return Default_Query_Offset
+}
+
+func (m *Query) GetLimit() int32 {
+        if m != nil && m.Limit != nil {
+                return *m.Limit
+        }
+        return 0
+}
+
+func (m *Query) GetCompiledCursor() *CompiledCursor {
+        if m != nil {
+                return m.CompiledCursor
+        }
+        return nil
+}
+
+func (m *Query) GetEndCompiledCursor() *CompiledCursor {
+        if m != nil {
+                return m.EndCompiledCursor
+        }
+        return nil
+}
+
+func (m *Query) GetCompositeIndex() []*CompositeIndex {
+        if m != nil {
+                return m.CompositeIndex
+        }
+        return nil
+}
+
+func (m *Query) GetRequirePerfectPlan() bool {
+        if m != nil && m.RequirePerfectPlan != nil {
+                return *m.RequirePerfectPlan
+        }
+        return Default_Query_RequirePerfectPlan
+}
+
+func (m *Query) GetKeysOnly() bool {
+        if m != nil && m.KeysOnly != nil {
+                return *m.KeysOnly
+        }
+        return Default_Query_KeysOnly
+}
+
+func (m *Query) GetTransaction() *Transaction {
+        if m != nil {
+                return m.Transaction
+        }
+        return nil
+}
+
+func (m *Query) GetCompile() bool {
+        if m != nil && m.Compile != nil {
+                return *m.Compile
+        }
+        return Default_Query_Compile
+}
+
+func (m *Query) GetFailoverMs() int64 {
+        if m != nil && m.FailoverMs != nil {
+                return *m.FailoverMs
+        }
+        return 0
+}
+
+func (m *Query) GetStrong() bool {
+        if m != nil && m.Strong != nil {
+                return *m.Strong
+        }
+        return false
+}
+
+func (m *Query) GetPropertyName() []string {
+        if m != nil {
+                return m.PropertyName
+        }
+        return nil
+}
+
+func (m *Query) GetGroupByPropertyName() []string {
+        if m != nil {
+                return m.GroupByPropertyName
+        }
+        return nil
+}
+
+func (m *Query) GetDistinct() bool {
+        if m != nil && m.Distinct != nil {
+                return *m.Distinct
+        }
+        return false
+}
+
+func (m *Query) GetMinSafeTimeSeconds() int64 {
+        if m != nil && m.MinSafeTimeSeconds != nil {
+                return *m.MinSafeTimeSeconds
+        }
+        return 0
+}
+
+func (m *Query) GetSafeReplicaName() []string {
+        if m != nil {
+                return m.SafeReplicaName
+        }
+        return nil
+}
+
+func (m *Query) GetPersistOffset() bool {
+        if m != nil && m.PersistOffset != nil {
+                return *m.PersistOffset
+        }
+        return Default_Query_PersistOffset
+}
+
+type Query_Filter struct {
+        Op                   *Query_Filter_Operator `protobuf:"varint,6,req,name=op,enum=appengine.Query_Filter_Operator" json:"op,omitempty"`
+        Property             []*Property            `protobuf:"bytes,14,rep,name=property" json:"property,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}               `json:"-"`
+        XXX_unrecognized     []byte                 `json:"-"`
+        XXX_sizecache        int32                  `json:"-"`
+}
+
+func (m *Query_Filter) Reset()         { *m = Query_Filter{} }
+func (m *Query_Filter) String() string { return proto.CompactTextString(m) }
+func (*Query_Filter) ProtoMessage()    {}
+func (*Query_Filter) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 0}
+}
+func (m *Query_Filter) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Query_Filter.Unmarshal(m, b)
+}
+func (m *Query_Filter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Query_Filter.Marshal(b, m, deterministic)
+}
+func (dst *Query_Filter) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Query_Filter.Merge(dst, src)
+}
+func (m *Query_Filter) XXX_Size() int {
+        return xxx_messageInfo_Query_Filter.Size(m)
+}
+func (m *Query_Filter) XXX_DiscardUnknown() {
+        xxx_messageInfo_Query_Filter.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Query_Filter proto.InternalMessageInfo
+
+func (m *Query_Filter) GetOp() Query_Filter_Operator {
+        if m != nil && m.Op != nil {
+                return *m.Op
+        }
+        return Query_Filter_LESS_THAN
+}
+
+func (m *Query_Filter) GetProperty() []*Property {
+        if m != nil {
+                return m.Property
+        }
+        return nil
+}
+
+type Query_Order struct {
+        Property             *string                `protobuf:"bytes,10,req,name=property" json:"property,omitempty"`
+        Direction            *Query_Order_Direction `protobuf:"varint,11,opt,name=direction,enum=appengine.Query_Order_Direction,def=1" json:"direction,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}               `json:"-"`
+        XXX_unrecognized     []byte                 `json:"-"`
+        XXX_sizecache        int32                  `json:"-"`
+}
+
+func (m *Query_Order) Reset()         { *m = Query_Order{} }
+func (m *Query_Order) String() string { return proto.CompactTextString(m) }
+func (*Query_Order) ProtoMessage()    {}
+func (*Query_Order) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 1}
+}
+func (m *Query_Order) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Query_Order.Unmarshal(m, b)
+}
+func (m *Query_Order) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Query_Order.Marshal(b, m, deterministic)
+}
+func (dst *Query_Order) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Query_Order.Merge(dst, src)
+}
+func (m *Query_Order) XXX_Size() int {
+        return xxx_messageInfo_Query_Order.Size(m)
+}
+func (m *Query_Order) XXX_DiscardUnknown() {
+        xxx_messageInfo_Query_Order.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Query_Order proto.InternalMessageInfo
+
+const Default_Query_Order_Direction Query_Order_Direction = Query_Order_ASCENDING
+
+func (m *Query_Order) GetProperty() string {
+        if m != nil && m.Property != nil {
+                return *m.Property
+        }
+        return ""
+}
+
+func (m *Query_Order) GetDirection() Query_Order_Direction {
+        if m != nil && m.Direction != nil {
+                return *m.Direction
+        }
+        return Default_Query_Order_Direction
+}
+
+type CompiledQuery struct {
+        Primaryscan          *CompiledQuery_PrimaryScan     `protobuf:"group,1,req,name=PrimaryScan,json=primaryscan" json:"primaryscan,omitempty"`
+        Mergejoinscan        []*CompiledQuery_MergeJoinScan `protobuf:"group,7,rep,name=MergeJoinScan,json=mergejoinscan" json:"mergejoinscan,omitempty"`
+        IndexDef             *Index                         `protobuf:"bytes,21,opt,name=index_def,json=indexDef" json:"index_def,omitempty"`
+        Offset               *int32                         `protobuf:"varint,10,opt,name=offset,def=0" json:"offset,omitempty"`
+        Limit                *int32                         `protobuf:"varint,11,opt,name=limit" json:"limit,omitempty"`
+        KeysOnly             *bool                          `protobuf:"varint,12,req,name=keys_only,json=keysOnly" json:"keys_only,omitempty"`
+        PropertyName         []string                       `protobuf:"bytes,24,rep,name=property_name,json=propertyName" json:"property_name,omitempty"`
+        DistinctInfixSize    *int32                         `protobuf:"varint,25,opt,name=distinct_infix_size,json=distinctInfixSize" json:"distinct_infix_size,omitempty"`
+        Entityfilter         *CompiledQuery_EntityFilter    `protobuf:"group,13,opt,name=EntityFilter,json=entityfilter" json:"entityfilter,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                       `json:"-"`
+        XXX_unrecognized     []byte                         `json:"-"`
+        XXX_sizecache        int32                          `json:"-"`
+}
+
+func (m *CompiledQuery) Reset()         { *m = CompiledQuery{} }
+func (m *CompiledQuery) String() string { return proto.CompactTextString(m) }
+func (*CompiledQuery) ProtoMessage()    {}
+func (*CompiledQuery) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16}
+}
+func (m *CompiledQuery) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompiledQuery.Unmarshal(m, b)
+}
+func (m *CompiledQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompiledQuery.Marshal(b, m, deterministic)
+}
+func (dst *CompiledQuery) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompiledQuery.Merge(dst, src)
+}
+func (m *CompiledQuery) XXX_Size() int {
+        return xxx_messageInfo_CompiledQuery.Size(m)
+}
+func (m *CompiledQuery) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompiledQuery.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompiledQuery proto.InternalMessageInfo
+
+const Default_CompiledQuery_Offset int32 = 0
+
+func (m *CompiledQuery) GetPrimaryscan() *CompiledQuery_PrimaryScan {
+        if m != nil {
+                return m.Primaryscan
+        }
+        return nil
+}
+
+func (m *CompiledQuery) GetMergejoinscan() []*CompiledQuery_MergeJoinScan {
+        if m != nil {
+                return m.Mergejoinscan
+        }
+        return nil
+}
+
+func (m *CompiledQuery) GetIndexDef() *Index {
+        if m != nil {
+                return m.IndexDef
+        }
+        return nil
+}
+
+func (m *CompiledQuery) GetOffset() int32 {
+        if m != nil && m.Offset != nil {
+                return *m.Offset
+        }
+        return Default_CompiledQuery_Offset
+}
+
+func (m *CompiledQuery) GetLimit() int32 {
+        if m != nil && m.Limit != nil {
+                return *m.Limit
+        }
+        return 0
+}
+
+func (m *CompiledQuery) GetKeysOnly() bool {
+        if m != nil && m.KeysOnly != nil {
+                return *m.KeysOnly
+        }
+        return false
+}
+
+func (m *CompiledQuery) GetPropertyName() []string {
+        if m != nil {
+                return m.PropertyName
+        }
+        return nil
+}
+
+func (m *CompiledQuery) GetDistinctInfixSize() int32 {
+        if m != nil && m.DistinctInfixSize != nil {
+                return *m.DistinctInfixSize
+        }
+        return 0
+}
+
+func (m *CompiledQuery) GetEntityfilter() *CompiledQuery_EntityFilter {
+        if m != nil {
+                return m.Entityfilter
+        }
+        return nil
+}
+
+type CompiledQuery_PrimaryScan struct {
+        IndexName                  *string  `protobuf:"bytes,2,opt,name=index_name,json=indexName" json:"index_name,omitempty"`
+        StartKey                   *string  `protobuf:"bytes,3,opt,name=start_key,json=startKey" json:"start_key,omitempty"`
+        StartInclusive             *bool    `protobuf:"varint,4,opt,name=start_inclusive,json=startInclusive" json:"start_inclusive,omitempty"`
+        EndKey                     *string  `protobuf:"bytes,5,opt,name=end_key,json=endKey" json:"end_key,omitempty"`
+        EndInclusive               *bool    `protobuf:"varint,6,opt,name=end_inclusive,json=endInclusive" json:"end_inclusive,omitempty"`
+        StartPostfixValue          []string `protobuf:"bytes,22,rep,name=start_postfix_value,json=startPostfixValue" json:"start_postfix_value,omitempty"`
+        EndPostfixValue            []string `protobuf:"bytes,23,rep,name=end_postfix_value,json=endPostfixValue" json:"end_postfix_value,omitempty"`
+        EndUnappliedLogTimestampUs *int64   `protobuf:"varint,19,opt,name=end_unapplied_log_timestamp_us,json=endUnappliedLogTimestampUs" json:"end_unapplied_log_timestamp_us,omitempty"`
+        XXX_NoUnkeyedLiteral       struct{} `json:"-"`
+        XXX_unrecognized           []byte   `json:"-"`
+        XXX_sizecache              int32    `json:"-"`
+}
+
+func (m *CompiledQuery_PrimaryScan) Reset()         { *m = CompiledQuery_PrimaryScan{} }
+func (m *CompiledQuery_PrimaryScan) String() string { return proto.CompactTextString(m) }
+func (*CompiledQuery_PrimaryScan) ProtoMessage()    {}
+func (*CompiledQuery_PrimaryScan) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16, 0}
+}
+func (m *CompiledQuery_PrimaryScan) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompiledQuery_PrimaryScan.Unmarshal(m, b)
+}
+func (m *CompiledQuery_PrimaryScan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompiledQuery_PrimaryScan.Marshal(b, m, deterministic)
+}
+func (dst *CompiledQuery_PrimaryScan) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompiledQuery_PrimaryScan.Merge(dst, src)
+}
+func (m *CompiledQuery_PrimaryScan) XXX_Size() int {
+        return xxx_messageInfo_CompiledQuery_PrimaryScan.Size(m)
+}
+func (m *CompiledQuery_PrimaryScan) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompiledQuery_PrimaryScan.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompiledQuery_PrimaryScan proto.InternalMessageInfo
+
+func (m *CompiledQuery_PrimaryScan) GetIndexName() string {
+        if m != nil && m.IndexName != nil {
+                return *m.IndexName
+        }
+        return ""
+}
+
+func (m *CompiledQuery_PrimaryScan) GetStartKey() string {
+        if m != nil && m.StartKey != nil {
+                return *m.StartKey
+        }
+        return ""
+}
+
+func (m *CompiledQuery_PrimaryScan) GetStartInclusive() bool {
+        if m != nil && m.StartInclusive != nil {
+                return *m.StartInclusive
+        }
+        return false
+}
+
+func (m *CompiledQuery_PrimaryScan) GetEndKey() string {
+        if m != nil && m.EndKey != nil {
+                return *m.EndKey
+        }
+        return ""
+}
+
+func (m *CompiledQuery_PrimaryScan) GetEndInclusive() bool {
+        if m != nil && m.EndInclusive != nil {
+                return *m.EndInclusive
+        }
+        return false
+}
+
+func (m *CompiledQuery_PrimaryScan) GetStartPostfixValue() []string {
+        if m != nil {
+                return m.StartPostfixValue
+        }
+        return nil
+}
+
+func (m *CompiledQuery_PrimaryScan) GetEndPostfixValue() []string {
+        if m != nil {
+                return m.EndPostfixValue
+        }
+        return nil
+}
+
+func (m *CompiledQuery_PrimaryScan) GetEndUnappliedLogTimestampUs() int64 {
+        if m != nil && m.EndUnappliedLogTimestampUs != nil {
+                return *m.EndUnappliedLogTimestampUs
+        }
+        return 0
+}
+
+type CompiledQuery_MergeJoinScan struct {
+        IndexName            *string  `protobuf:"bytes,8,req,name=index_name,json=indexName" json:"index_name,omitempty"`
+        PrefixValue          []string `protobuf:"bytes,9,rep,name=prefix_value,json=prefixValue" json:"prefix_value,omitempty"`
+        ValuePrefix          *bool    `protobuf:"varint,20,opt,name=value_prefix,json=valuePrefix,def=0" json:"value_prefix,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *CompiledQuery_MergeJoinScan) Reset()         { *m = CompiledQuery_MergeJoinScan{} }
+func (m *CompiledQuery_MergeJoinScan) String() string { return proto.CompactTextString(m) }
+func (*CompiledQuery_MergeJoinScan) ProtoMessage()    {}
+func (*CompiledQuery_MergeJoinScan) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16, 1}
+}
+func (m *CompiledQuery_MergeJoinScan) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompiledQuery_MergeJoinScan.Unmarshal(m, b)
+}
+func (m *CompiledQuery_MergeJoinScan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompiledQuery_MergeJoinScan.Marshal(b, m, deterministic)
+}
+func (dst *CompiledQuery_MergeJoinScan) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompiledQuery_MergeJoinScan.Merge(dst, src)
+}
+func (m *CompiledQuery_MergeJoinScan) XXX_Size() int {
+        return xxx_messageInfo_CompiledQuery_MergeJoinScan.Size(m)
+}
+func (m *CompiledQuery_MergeJoinScan) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompiledQuery_MergeJoinScan.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompiledQuery_MergeJoinScan proto.InternalMessageInfo
+
+const Default_CompiledQuery_MergeJoinScan_ValuePrefix bool = false
+
+func (m *CompiledQuery_MergeJoinScan) GetIndexName() string {
+        if m != nil && m.IndexName != nil {
+                return *m.IndexName
+        }
+        return ""
+}
+
+func (m *CompiledQuery_MergeJoinScan) GetPrefixValue() []string {
+        if m != nil {
+                return m.PrefixValue
+        }
+        return nil
+}
+
+func (m *CompiledQuery_MergeJoinScan) GetValuePrefix() bool {
+        if m != nil && m.ValuePrefix != nil {
+                return *m.ValuePrefix
+        }
+        return Default_CompiledQuery_MergeJoinScan_ValuePrefix
+}
+
+type CompiledQuery_EntityFilter struct {
+        Distinct             *bool      `protobuf:"varint,14,opt,name=distinct,def=0" json:"distinct,omitempty"`
+        Kind                 *string    `protobuf:"bytes,17,opt,name=kind" json:"kind,omitempty"`
+        Ancestor             *Reference `protobuf:"bytes,18,opt,name=ancestor" json:"ancestor,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}   `json:"-"`
+        XXX_unrecognized     []byte     `json:"-"`
+        XXX_sizecache        int32      `json:"-"`
+}
+
+func (m *CompiledQuery_EntityFilter) Reset()         { *m = CompiledQuery_EntityFilter{} }
+func (m *CompiledQuery_EntityFilter) String() string { return proto.CompactTextString(m) }
+func (*CompiledQuery_EntityFilter) ProtoMessage()    {}
+func (*CompiledQuery_EntityFilter) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16, 2}
+}
+func (m *CompiledQuery_EntityFilter) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompiledQuery_EntityFilter.Unmarshal(m, b)
+}
+func (m *CompiledQuery_EntityFilter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompiledQuery_EntityFilter.Marshal(b, m, deterministic)
+}
+func (dst *CompiledQuery_EntityFilter) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompiledQuery_EntityFilter.Merge(dst, src)
+}
+func (m *CompiledQuery_EntityFilter) XXX_Size() int {
+        return xxx_messageInfo_CompiledQuery_EntityFilter.Size(m)
+}
+func (m *CompiledQuery_EntityFilter) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompiledQuery_EntityFilter.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompiledQuery_EntityFilter proto.InternalMessageInfo
+
+const Default_CompiledQuery_EntityFilter_Distinct bool = false
+
+func (m *CompiledQuery_EntityFilter) GetDistinct() bool {
+        if m != nil && m.Distinct != nil {
+                return *m.Distinct
+        }
+        return Default_CompiledQuery_EntityFilter_Distinct
+}
+
+func (m *CompiledQuery_EntityFilter) GetKind() string {
+        if m != nil && m.Kind != nil {
+                return *m.Kind
+        }
+        return ""
+}
+
+func (m *CompiledQuery_EntityFilter) GetAncestor() *Reference {
+        if m != nil {
+                return m.Ancestor
+        }
+        return nil
+}
+
+type CompiledCursor struct {
+        Position             *CompiledCursor_Position `protobuf:"group,2,opt,name=Position,json=position" json:"position,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
+        XXX_unrecognized     []byte                   `json:"-"`
+        XXX_sizecache        int32                    `json:"-"`
+}
+
+func (m *CompiledCursor) Reset()         { *m = CompiledCursor{} }
+func (m *CompiledCursor) String() string { return proto.CompactTextString(m) }
+func (*CompiledCursor) ProtoMessage()    {}
+func (*CompiledCursor) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{17}
+}
+func (m *CompiledCursor) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompiledCursor.Unmarshal(m, b)
+}
+func (m *CompiledCursor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompiledCursor.Marshal(b, m, deterministic)
+}
+func (dst *CompiledCursor) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompiledCursor.Merge(dst, src)
+}
+func (m *CompiledCursor) XXX_Size() int {
+        return xxx_messageInfo_CompiledCursor.Size(m)
+}
+func (m *CompiledCursor) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompiledCursor.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompiledCursor proto.InternalMessageInfo
+
+func (m *CompiledCursor) GetPosition() *CompiledCursor_Position {
+        if m != nil {
+                return m.Position
+        }
+        return nil
+}
+
+type CompiledCursor_Position struct {
+        StartKey             *string                               `protobuf:"bytes,27,opt,name=start_key,json=startKey" json:"start_key,omitempty"`
+        Indexvalue           []*CompiledCursor_Position_IndexValue `protobuf:"group,29,rep,name=IndexValue,json=indexvalue" json:"indexvalue,omitempty"`
+        Key                  *Reference                            `protobuf:"bytes,32,opt,name=key" json:"key,omitempty"`
+        StartInclusive       *bool                                 `protobuf:"varint,28,opt,name=start_inclusive,json=startInclusive,def=1" json:"start_inclusive,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                              `json:"-"`
+        XXX_unrecognized     []byte                                `json:"-"`
+        XXX_sizecache        int32                                 `json:"-"`
+}
+
+func (m *CompiledCursor_Position) Reset()         { *m = CompiledCursor_Position{} }
+func (m *CompiledCursor_Position) String() string { return proto.CompactTextString(m) }
+func (*CompiledCursor_Position) ProtoMessage()    {}
+func (*CompiledCursor_Position) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{17, 0}
+}
+func (m *CompiledCursor_Position) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompiledCursor_Position.Unmarshal(m, b)
+}
+func (m *CompiledCursor_Position) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompiledCursor_Position.Marshal(b, m, deterministic)
+}
+func (dst *CompiledCursor_Position) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompiledCursor_Position.Merge(dst, src)
+}
+func (m *CompiledCursor_Position) XXX_Size() int {
+        return xxx_messageInfo_CompiledCursor_Position.Size(m)
+}
+func (m *CompiledCursor_Position) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompiledCursor_Position.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompiledCursor_Position proto.InternalMessageInfo
+
+const Default_CompiledCursor_Position_StartInclusive bool = true
+
+func (m *CompiledCursor_Position) GetStartKey() string {
+        if m != nil && m.StartKey != nil {
+                return *m.StartKey
+        }
+        return ""
+}
+
+func (m *CompiledCursor_Position) GetIndexvalue() []*CompiledCursor_Position_IndexValue {
+        if m != nil {
+                return m.Indexvalue
+        }
+        return nil
+}
+
+func (m *CompiledCursor_Position) GetKey() *Reference {
+        if m != nil {
+                return m.Key
+        }
+        return nil
+}
+
+func (m *CompiledCursor_Position) GetStartInclusive() bool {
+        if m != nil && m.StartInclusive != nil {
+                return *m.StartInclusive
+        }
+        return Default_CompiledCursor_Position_StartInclusive
+}
+
+type CompiledCursor_Position_IndexValue struct {
+        Property             *string        `protobuf:"bytes,30,opt,name=property" json:"property,omitempty"`
+        Value                *PropertyValue `protobuf:"bytes,31,req,name=value" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}       `json:"-"`
+        XXX_unrecognized     []byte         `json:"-"`
+        XXX_sizecache        int32          `json:"-"`
+}
+
+func (m *CompiledCursor_Position_IndexValue) Reset()         { *m = CompiledCursor_Position_IndexValue{} }
+func (m *CompiledCursor_Position_IndexValue) String() string { return proto.CompactTextString(m) }
+func (*CompiledCursor_Position_IndexValue) ProtoMessage()    {}
+func (*CompiledCursor_Position_IndexValue) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{17, 0, 0}
+}
+func (m *CompiledCursor_Position_IndexValue) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompiledCursor_Position_IndexValue.Unmarshal(m, b)
+}
+func (m *CompiledCursor_Position_IndexValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompiledCursor_Position_IndexValue.Marshal(b, m, deterministic)
+}
+func (dst *CompiledCursor_Position_IndexValue) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompiledCursor_Position_IndexValue.Merge(dst, src)
+}
+func (m *CompiledCursor_Position_IndexValue) XXX_Size() int {
+        return xxx_messageInfo_CompiledCursor_Position_IndexValue.Size(m)
+}
+func (m *CompiledCursor_Position_IndexValue) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompiledCursor_Position_IndexValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompiledCursor_Position_IndexValue proto.InternalMessageInfo
+
+func (m *CompiledCursor_Position_IndexValue) GetProperty() string {
+        if m != nil && m.Property != nil {
+                return *m.Property
+        }
+        return ""
+}
+
+func (m *CompiledCursor_Position_IndexValue) GetValue() *PropertyValue {
+        if m != nil {
+                return m.Value
+        }
+        return nil
+}
+
+type Cursor struct {
+        Cursor               *uint64  `protobuf:"fixed64,1,req,name=cursor" json:"cursor,omitempty"`
+        App                  *string  `protobuf:"bytes,2,opt,name=app" json:"app,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Cursor) Reset()         { *m = Cursor{} }
+func (m *Cursor) String() string { return proto.CompactTextString(m) }
+func (*Cursor) ProtoMessage()    {}
+func (*Cursor) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{18}
+}
+func (m *Cursor) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Cursor.Unmarshal(m, b)
+}
+func (m *Cursor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Cursor.Marshal(b, m, deterministic)
+}
+func (dst *Cursor) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Cursor.Merge(dst, src)
+}
+func (m *Cursor) XXX_Size() int {
+        return xxx_messageInfo_Cursor.Size(m)
+}
+func (m *Cursor) XXX_DiscardUnknown() {
+        xxx_messageInfo_Cursor.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Cursor proto.InternalMessageInfo
+
+func (m *Cursor) GetCursor() uint64 {
+        if m != nil && m.Cursor != nil {
+                return *m.Cursor
+        }
+        return 0
+}
+
+func (m *Cursor) GetApp() string {
+        if m != nil && m.App != nil {
+                return *m.App
+        }
+        return ""
+}
+
+type Error struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Error) Reset()         { *m = Error{} }
+func (m *Error) String() string { return proto.CompactTextString(m) }
+func (*Error) ProtoMessage()    {}
+func (*Error) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{19}
+}
+func (m *Error) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Error.Unmarshal(m, b)
+}
+func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Error.Marshal(b, m, deterministic)
+}
+func (dst *Error) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Error.Merge(dst, src)
+}
+func (m *Error) XXX_Size() int {
+        return xxx_messageInfo_Error.Size(m)
+}
+func (m *Error) XXX_DiscardUnknown() {
+        xxx_messageInfo_Error.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Error proto.InternalMessageInfo
+
+type Cost struct {
+        IndexWrites             *int32           `protobuf:"varint,1,opt,name=index_writes,json=indexWrites" json:"index_writes,omitempty"`
+        IndexWriteBytes         *int32           `protobuf:"varint,2,opt,name=index_write_bytes,json=indexWriteBytes" json:"index_write_bytes,omitempty"`
+        EntityWrites            *int32           `protobuf:"varint,3,opt,name=entity_writes,json=entityWrites" json:"entity_writes,omitempty"`
+        EntityWriteBytes        *int32           `protobuf:"varint,4,opt,name=entity_write_bytes,json=entityWriteBytes" json:"entity_write_bytes,omitempty"`
+        Commitcost              *Cost_CommitCost `protobuf:"group,5,opt,name=CommitCost,json=commitcost" json:"commitcost,omitempty"`
+        ApproximateStorageDelta *int32           `protobuf:"varint,8,opt,name=approximate_storage_delta,json=approximateStorageDelta" json:"approximate_storage_delta,omitempty"`
+        IdSequenceUpdates       *int32           `protobuf:"varint,9,opt,name=id_sequence_updates,json=idSequenceUpdates" json:"id_sequence_updates,omitempty"`
+        XXX_NoUnkeyedLiteral    struct{}         `json:"-"`
+        XXX_unrecognized        []byte           `json:"-"`
+        XXX_sizecache           int32            `json:"-"`
+}
+
+func (m *Cost) Reset()         { *m = Cost{} }
+func (m *Cost) String() string { return proto.CompactTextString(m) }
+func (*Cost) ProtoMessage()    {}
+func (*Cost) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{20}
+}
+func (m *Cost) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Cost.Unmarshal(m, b)
+}
+func (m *Cost) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Cost.Marshal(b, m, deterministic)
+}
+func (dst *Cost) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Cost.Merge(dst, src)
+}
+func (m *Cost) XXX_Size() int {
+        return xxx_messageInfo_Cost.Size(m)
+}
+func (m *Cost) XXX_DiscardUnknown() {
+        xxx_messageInfo_Cost.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Cost proto.InternalMessageInfo
+
+func (m *Cost) GetIndexWrites() int32 {
+        if m != nil && m.IndexWrites != nil {
+                return *m.IndexWrites
+        }
+        return 0
+}
+
+func (m *Cost) GetIndexWriteBytes() int32 {
+        if m != nil && m.IndexWriteBytes != nil {
+                return *m.IndexWriteBytes
+        }
+        return 0
+}
+
+func (m *Cost) GetEntityWrites() int32 {
+        if m != nil && m.EntityWrites != nil {
+                return *m.EntityWrites
+        }
+        return 0
+}
+
+func (m *Cost) GetEntityWriteBytes() int32 {
+        if m != nil && m.EntityWriteBytes != nil {
+                return *m.EntityWriteBytes
+        }
+        return 0
+}
+
+func (m *Cost) GetCommitcost() *Cost_CommitCost {
+        if m != nil {
+                return m.Commitcost
+        }
+        return nil
+}
+
+func (m *Cost) GetApproximateStorageDelta() int32 {
+        if m != nil && m.ApproximateStorageDelta != nil {
+                return *m.ApproximateStorageDelta
+        }
+        return 0
+}
+
+func (m *Cost) GetIdSequenceUpdates() int32 {
+        if m != nil && m.IdSequenceUpdates != nil {
+                return *m.IdSequenceUpdates
+        }
+        return 0
+}
+
+type Cost_CommitCost struct {
+        RequestedEntityPuts    *int32   `protobuf:"varint,6,opt,name=requested_entity_puts,json=requestedEntityPuts" json:"requested_entity_puts,omitempty"`
+        RequestedEntityDeletes *int32   `protobuf:"varint,7,opt,name=requested_entity_deletes,json=requestedEntityDeletes" json:"requested_entity_deletes,omitempty"`
+        XXX_NoUnkeyedLiteral   struct{} `json:"-"`
+        XXX_unrecognized       []byte   `json:"-"`
+        XXX_sizecache          int32    `json:"-"`
+}
+
+func (m *Cost_CommitCost) Reset()         { *m = Cost_CommitCost{} }
+func (m *Cost_CommitCost) String() string { return proto.CompactTextString(m) }
+func (*Cost_CommitCost) ProtoMessage()    {}
+func (*Cost_CommitCost) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{20, 0}
+}
+func (m *Cost_CommitCost) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Cost_CommitCost.Unmarshal(m, b)
+}
+func (m *Cost_CommitCost) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Cost_CommitCost.Marshal(b, m, deterministic)
+}
+func (dst *Cost_CommitCost) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Cost_CommitCost.Merge(dst, src)
+}
+func (m *Cost_CommitCost) XXX_Size() int {
+        return xxx_messageInfo_Cost_CommitCost.Size(m)
+}
+func (m *Cost_CommitCost) XXX_DiscardUnknown() {
+        xxx_messageInfo_Cost_CommitCost.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Cost_CommitCost proto.InternalMessageInfo
+
+func (m *Cost_CommitCost) GetRequestedEntityPuts() int32 {
+        if m != nil && m.RequestedEntityPuts != nil {
+                return *m.RequestedEntityPuts
+        }
+        return 0
+}
+
+func (m *Cost_CommitCost) GetRequestedEntityDeletes() int32 {
+        if m != nil && m.RequestedEntityDeletes != nil {
+                return *m.RequestedEntityDeletes
+        }
+        return 0
+}
+
+type GetRequest struct {
+        Header               *InternalHeader `protobuf:"bytes,6,opt,name=header" json:"header,omitempty"`
+        Key                  []*Reference    `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
+        Transaction          *Transaction    `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"`
+        FailoverMs           *int64          `protobuf:"varint,3,opt,name=failover_ms,json=failoverMs" json:"failover_ms,omitempty"`
+        Strong               *bool           `protobuf:"varint,4,opt,name=strong" json:"strong,omitempty"`
+        AllowDeferred        *bool           `protobuf:"varint,5,opt,name=allow_deferred,json=allowDeferred,def=0" json:"allow_deferred,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+        XXX_unrecognized     []byte          `json:"-"`
+        XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *GetRequest) Reset()         { *m = GetRequest{} }
+func (m *GetRequest) String() string { return proto.CompactTextString(m) }
+func (*GetRequest) ProtoMessage()    {}
+func (*GetRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{21}
+}
+func (m *GetRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetRequest.Unmarshal(m, b)
+}
+func (m *GetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetRequest.Merge(dst, src)
+}
+func (m *GetRequest) XXX_Size() int {
+        return xxx_messageInfo_GetRequest.Size(m)
+}
+func (m *GetRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetRequest proto.InternalMessageInfo
+
+const Default_GetRequest_AllowDeferred bool = false
+
+func (m *GetRequest) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *GetRequest) GetKey() []*Reference {
+        if m != nil {
+                return m.Key
+        }
+        return nil
+}
+
+func (m *GetRequest) GetTransaction() *Transaction {
+        if m != nil {
+                return m.Transaction
+        }
+        return nil
+}
+
+func (m *GetRequest) GetFailoverMs() int64 {
+        if m != nil && m.FailoverMs != nil {
+                return *m.FailoverMs
+        }
+        return 0
+}
+
+func (m *GetRequest) GetStrong() bool {
+        if m != nil && m.Strong != nil {
+                return *m.Strong
+        }
+        return false
+}
+
+func (m *GetRequest) GetAllowDeferred() bool {
+        if m != nil && m.AllowDeferred != nil {
+                return *m.AllowDeferred
+        }
+        return Default_GetRequest_AllowDeferred
+}
+
+type GetResponse struct {
+        Entity               []*GetResponse_Entity `protobuf:"group,1,rep,name=Entity,json=entity" json:"entity,omitempty"`
+        Deferred             []*Reference          `protobuf:"bytes,5,rep,name=deferred" json:"deferred,omitempty"`
+        InOrder              *bool                 `protobuf:"varint,6,opt,name=in_order,json=inOrder,def=1" json:"in_order,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}              `json:"-"`
+        XXX_unrecognized     []byte                `json:"-"`
+        XXX_sizecache        int32                 `json:"-"`
+}
+
+func (m *GetResponse) Reset()         { *m = GetResponse{} }
+func (m *GetResponse) String() string { return proto.CompactTextString(m) }
+func (*GetResponse) ProtoMessage()    {}
+func (*GetResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{22}
+}
+func (m *GetResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetResponse.Unmarshal(m, b)
+}
+func (m *GetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetResponse.Merge(dst, src)
+}
+func (m *GetResponse) XXX_Size() int {
+        return xxx_messageInfo_GetResponse.Size(m)
+}
+func (m *GetResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetResponse proto.InternalMessageInfo
+
+const Default_GetResponse_InOrder bool = true
+
+func (m *GetResponse) GetEntity() []*GetResponse_Entity {
+        if m != nil {
+                return m.Entity
+        }
+        return nil
+}
+
+func (m *GetResponse) GetDeferred() []*Reference {
+        if m != nil {
+                return m.Deferred
+        }
+        return nil
+}
+
+func (m *GetResponse) GetInOrder() bool {
+        if m != nil && m.InOrder != nil {
+                return *m.InOrder
+        }
+        return Default_GetResponse_InOrder
+}
+
+type GetResponse_Entity struct {
+        Entity               *EntityProto `protobuf:"bytes,2,opt,name=entity" json:"entity,omitempty"`
+        Key                  *Reference   `protobuf:"bytes,4,opt,name=key" json:"key,omitempty"`
+        Version              *int64       `protobuf:"varint,3,opt,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}     `json:"-"`
+        XXX_unrecognized     []byte       `json:"-"`
+        XXX_sizecache        int32        `json:"-"`
+}
+
+func (m *GetResponse_Entity) Reset()         { *m = GetResponse_Entity{} }
+func (m *GetResponse_Entity) String() string { return proto.CompactTextString(m) }
+func (*GetResponse_Entity) ProtoMessage()    {}
+func (*GetResponse_Entity) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{22, 0}
+}
+func (m *GetResponse_Entity) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetResponse_Entity.Unmarshal(m, b)
+}
+func (m *GetResponse_Entity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetResponse_Entity.Marshal(b, m, deterministic)
+}
+func (dst *GetResponse_Entity) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetResponse_Entity.Merge(dst, src)
+}
+func (m *GetResponse_Entity) XXX_Size() int {
+        return xxx_messageInfo_GetResponse_Entity.Size(m)
+}
+func (m *GetResponse_Entity) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetResponse_Entity.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetResponse_Entity proto.InternalMessageInfo
+
+func (m *GetResponse_Entity) GetEntity() *EntityProto {
+        if m != nil {
+                return m.Entity
+        }
+        return nil
+}
+
+func (m *GetResponse_Entity) GetKey() *Reference {
+        if m != nil {
+                return m.Key
+        }
+        return nil
+}
+
+func (m *GetResponse_Entity) GetVersion() int64 {
+        if m != nil && m.Version != nil {
+                return *m.Version
+        }
+        return 0
+}
+
+type PutRequest struct {
+        Header               *InternalHeader          `protobuf:"bytes,11,opt,name=header" json:"header,omitempty"`
+        Entity               []*EntityProto           `protobuf:"bytes,1,rep,name=entity" json:"entity,omitempty"`
+        Transaction          *Transaction             `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"`
+        CompositeIndex       []*CompositeIndex        `protobuf:"bytes,3,rep,name=composite_index,json=compositeIndex" json:"composite_index,omitempty"`
+        Trusted              *bool                    `protobuf:"varint,4,opt,name=trusted,def=0" json:"trusted,omitempty"`
+        Force                *bool                    `protobuf:"varint,7,opt,name=force,def=0" json:"force,omitempty"`
+        MarkChanges          *bool                    `protobuf:"varint,8,opt,name=mark_changes,json=markChanges,def=0" json:"mark_changes,omitempty"`
+        Snapshot             []*Snapshot              `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"`
+        AutoIdPolicy         *PutRequest_AutoIdPolicy `protobuf:"varint,10,opt,name=auto_id_policy,json=autoIdPolicy,enum=appengine.PutRequest_AutoIdPolicy,def=0" json:"auto_id_policy,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
+        XXX_unrecognized     []byte                   `json:"-"`
+        XXX_sizecache        int32                    `json:"-"`
+}
+
+func (m *PutRequest) Reset()         { *m = PutRequest{} }
+func (m *PutRequest) String() string { return proto.CompactTextString(m) }
+func (*PutRequest) ProtoMessage()    {}
+func (*PutRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{23}
+}
+func (m *PutRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_PutRequest.Unmarshal(m, b)
+}
+func (m *PutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_PutRequest.Marshal(b, m, deterministic)
+}
+func (dst *PutRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_PutRequest.Merge(dst, src)
+}
+func (m *PutRequest) XXX_Size() int {
+        return xxx_messageInfo_PutRequest.Size(m)
+}
+func (m *PutRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_PutRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PutRequest proto.InternalMessageInfo
+
+const Default_PutRequest_Trusted bool = false
+const Default_PutRequest_Force bool = false
+const Default_PutRequest_MarkChanges bool = false
+const Default_PutRequest_AutoIdPolicy PutRequest_AutoIdPolicy = PutRequest_CURRENT
+
+func (m *PutRequest) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *PutRequest) GetEntity() []*EntityProto {
+        if m != nil {
+                return m.Entity
+        }
+        return nil
+}
+
+func (m *PutRequest) GetTransaction() *Transaction {
+        if m != nil {
+                return m.Transaction
+        }
+        return nil
+}
+
+func (m *PutRequest) GetCompositeIndex() []*CompositeIndex {
+        if m != nil {
+                return m.CompositeIndex
+        }
+        return nil
+}
+
+func (m *PutRequest) GetTrusted() bool {
+        if m != nil && m.Trusted != nil {
+                return *m.Trusted
+        }
+        return Default_PutRequest_Trusted
+}
+
+func (m *PutRequest) GetForce() bool {
+        if m != nil && m.Force != nil {
+                return *m.Force
+        }
+        return Default_PutRequest_Force
+}
+
+func (m *PutRequest) GetMarkChanges() bool {
+        if m != nil && m.MarkChanges != nil {
+                return *m.MarkChanges
+        }
+        return Default_PutRequest_MarkChanges
+}
+
+func (m *PutRequest) GetSnapshot() []*Snapshot {
+        if m != nil {
+                return m.Snapshot
+        }
+        return nil
+}
+
+func (m *PutRequest) GetAutoIdPolicy() PutRequest_AutoIdPolicy {
+        if m != nil && m.AutoIdPolicy != nil {
+                return *m.AutoIdPolicy
+        }
+        return Default_PutRequest_AutoIdPolicy
+}
+
+type PutResponse struct {
+        Key                  []*Reference `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
+        Cost                 *Cost        `protobuf:"bytes,2,opt,name=cost" json:"cost,omitempty"`
+        Version              []int64      `protobuf:"varint,3,rep,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}     `json:"-"`
+        XXX_unrecognized     []byte       `json:"-"`
+        XXX_sizecache        int32        `json:"-"`
+}
+
+func (m *PutResponse) Reset()         { *m = PutResponse{} }
+func (m *PutResponse) String() string { return proto.CompactTextString(m) }
+func (*PutResponse) ProtoMessage()    {}
+func (*PutResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{24}
+}
+func (m *PutResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_PutResponse.Unmarshal(m, b)
+}
+func (m *PutResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_PutResponse.Marshal(b, m, deterministic)
+}
+func (dst *PutResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_PutResponse.Merge(dst, src)
+}
+func (m *PutResponse) XXX_Size() int {
+        return xxx_messageInfo_PutResponse.Size(m)
+}
+func (m *PutResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_PutResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PutResponse proto.InternalMessageInfo
+
+func (m *PutResponse) GetKey() []*Reference {
+        if m != nil {
+                return m.Key
+        }
+        return nil
+}
+
+func (m *PutResponse) GetCost() *Cost {
+        if m != nil {
+                return m.Cost
+        }
+        return nil
+}
+
+func (m *PutResponse) GetVersion() []int64 {
+        if m != nil {
+                return m.Version
+        }
+        return nil
+}
+
+type TouchRequest struct {
+        Header               *InternalHeader   `protobuf:"bytes,10,opt,name=header" json:"header,omitempty"`
+        Key                  []*Reference      `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
+        CompositeIndex       []*CompositeIndex `protobuf:"bytes,2,rep,name=composite_index,json=compositeIndex" json:"composite_index,omitempty"`
+        Force                *bool             `protobuf:"varint,3,opt,name=force,def=0" json:"force,omitempty"`
+        Snapshot             []*Snapshot       `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+        XXX_unrecognized     []byte            `json:"-"`
+        XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *TouchRequest) Reset()         { *m = TouchRequest{} }
+func (m *TouchRequest) String() string { return proto.CompactTextString(m) }
+func (*TouchRequest) ProtoMessage()    {}
+func (*TouchRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{25}
+}
+func (m *TouchRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_TouchRequest.Unmarshal(m, b)
+}
+func (m *TouchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_TouchRequest.Marshal(b, m, deterministic)
+}
+func (dst *TouchRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_TouchRequest.Merge(dst, src)
+}
+func (m *TouchRequest) XXX_Size() int {
+        return xxx_messageInfo_TouchRequest.Size(m)
+}
+func (m *TouchRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_TouchRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TouchRequest proto.InternalMessageInfo
+
+const Default_TouchRequest_Force bool = false
+
+func (m *TouchRequest) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *TouchRequest) GetKey() []*Reference {
+        if m != nil {
+                return m.Key
+        }
+        return nil
+}
+
+func (m *TouchRequest) GetCompositeIndex() []*CompositeIndex {
+        if m != nil {
+                return m.CompositeIndex
+        }
+        return nil
+}
+
+func (m *TouchRequest) GetForce() bool {
+        if m != nil && m.Force != nil {
+                return *m.Force
+        }
+        return Default_TouchRequest_Force
+}
+
+func (m *TouchRequest) GetSnapshot() []*Snapshot {
+        if m != nil {
+                return m.Snapshot
+        }
+        return nil
+}
+
+type TouchResponse struct {
+        Cost                 *Cost    `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *TouchResponse) Reset()         { *m = TouchResponse{} }
+func (m *TouchResponse) String() string { return proto.CompactTextString(m) }
+func (*TouchResponse) ProtoMessage()    {}
+func (*TouchResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{26}
+}
+func (m *TouchResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_TouchResponse.Unmarshal(m, b)
+}
+func (m *TouchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_TouchResponse.Marshal(b, m, deterministic)
+}
+func (dst *TouchResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_TouchResponse.Merge(dst, src)
+}
+func (m *TouchResponse) XXX_Size() int {
+        return xxx_messageInfo_TouchResponse.Size(m)
+}
+func (m *TouchResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_TouchResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TouchResponse proto.InternalMessageInfo
+
+func (m *TouchResponse) GetCost() *Cost {
+        if m != nil {
+                return m.Cost
+        }
+        return nil
+}
+
+type DeleteRequest struct {
+        Header               *InternalHeader `protobuf:"bytes,10,opt,name=header" json:"header,omitempty"`
+        Key                  []*Reference    `protobuf:"bytes,6,rep,name=key" json:"key,omitempty"`
+        Transaction          *Transaction    `protobuf:"bytes,5,opt,name=transaction" json:"transaction,omitempty"`
+        Trusted              *bool           `protobuf:"varint,4,opt,name=trusted,def=0" json:"trusted,omitempty"`
+        Force                *bool           `protobuf:"varint,7,opt,name=force,def=0" json:"force,omitempty"`
+        MarkChanges          *bool           `protobuf:"varint,8,opt,name=mark_changes,json=markChanges,def=0" json:"mark_changes,omitempty"`
+        Snapshot             []*Snapshot     `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+        XXX_unrecognized     []byte          `json:"-"`
+        XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *DeleteRequest) Reset()         { *m = DeleteRequest{} }
+func (m *DeleteRequest) String() string { return proto.CompactTextString(m) }
+func (*DeleteRequest) ProtoMessage()    {}
+func (*DeleteRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{27}
+}
+func (m *DeleteRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_DeleteRequest.Unmarshal(m, b)
+}
+func (m *DeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_DeleteRequest.Marshal(b, m, deterministic)
+}
+func (dst *DeleteRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_DeleteRequest.Merge(dst, src)
+}
+func (m *DeleteRequest) XXX_Size() int {
+        return xxx_messageInfo_DeleteRequest.Size(m)
+}
+func (m *DeleteRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_DeleteRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DeleteRequest proto.InternalMessageInfo
+
+const Default_DeleteRequest_Trusted bool = false
+const Default_DeleteRequest_Force bool = false
+const Default_DeleteRequest_MarkChanges bool = false
+
+func (m *DeleteRequest) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *DeleteRequest) GetKey() []*Reference {
+        if m != nil {
+                return m.Key
+        }
+        return nil
+}
+
+func (m *DeleteRequest) GetTransaction() *Transaction {
+        if m != nil {
+                return m.Transaction
+        }
+        return nil
+}
+
+func (m *DeleteRequest) GetTrusted() bool {
+        if m != nil && m.Trusted != nil {
+                return *m.Trusted
+        }
+        return Default_DeleteRequest_Trusted
+}
+
+func (m *DeleteRequest) GetForce() bool {
+        if m != nil && m.Force != nil {
+                return *m.Force
+        }
+        return Default_DeleteRequest_Force
+}
+
+func (m *DeleteRequest) GetMarkChanges() bool {
+        if m != nil && m.MarkChanges != nil {
+                return *m.MarkChanges
+        }
+        return Default_DeleteRequest_MarkChanges
+}
+
+func (m *DeleteRequest) GetSnapshot() []*Snapshot {
+        if m != nil {
+                return m.Snapshot
+        }
+        return nil
+}
+
+type DeleteResponse struct {
+        Cost                 *Cost    `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"`
+        Version              []int64  `protobuf:"varint,3,rep,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *DeleteResponse) Reset()         { *m = DeleteResponse{} }
+func (m *DeleteResponse) String() string { return proto.CompactTextString(m) }
+func (*DeleteResponse) ProtoMessage()    {}
+func (*DeleteResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{28}
+}
+func (m *DeleteResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_DeleteResponse.Unmarshal(m, b)
+}
+func (m *DeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_DeleteResponse.Marshal(b, m, deterministic)
+}
+func (dst *DeleteResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_DeleteResponse.Merge(dst, src)
+}
+func (m *DeleteResponse) XXX_Size() int {
+        return xxx_messageInfo_DeleteResponse.Size(m)
+}
+func (m *DeleteResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_DeleteResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DeleteResponse proto.InternalMessageInfo
+
+func (m *DeleteResponse) GetCost() *Cost {
+        if m != nil {
+                return m.Cost
+        }
+        return nil
+}
+
+func (m *DeleteResponse) GetVersion() []int64 {
+        if m != nil {
+                return m.Version
+        }
+        return nil
+}
+
+type NextRequest struct {
+        Header               *InternalHeader `protobuf:"bytes,5,opt,name=header" json:"header,omitempty"`
+        Cursor               *Cursor         `protobuf:"bytes,1,req,name=cursor" json:"cursor,omitempty"`
+        Count                *int32          `protobuf:"varint,2,opt,name=count" json:"count,omitempty"`
+        Offset               *int32          `protobuf:"varint,4,opt,name=offset,def=0" json:"offset,omitempty"`
+        Compile              *bool           `protobuf:"varint,3,opt,name=compile,def=0" json:"compile,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+        XXX_unrecognized     []byte          `json:"-"`
+        XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *NextRequest) Reset()         { *m = NextRequest{} }
+func (m *NextRequest) String() string { return proto.CompactTextString(m) }
+func (*NextRequest) ProtoMessage()    {}
+func (*NextRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{29}
+}
+func (m *NextRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_NextRequest.Unmarshal(m, b)
+}
+func (m *NextRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_NextRequest.Marshal(b, m, deterministic)
+}
+func (dst *NextRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_NextRequest.Merge(dst, src)
+}
+func (m *NextRequest) XXX_Size() int {
+        return xxx_messageInfo_NextRequest.Size(m)
+}
+func (m *NextRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_NextRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NextRequest proto.InternalMessageInfo
+
+const Default_NextRequest_Offset int32 = 0
+const Default_NextRequest_Compile bool = false
+
+func (m *NextRequest) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *NextRequest) GetCursor() *Cursor {
+        if m != nil {
+                return m.Cursor
+        }
+        return nil
+}
+
+func (m *NextRequest) GetCount() int32 {
+        if m != nil && m.Count != nil {
+                return *m.Count
+        }
+        return 0
+}
+
+func (m *NextRequest) GetOffset() int32 {
+        if m != nil && m.Offset != nil {
+                return *m.Offset
+        }
+        return Default_NextRequest_Offset
+}
+
+func (m *NextRequest) GetCompile() bool {
+        if m != nil && m.Compile != nil {
+                return *m.Compile
+        }
+        return Default_NextRequest_Compile
+}
+
+type QueryResult struct {
+        Cursor               *Cursor           `protobuf:"bytes,1,opt,name=cursor" json:"cursor,omitempty"`
+        Result               []*EntityProto    `protobuf:"bytes,2,rep,name=result" json:"result,omitempty"`
+        SkippedResults       *int32            `protobuf:"varint,7,opt,name=skipped_results,json=skippedResults" json:"skipped_results,omitempty"`
+        MoreResults          *bool             `protobuf:"varint,3,req,name=more_results,json=moreResults" json:"more_results,omitempty"`
+        KeysOnly             *bool             `protobuf:"varint,4,opt,name=keys_only,json=keysOnly" json:"keys_only,omitempty"`
+        IndexOnly            *bool             `protobuf:"varint,9,opt,name=index_only,json=indexOnly" json:"index_only,omitempty"`
+        SmallOps             *bool             `protobuf:"varint,10,opt,name=small_ops,json=smallOps" json:"small_ops,omitempty"`
+        CompiledQuery        *CompiledQuery    `protobuf:"bytes,5,opt,name=compiled_query,json=compiledQuery" json:"compiled_query,omitempty"`
+        CompiledCursor       *CompiledCursor   `protobuf:"bytes,6,opt,name=compiled_cursor,json=compiledCursor" json:"compiled_cursor,omitempty"`
+        Index                []*CompositeIndex `protobuf:"bytes,8,rep,name=index" json:"index,omitempty"`
+        Version              []int64           `protobuf:"varint,11,rep,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+        XXX_unrecognized     []byte            `json:"-"`
+        XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *QueryResult) Reset()         { *m = QueryResult{} }
+func (m *QueryResult) String() string { return proto.CompactTextString(m) }
+func (*QueryResult) ProtoMessage()    {}
+func (*QueryResult) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{30}
+}
+func (m *QueryResult) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_QueryResult.Unmarshal(m, b)
+}
+func (m *QueryResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_QueryResult.Marshal(b, m, deterministic)
+}
+func (dst *QueryResult) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_QueryResult.Merge(dst, src)
+}
+func (m *QueryResult) XXX_Size() int {
+        return xxx_messageInfo_QueryResult.Size(m)
+}
+func (m *QueryResult) XXX_DiscardUnknown() {
+        xxx_messageInfo_QueryResult.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryResult proto.InternalMessageInfo
+
+func (m *QueryResult) GetCursor() *Cursor {
+        if m != nil {
+                return m.Cursor
+        }
+        return nil
+}
+
+func (m *QueryResult) GetResult() []*EntityProto {
+        if m != nil {
+                return m.Result
+        }
+        return nil
+}
+
+func (m *QueryResult) GetSkippedResults() int32 {
+        if m != nil && m.SkippedResults != nil {
+                return *m.SkippedResults
+        }
+        return 0
+}
+
+func (m *QueryResult) GetMoreResults() bool {
+        if m != nil && m.MoreResults != nil {
+                return *m.MoreResults
+        }
+        return false
+}
+
+func (m *QueryResult) GetKeysOnly() bool {
+        if m != nil && m.KeysOnly != nil {
+                return *m.KeysOnly
+        }
+        return false
+}
+
+func (m *QueryResult) GetIndexOnly() bool {
+        if m != nil && m.IndexOnly != nil {
+                return *m.IndexOnly
+        }
+        return false
+}
+
+func (m *QueryResult) GetSmallOps() bool {
+        if m != nil && m.SmallOps != nil {
+                return *m.SmallOps
+        }
+        return false
+}
+
+func (m *QueryResult) GetCompiledQuery() *CompiledQuery {
+        if m != nil {
+                return m.CompiledQuery
+        }
+        return nil
+}
+
+func (m *QueryResult) GetCompiledCursor() *CompiledCursor {
+        if m != nil {
+                return m.CompiledCursor
+        }
+        return nil
+}
+
+func (m *QueryResult) GetIndex() []*CompositeIndex {
+        if m != nil {
+                return m.Index
+        }
+        return nil
+}
+
+func (m *QueryResult) GetVersion() []int64 {
+        if m != nil {
+                return m.Version
+        }
+        return nil
+}
+
+type AllocateIdsRequest struct {
+        Header               *InternalHeader `protobuf:"bytes,4,opt,name=header" json:"header,omitempty"`
+        ModelKey             *Reference      `protobuf:"bytes,1,opt,name=model_key,json=modelKey" json:"model_key,omitempty"`
+        Size                 *int64          `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
+        Max                  *int64          `protobuf:"varint,3,opt,name=max" json:"max,omitempty"`
+        Reserve              []*Reference    `protobuf:"bytes,5,rep,name=reserve" json:"reserve,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+        XXX_unrecognized     []byte          `json:"-"`
+        XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *AllocateIdsRequest) Reset()         { *m = AllocateIdsRequest{} }
+func (m *AllocateIdsRequest) String() string { return proto.CompactTextString(m) }
+func (*AllocateIdsRequest) ProtoMessage()    {}
+func (*AllocateIdsRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{31}
+}
+func (m *AllocateIdsRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_AllocateIdsRequest.Unmarshal(m, b)
+}
+func (m *AllocateIdsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_AllocateIdsRequest.Marshal(b, m, deterministic)
+}
+func (dst *AllocateIdsRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_AllocateIdsRequest.Merge(dst, src)
+}
+func (m *AllocateIdsRequest) XXX_Size() int {
+        return xxx_messageInfo_AllocateIdsRequest.Size(m)
+}
+func (m *AllocateIdsRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_AllocateIdsRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AllocateIdsRequest proto.InternalMessageInfo
+
+func (m *AllocateIdsRequest) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *AllocateIdsRequest) GetModelKey() *Reference {
+        if m != nil {
+                return m.ModelKey
+        }
+        return nil
+}
+
+func (m *AllocateIdsRequest) GetSize() int64 {
+        if m != nil && m.Size != nil {
+                return *m.Size
+        }
+        return 0
+}
+
+func (m *AllocateIdsRequest) GetMax() int64 {
+        if m != nil && m.Max != nil {
+                return *m.Max
+        }
+        return 0
+}
+
+func (m *AllocateIdsRequest) GetReserve() []*Reference {
+        if m != nil {
+                return m.Reserve
+        }
+        return nil
+}
+
+type AllocateIdsResponse struct {
+        Start                *int64   `protobuf:"varint,1,req,name=start" json:"start,omitempty"`
+        End                  *int64   `protobuf:"varint,2,req,name=end" json:"end,omitempty"`
+        Cost                 *Cost    `protobuf:"bytes,3,opt,name=cost" json:"cost,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *AllocateIdsResponse) Reset()         { *m = AllocateIdsResponse{} }
+func (m *AllocateIdsResponse) String() string { return proto.CompactTextString(m) }
+func (*AllocateIdsResponse) ProtoMessage()    {}
+func (*AllocateIdsResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{32}
+}
+func (m *AllocateIdsResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_AllocateIdsResponse.Unmarshal(m, b)
+}
+func (m *AllocateIdsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_AllocateIdsResponse.Marshal(b, m, deterministic)
+}
+func (dst *AllocateIdsResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_AllocateIdsResponse.Merge(dst, src)
+}
+func (m *AllocateIdsResponse) XXX_Size() int {
+        return xxx_messageInfo_AllocateIdsResponse.Size(m)
+}
+func (m *AllocateIdsResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_AllocateIdsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AllocateIdsResponse proto.InternalMessageInfo
+
+func (m *AllocateIdsResponse) GetStart() int64 {
+        if m != nil && m.Start != nil {
+                return *m.Start
+        }
+        return 0
+}
+
+func (m *AllocateIdsResponse) GetEnd() int64 {
+        if m != nil && m.End != nil {
+                return *m.End
+        }
+        return 0
+}
+
+func (m *AllocateIdsResponse) GetCost() *Cost {
+        if m != nil {
+                return m.Cost
+        }
+        return nil
+}
+
+type CompositeIndices struct {
+        Index                []*CompositeIndex `protobuf:"bytes,1,rep,name=index" json:"index,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+        XXX_unrecognized     []byte            `json:"-"`
+        XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *CompositeIndices) Reset()         { *m = CompositeIndices{} }
+func (m *CompositeIndices) String() string { return proto.CompactTextString(m) }
+func (*CompositeIndices) ProtoMessage()    {}
+func (*CompositeIndices) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{33}
+}
+func (m *CompositeIndices) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CompositeIndices.Unmarshal(m, b)
+}
+func (m *CompositeIndices) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CompositeIndices.Marshal(b, m, deterministic)
+}
+func (dst *CompositeIndices) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CompositeIndices.Merge(dst, src)
+}
+func (m *CompositeIndices) XXX_Size() int {
+        return xxx_messageInfo_CompositeIndices.Size(m)
+}
+func (m *CompositeIndices) XXX_DiscardUnknown() {
+        xxx_messageInfo_CompositeIndices.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompositeIndices proto.InternalMessageInfo
+
+func (m *CompositeIndices) GetIndex() []*CompositeIndex {
+        if m != nil {
+                return m.Index
+        }
+        return nil
+}
+
+type AddActionsRequest struct {
+        Header               *InternalHeader `protobuf:"bytes,3,opt,name=header" json:"header,omitempty"`
+        Transaction          *Transaction    `protobuf:"bytes,1,req,name=transaction" json:"transaction,omitempty"`
+        Action               []*Action       `protobuf:"bytes,2,rep,name=action" json:"action,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+        XXX_unrecognized     []byte          `json:"-"`
+        XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *AddActionsRequest) Reset()         { *m = AddActionsRequest{} }
+func (m *AddActionsRequest) String() string { return proto.CompactTextString(m) }
+func (*AddActionsRequest) ProtoMessage()    {}
+func (*AddActionsRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{34}
+}
+func (m *AddActionsRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_AddActionsRequest.Unmarshal(m, b)
+}
+func (m *AddActionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_AddActionsRequest.Marshal(b, m, deterministic)
+}
+func (dst *AddActionsRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_AddActionsRequest.Merge(dst, src)
+}
+func (m *AddActionsRequest) XXX_Size() int {
+        return xxx_messageInfo_AddActionsRequest.Size(m)
+}
+func (m *AddActionsRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_AddActionsRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AddActionsRequest proto.InternalMessageInfo
+
+func (m *AddActionsRequest) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *AddActionsRequest) GetTransaction() *Transaction {
+        if m != nil {
+                return m.Transaction
+        }
+        return nil
+}
+
+func (m *AddActionsRequest) GetAction() []*Action {
+        if m != nil {
+                return m.Action
+        }
+        return nil
+}
+
+type AddActionsResponse struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *AddActionsResponse) Reset()         { *m = AddActionsResponse{} }
+func (m *AddActionsResponse) String() string { return proto.CompactTextString(m) }
+func (*AddActionsResponse) ProtoMessage()    {}
+func (*AddActionsResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{35}
+}
+func (m *AddActionsResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_AddActionsResponse.Unmarshal(m, b)
+}
+func (m *AddActionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_AddActionsResponse.Marshal(b, m, deterministic)
+}
+func (dst *AddActionsResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_AddActionsResponse.Merge(dst, src)
+}
+func (m *AddActionsResponse) XXX_Size() int {
+        return xxx_messageInfo_AddActionsResponse.Size(m)
+}
+func (m *AddActionsResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_AddActionsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AddActionsResponse proto.InternalMessageInfo
+
+type BeginTransactionRequest struct {
+        Header               *InternalHeader                          `protobuf:"bytes,3,opt,name=header" json:"header,omitempty"`
+        App                  *string                                  `protobuf:"bytes,1,req,name=app" json:"app,omitempty"`
+        AllowMultipleEg      *bool                                    `protobuf:"varint,2,opt,name=allow_multiple_eg,json=allowMultipleEg,def=0" json:"allow_multiple_eg,omitempty"`
+        DatabaseId           *string                                  `protobuf:"bytes,4,opt,name=database_id,json=databaseId" json:"database_id,omitempty"`
+        Mode                 *BeginTransactionRequest_TransactionMode `protobuf:"varint,5,opt,name=mode,enum=appengine.BeginTransactionRequest_TransactionMode,def=0" json:"mode,omitempty"`
+        PreviousTransaction  *Transaction                             `protobuf:"bytes,7,opt,name=previous_transaction,json=previousTransaction" json:"previous_transaction,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                                 `json:"-"`
+        XXX_unrecognized     []byte                                   `json:"-"`
+        XXX_sizecache        int32                                    `json:"-"`
+}
+
+func (m *BeginTransactionRequest) Reset()         { *m = BeginTransactionRequest{} }
+func (m *BeginTransactionRequest) String() string { return proto.CompactTextString(m) }
+func (*BeginTransactionRequest) ProtoMessage()    {}
+func (*BeginTransactionRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{36}
+}
+func (m *BeginTransactionRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_BeginTransactionRequest.Unmarshal(m, b)
+}
+func (m *BeginTransactionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_BeginTransactionRequest.Marshal(b, m, deterministic)
+}
+func (dst *BeginTransactionRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_BeginTransactionRequest.Merge(dst, src)
+}
+func (m *BeginTransactionRequest) XXX_Size() int {
+        return xxx_messageInfo_BeginTransactionRequest.Size(m)
+}
+func (m *BeginTransactionRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_BeginTransactionRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BeginTransactionRequest proto.InternalMessageInfo
+
+const Default_BeginTransactionRequest_AllowMultipleEg bool = false
+const Default_BeginTransactionRequest_Mode BeginTransactionRequest_TransactionMode = BeginTransactionRequest_UNKNOWN
+
+func (m *BeginTransactionRequest) GetHeader() *InternalHeader {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *BeginTransactionRequest) GetApp() string {
+        if m != nil && m.App != nil {
+                return *m.App
+        }
+        return ""
+}
+
+func (m *BeginTransactionRequest) GetAllowMultipleEg() bool {
+        if m != nil && m.AllowMultipleEg != nil {
+                return *m.AllowMultipleEg
+        }
+        return Default_BeginTransactionRequest_AllowMultipleEg
+}
+
+func (m *BeginTransactionRequest) GetDatabaseId() string {
+        if m != nil && m.DatabaseId != nil {
+                return *m.DatabaseId
+        }
+        return ""
+}
+
+func (m *BeginTransactionRequest) GetMode() BeginTransactionRequest_TransactionMode {
+        if m != nil && m.Mode != nil {
+                return *m.Mode
+        }
+        return Default_BeginTransactionRequest_Mode
+}
+
+func (m *BeginTransactionRequest) GetPreviousTransaction() *Transaction {
+        if m != nil {
+                return m.PreviousTransaction
+        }
+        return nil
+}
+
+type CommitResponse struct {
+        Cost                 *Cost                     `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"`
+        Version              []*CommitResponse_Version `protobuf:"group,3,rep,name=Version,json=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
+        XXX_unrecognized     []byte                    `json:"-"`
+        XXX_sizecache        int32                     `json:"-"`
+}
+
+func (m *CommitResponse) Reset()         { *m = CommitResponse{} }
+func (m *CommitResponse) String() string { return proto.CompactTextString(m) }
+func (*CommitResponse) ProtoMessage()    {}
+func (*CommitResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{37}
+}
+func (m *CommitResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CommitResponse.Unmarshal(m, b)
+}
+func (m *CommitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CommitResponse.Marshal(b, m, deterministic)
+}
+func (dst *CommitResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CommitResponse.Merge(dst, src)
+}
+func (m *CommitResponse) XXX_Size() int {
+        return xxx_messageInfo_CommitResponse.Size(m)
+}
+func (m *CommitResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_CommitResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CommitResponse proto.InternalMessageInfo
+
+func (m *CommitResponse) GetCost() *Cost {
+        if m != nil {
+                return m.Cost
+        }
+        return nil
+}
+
+func (m *CommitResponse) GetVersion() []*CommitResponse_Version {
+        if m != nil {
+                return m.Version
+        }
+        return nil
+}
+
+type CommitResponse_Version struct {
+        RootEntityKey        *Reference `protobuf:"bytes,4,req,name=root_entity_key,json=rootEntityKey" json:"root_entity_key,omitempty"`
+        Version              *int64     `protobuf:"varint,5,req,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}   `json:"-"`
+        XXX_unrecognized     []byte     `json:"-"`
+        XXX_sizecache        int32      `json:"-"`
+}
+
+func (m *CommitResponse_Version) Reset()         { *m = CommitResponse_Version{} }
+func (m *CommitResponse_Version) String() string { return proto.CompactTextString(m) }
+func (*CommitResponse_Version) ProtoMessage()    {}
+func (*CommitResponse_Version) Descriptor() ([]byte, []int) {
+        return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{37, 0}
+}
+func (m *CommitResponse_Version) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CommitResponse_Version.Unmarshal(m, b)
+}
+func (m *CommitResponse_Version) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CommitResponse_Version.Marshal(b, m, deterministic)
+}
+func (dst *CommitResponse_Version) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CommitResponse_Version.Merge(dst, src)
+}
+func (m *CommitResponse_Version) XXX_Size() int {
+        return xxx_messageInfo_CommitResponse_Version.Size(m)
+}
+func (m *CommitResponse_Version) XXX_DiscardUnknown() {
+        xxx_messageInfo_CommitResponse_Version.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CommitResponse_Version proto.InternalMessageInfo
+
+func (m *CommitResponse_Version) GetRootEntityKey() *Reference {
+        if m != nil {
+                return m.RootEntityKey
+        }
+        return nil
+}
+
+func (m *CommitResponse_Version) GetVersion() int64 {
+        if m != nil && m.Version != nil {
+                return *m.Version
+        }
+        return 0
+}
+
+func init() {
+        proto.RegisterType((*Action)(nil), "appengine.Action")
+        proto.RegisterType((*PropertyValue)(nil), "appengine.PropertyValue")
+        proto.RegisterType((*PropertyValue_PointValue)(nil), "appengine.PropertyValue.PointValue")
+        proto.RegisterType((*PropertyValue_UserValue)(nil), "appengine.PropertyValue.UserValue")
+        proto.RegisterType((*PropertyValue_ReferenceValue)(nil), "appengine.PropertyValue.ReferenceValue")
+        proto.RegisterType((*PropertyValue_ReferenceValue_PathElement)(nil), "appengine.PropertyValue.ReferenceValue.PathElement")
+        proto.RegisterType((*Property)(nil), "appengine.Property")
+        proto.RegisterType((*Path)(nil), "appengine.Path")
+        proto.RegisterType((*Path_Element)(nil), "appengine.Path.Element")
+        proto.RegisterType((*Reference)(nil), "appengine.Reference")
+        proto.RegisterType((*User)(nil), "appengine.User")
+        proto.RegisterType((*EntityProto)(nil), "appengine.EntityProto")
+        proto.RegisterType((*CompositeProperty)(nil), "appengine.CompositeProperty")
+        proto.RegisterType((*Index)(nil), "appengine.Index")
+        proto.RegisterType((*Index_Property)(nil), "appengine.Index.Property")
+        proto.RegisterType((*CompositeIndex)(nil), "appengine.CompositeIndex")
+        proto.RegisterType((*IndexPostfix)(nil), "appengine.IndexPostfix")
+        proto.RegisterType((*IndexPostfix_IndexValue)(nil), "appengine.IndexPostfix.IndexValue")
+        proto.RegisterType((*IndexPosition)(nil), "appengine.IndexPosition")
+        proto.RegisterType((*Snapshot)(nil), "appengine.Snapshot")
+        proto.RegisterType((*InternalHeader)(nil), "appengine.InternalHeader")
+        proto.RegisterType((*Transaction)(nil), "appengine.Transaction")
+        proto.RegisterType((*Query)(nil), "appengine.Query")
+        proto.RegisterType((*Query_Filter)(nil), "appengine.Query.Filter")
+        proto.RegisterType((*Query_Order)(nil), "appengine.Query.Order")
+        proto.RegisterType((*CompiledQuery)(nil), "appengine.CompiledQuery")
+        proto.RegisterType((*CompiledQuery_PrimaryScan)(nil), "appengine.CompiledQuery.PrimaryScan")
+        proto.RegisterType((*CompiledQuery_MergeJoinScan)(nil), "appengine.CompiledQuery.MergeJoinScan")
+        proto.RegisterType((*CompiledQuery_EntityFilter)(nil), "appengine.CompiledQuery.EntityFilter")
+        proto.RegisterType((*CompiledCursor)(nil), "appengine.CompiledCursor")
+        proto.RegisterType((*CompiledCursor_Position)(nil), "appengine.CompiledCursor.Position")
+        proto.RegisterType((*CompiledCursor_Position_IndexValue)(nil), "appengine.CompiledCursor.Position.IndexValue")
+        proto.RegisterType((*Cursor)(nil), "appengine.Cursor")
+        proto.RegisterType((*Error)(nil), "appengine.Error")
+        proto.RegisterType((*Cost)(nil), "appengine.Cost")
+        proto.RegisterType((*Cost_CommitCost)(nil), "appengine.Cost.CommitCost")
+        proto.RegisterType((*GetRequest)(nil), "appengine.GetRequest")
+        proto.RegisterType((*GetResponse)(nil), "appengine.GetResponse")
+        proto.RegisterType((*GetResponse_Entity)(nil), "appengine.GetResponse.Entity")
+        proto.RegisterType((*PutRequest)(nil), "appengine.PutRequest")
+        proto.RegisterType((*PutResponse)(nil), "appengine.PutResponse")
+        proto.RegisterType((*TouchRequest)(nil), "appengine.TouchRequest")
+        proto.RegisterType((*TouchResponse)(nil), "appengine.TouchResponse")
+        proto.RegisterType((*DeleteRequest)(nil), "appengine.DeleteRequest")
+        proto.RegisterType((*DeleteResponse)(nil), "appengine.DeleteResponse")
+        proto.RegisterType((*NextRequest)(nil), "appengine.NextRequest")
+        proto.RegisterType((*QueryResult)(nil), "appengine.QueryResult")
+        proto.RegisterType((*AllocateIdsRequest)(nil), "appengine.AllocateIdsRequest")
+        proto.RegisterType((*AllocateIdsResponse)(nil), "appengine.AllocateIdsResponse")
+        proto.RegisterType((*CompositeIndices)(nil), "appengine.CompositeIndices")
+        proto.RegisterType((*AddActionsRequest)(nil), "appengine.AddActionsRequest")
+        proto.RegisterType((*AddActionsResponse)(nil), "appengine.AddActionsResponse")
+        proto.RegisterType((*BeginTransactionRequest)(nil), "appengine.BeginTransactionRequest")
+        proto.RegisterType((*CommitResponse)(nil), "appengine.CommitResponse")
+        proto.RegisterType((*CommitResponse_Version)(nil), "appengine.CommitResponse.Version")
+}
+
+func init() {
+        proto.RegisterFile("google.golang.org/appengine/internal/datastore/datastore_v3.proto", fileDescriptor_datastore_v3_83b17b80c34f6179)
+}
+
+var fileDescriptor_datastore_v3_83b17b80c34f6179 = []byte{
+        // 4156 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xcd, 0x73, 0xe3, 0x46,
+        0x76, 0x37, 0xc1, 0xef, 0x47, 0x89, 0x82, 0x5a, 0xf3, 0xc1, 0xa1, 0x3f, 0x46, 0xc6, 0xac, 0x6d,
+        0xd9, 0x6b, 0x73, 0x6c, 0xf9, 0x23, 0x5b, 0x4a, 0x76, 0x1d, 0x4a, 0xc4, 0x68, 0x90, 0xa1, 0x48,
+        0xb9, 0x09, 0xd9, 0x9e, 0x5c, 0x50, 0x18, 0xa2, 0x29, 0x21, 0x43, 0x02, 0x30, 0x00, 0x6a, 0x46,
+        0x93, 0xe4, 0x90, 0x4b, 0x2a, 0x55, 0x5b, 0xa9, 0x1c, 0x92, 0x4a, 0x25, 0xf9, 0x07, 0x72, 0xc8,
+        0x39, 0x95, 0xaa, 0x54, 0xf6, 0x98, 0x5b, 0x0e, 0x7b, 0xc9, 0x31, 0x95, 0x73, 0xf2, 0x27, 0x24,
+        0x39, 0xa4, 0xfa, 0x75, 0x03, 0x02, 0x28, 0x4a, 0x23, 0x6d, 0xf6, 0x90, 0x13, 0xd1, 0xef, 0xfd,
+        0xba, 0xf1, 0xfa, 0xf5, 0xfb, 0x6c, 0x10, 0xba, 0xc7, 0xbe, 0x7f, 0x3c, 0x65, 0x9d, 0x63, 0x7f,
+        0x6a, 0x7b, 0xc7, 0x1d, 0x3f, 0x3c, 0x7e, 0x68, 0x07, 0x01, 0xf3, 0x8e, 0x5d, 0x8f, 0x3d, 0x74,
+        0xbd, 0x98, 0x85, 0x9e, 0x3d, 0x7d, 0xe8, 0xd8, 0xb1, 0x1d, 0xc5, 0x7e, 0xc8, 0xce, 0x9f, 0xac,
+        0xd3, 0xcf, 0x3b, 0x41, 0xe8, 0xc7, 0x3e, 0xa9, 0xa7, 0x13, 0xb4, 0x1a, 0x54, 0xba, 0xe3, 0xd8,
+        0xf5, 0x3d, 0xed, 0x1f, 0x2b, 0xb0, 0x7a, 0x18, 0xfa, 0x01, 0x0b, 0xe3, 0xb3, 0x6f, 0xed, 0xe9,
+        0x9c, 0x91, 0x77, 0x00, 0x5c, 0x2f, 0xfe, 0xea, 0x0b, 0x1c, 0xb5, 0x0a, 0x9b, 0x85, 0xad, 0x22,
+        0xcd, 0x50, 0x88, 0x06, 0x2b, 0xcf, 0x7c, 0x7f, 0xca, 0x6c, 0x4f, 0x20, 0x94, 0xcd, 0xc2, 0x56,
+        0x8d, 0xe6, 0x68, 0x64, 0x13, 0x1a, 0x51, 0x1c, 0xba, 0xde, 0xb1, 0x80, 0x14, 0x37, 0x0b, 0x5b,
+        0x75, 0x9a, 0x25, 0x71, 0x84, 0xe3, 0xcf, 0x9f, 0x4d, 0x99, 0x40, 0x94, 0x36, 0x0b, 0x5b, 0x05,
+        0x9a, 0x25, 0x91, 0x3d, 0x80, 0xc0, 0x77, 0xbd, 0xf8, 0x14, 0x01, 0xe5, 0xcd, 0xc2, 0x16, 0x6c,
+        0x3f, 0xe8, 0xa4, 0x7b, 0xe8, 0xe4, 0xa4, 0xee, 0x1c, 0x72, 0x28, 0x3e, 0xd2, 0xcc, 0x34, 0xf2,
+        0xdb, 0x50, 0x9f, 0x47, 0x2c, 0x14, 0x6b, 0xd4, 0x70, 0x0d, 0xed, 0xd2, 0x35, 0x8e, 0x22, 0x16,
+        0x8a, 0x25, 0xce, 0x27, 0x91, 0x21, 0x34, 0x43, 0x36, 0x61, 0x21, 0xf3, 0xc6, 0x4c, 0x2c, 0xb3,
+        0x82, 0xcb, 0x7c, 0x70, 0xe9, 0x32, 0x34, 0x81, 0x8b, 0xb5, 0x16, 0xa6, 0xb7, 0xb7, 0x00, 0xce,
+        0x85, 0x25, 0x2b, 0x50, 0x78, 0xd9, 0xaa, 0x6c, 0x2a, 0x5b, 0x05, 0x5a, 0x78, 0xc9, 0x47, 0x67,
+        0xad, 0xaa, 0x18, 0x9d, 0xb5, 0xff, 0xa9, 0x00, 0xf5, 0x54, 0x26, 0x72, 0x0b, 0xca, 0x6c, 0x66,
+        0xbb, 0xd3, 0x56, 0x7d, 0x53, 0xd9, 0xaa, 0x53, 0x31, 0x20, 0xf7, 0xa1, 0x61, 0xcf, 0xe3, 0x13,
+        0xcb, 0xf1, 0x67, 0xb6, 0xeb, 0xb5, 0x00, 0x79, 0xc0, 0x49, 0x3d, 0xa4, 0x90, 0x36, 0xd4, 0x3c,
+        0x77, 0xfc, 0xdc, 0xb3, 0x67, 0xac, 0xd5, 0xc0, 0x73, 0x48, 0xc7, 0xe4, 0x13, 0x20, 0x13, 0xe6,
+        0xb0, 0xd0, 0x8e, 0x99, 0x63, 0xb9, 0x0e, 0xf3, 0x62, 0x37, 0x3e, 0x6b, 0xdd, 0x46, 0xd4, 0x7a,
+        0xca, 0x31, 0x24, 0x23, 0x0f, 0x0f, 0x42, 0xff, 0xd4, 0x75, 0x58, 0xd8, 0xba, 0xb3, 0x00, 0x3f,
+        0x94, 0x8c, 0xf6, 0xbf, 0x17, 0xa0, 0x99, 0xd7, 0x05, 0x51, 0xa1, 0x68, 0x07, 0x41, 0x6b, 0x15,
+        0xa5, 0xe4, 0x8f, 0xe4, 0x6d, 0x00, 0x2e, 0x8a, 0x15, 0x05, 0xf6, 0x98, 0xb5, 0x6e, 0xe1, 0x5a,
+        0x75, 0x4e, 0x19, 0x71, 0x02, 0x39, 0x82, 0x46, 0x60, 0xc7, 0x27, 0x6c, 0xca, 0x66, 0xcc, 0x8b,
+        0x5b, 0xcd, 0xcd, 0xe2, 0x16, 0x6c, 0x7f, 0x7e, 0x4d, 0xd5, 0x77, 0x0e, 0xed, 0xf8, 0x44, 0x17,
+        0x53, 0x69, 0x76, 0x9d, 0xb6, 0x0e, 0x8d, 0x0c, 0x8f, 0x10, 0x28, 0xc5, 0x67, 0x01, 0x6b, 0xad,
+        0xa1, 0x5c, 0xf8, 0x4c, 0x9a, 0xa0, 0xb8, 0x4e, 0x4b, 0x45, 0xf3, 0x57, 0x5c, 0x87, 0x63, 0x50,
+        0x87, 0xeb, 0x28, 0x22, 0x3e, 0x6b, 0xff, 0x51, 0x86, 0x5a, 0x22, 0x00, 0xe9, 0x42, 0x75, 0xc6,
+        0x6c, 0xcf, 0xf5, 0x8e, 0xd1, 0x69, 0x9a, 0xdb, 0x6f, 0x2e, 0x11, 0xb3, 0x73, 0x20, 0x20, 0x3b,
+        0x30, 0x18, 0x5a, 0x07, 0x7a, 0x77, 0x60, 0x0c, 0xf6, 0x69, 0x32, 0x8f, 0x1f, 0xa6, 0x7c, 0xb4,
+        0xe6, 0xa1, 0x8b, 0x9e, 0x55, 0xa7, 0x20, 0x49, 0x47, 0xa1, 0x9b, 0x0a, 0x51, 0x14, 0x82, 0xe2,
+        0x21, 0x76, 0xa0, 0x9c, 0xb8, 0x88, 0xb2, 0xd5, 0xd8, 0x6e, 0x5d, 0xa6, 0x1c, 0x2a, 0x60, 0xdc,
+        0x20, 0x66, 0xf3, 0x69, 0xec, 0x06, 0x53, 0xee, 0x76, 0xca, 0x56, 0x8d, 0xa6, 0x63, 0xf2, 0x1e,
+        0x40, 0xc4, 0xec, 0x70, 0x7c, 0x62, 0x3f, 0x9b, 0xb2, 0x56, 0x85, 0x7b, 0xf6, 0x4e, 0x79, 0x62,
+        0x4f, 0x23, 0x46, 0x33, 0x0c, 0x62, 0xc3, 0xdd, 0x49, 0x1c, 0x59, 0xb1, 0xff, 0x9c, 0x79, 0xee,
+        0x2b, 0x9b, 0x07, 0x12, 0xcb, 0x0f, 0xf8, 0x0f, 0xfa, 0x58, 0x73, 0xfb, 0xc3, 0x65, 0x5b, 0x7f,
+        0x14, 0x47, 0x66, 0x66, 0xc6, 0x10, 0x27, 0xd0, 0xdb, 0x93, 0x65, 0x64, 0xd2, 0x86, 0xca, 0xd4,
+        0x1f, 0xdb, 0x53, 0xd6, 0xaa, 0x73, 0x2d, 0xec, 0x28, 0xcc, 0xa3, 0x92, 0xa2, 0xfd, 0xb3, 0x02,
+        0x55, 0xa9, 0x47, 0xd2, 0x84, 0x8c, 0x26, 0xd5, 0x37, 0x48, 0x0d, 0x4a, 0xbb, 0xfd, 0xe1, 0xae,
+        0xda, 0xe4, 0x4f, 0xa6, 0xfe, 0xbd, 0xa9, 0xae, 0x71, 0xcc, 0xee, 0x53, 0x53, 0x1f, 0x99, 0x94,
+        0x63, 0x54, 0xb2, 0x0e, 0xab, 0x5d, 0x73, 0x78, 0x60, 0xed, 0x75, 0x4d, 0x7d, 0x7f, 0x48, 0x9f,
+        0xaa, 0x05, 0xb2, 0x0a, 0x75, 0x24, 0xf5, 0x8d, 0xc1, 0x13, 0x55, 0xe1, 0x33, 0x70, 0x68, 0x1a,
+        0x66, 0x5f, 0x57, 0x8b, 0x44, 0x85, 0x15, 0x31, 0x63, 0x38, 0x30, 0xf5, 0x81, 0xa9, 0x96, 0x52,
+        0xca, 0xe8, 0xe8, 0xe0, 0xa0, 0x4b, 0x9f, 0xaa, 0x65, 0xb2, 0x06, 0x0d, 0xa4, 0x74, 0x8f, 0xcc,
+        0xc7, 0x43, 0xaa, 0x56, 0x48, 0x03, 0xaa, 0xfb, 0x3d, 0xeb, 0xbb, 0xc7, 0xfa, 0x40, 0xad, 0x92,
+        0x15, 0xa8, 0xed, 0xf7, 0x2c, 0xfd, 0xa0, 0x6b, 0xf4, 0xd5, 0x1a, 0x9f, 0xbd, 0xaf, 0x0f, 0xe9,
+        0x68, 0x64, 0x1d, 0x0e, 0x8d, 0x81, 0xa9, 0xd6, 0x49, 0x1d, 0xca, 0xfb, 0x3d, 0xcb, 0x38, 0x50,
+        0x81, 0x10, 0x68, 0xee, 0xf7, 0xac, 0xc3, 0xc7, 0xc3, 0x81, 0x3e, 0x38, 0x3a, 0xd8, 0xd5, 0xa9,
+        0xda, 0x20, 0xb7, 0x40, 0xe5, 0xb4, 0xe1, 0xc8, 0xec, 0xf6, 0xbb, 0xbd, 0x1e, 0xd5, 0x47, 0x23,
+        0x75, 0x85, 0x4b, 0xbd, 0xdf, 0xb3, 0x68, 0xd7, 0xe4, 0xfb, 0x5a, 0xe5, 0x2f, 0xe4, 0x7b, 0x7f,
+        0xa2, 0x3f, 0x55, 0xd7, 0xf9, 0x2b, 0xf4, 0x81, 0x69, 0x98, 0x4f, 0xad, 0x43, 0x3a, 0x34, 0x87,
+        0xea, 0x06, 0x17, 0xd0, 0x18, 0xf4, 0xf4, 0xef, 0xad, 0x6f, 0xbb, 0xfd, 0x23, 0x5d, 0x25, 0xda,
+        0x8f, 0xe1, 0xf6, 0xd2, 0x33, 0xe1, 0xaa, 0x7b, 0x6c, 0x1e, 0xf4, 0xd5, 0x02, 0x7f, 0xe2, 0x9b,
+        0x52, 0x15, 0xed, 0x0f, 0xa0, 0xc4, 0x5d, 0x86, 0x7c, 0x06, 0xd5, 0xc4, 0x1b, 0x0b, 0xe8, 0x8d,
+        0x77, 0xb3, 0x67, 0x6d, 0xc7, 0x27, 0x9d, 0xc4, 0xe3, 0x12, 0x5c, 0xbb, 0x0b, 0xd5, 0x45, 0x4f,
+        0x53, 0x2e, 0x78, 0x5a, 0xf1, 0x82, 0xa7, 0x95, 0x32, 0x9e, 0x66, 0x43, 0x3d, 0xf5, 0xed, 0x9b,
+        0x47, 0x91, 0x07, 0x50, 0xe2, 0xde, 0xdf, 0x6a, 0xa2, 0x87, 0xac, 0x2d, 0x08, 0x4c, 0x91, 0xa9,
+        0xfd, 0x43, 0x01, 0x4a, 0x3c, 0xda, 0x9e, 0x07, 0xda, 0xc2, 0x15, 0x81, 0x56, 0xb9, 0x32, 0xd0,
+        0x16, 0xaf, 0x15, 0x68, 0x2b, 0x37, 0x0b, 0xb4, 0xd5, 0x4b, 0x02, 0xad, 0xf6, 0x67, 0x45, 0x68,
+        0xe8, 0x38, 0xf3, 0x10, 0x13, 0xfd, 0xfb, 0x50, 0x7c, 0xce, 0xce, 0x50, 0x3f, 0x8d, 0xed, 0x5b,
+        0x99, 0xdd, 0xa6, 0x2a, 0xa4, 0x1c, 0x40, 0xb6, 0x61, 0x45, 0xbc, 0xd0, 0x3a, 0x0e, 0xfd, 0x79,
+        0xd0, 0x52, 0x97, 0xab, 0xa7, 0x21, 0x40, 0xfb, 0x1c, 0x43, 0xde, 0x83, 0xb2, 0xff, 0xc2, 0x63,
+        0x21, 0xc6, 0xc1, 0x3c, 0x98, 0x2b, 0x8f, 0x0a, 0x2e, 0x79, 0x08, 0xa5, 0xe7, 0xae, 0xe7, 0xe0,
+        0x19, 0xe6, 0x23, 0x61, 0x46, 0xd0, 0xce, 0x13, 0xd7, 0x73, 0x28, 0x02, 0xc9, 0x3d, 0xa8, 0xf1,
+        0x5f, 0x8c, 0x7b, 0x65, 0xdc, 0x68, 0x95, 0x8f, 0x79, 0xd0, 0x7b, 0x08, 0xb5, 0x40, 0xc6, 0x10,
+        0x4c, 0x00, 0x8d, 0xed, 0x8d, 0x25, 0xe1, 0x85, 0xa6, 0x20, 0xf2, 0x15, 0xac, 0x84, 0xf6, 0x0b,
+        0x2b, 0x9d, 0xb4, 0x76, 0xf9, 0xa4, 0x46, 0x68, 0xbf, 0x48, 0x23, 0x38, 0x81, 0x52, 0x68, 0x7b,
+        0xcf, 0x5b, 0x64, 0xb3, 0xb0, 0x55, 0xa6, 0xf8, 0xac, 0x7d, 0x01, 0x25, 0x2e, 0x25, 0x8f, 0x08,
+        0xfb, 0x3d, 0xf4, 0xff, 0xee, 0x9e, 0xa9, 0x16, 0x12, 0x7f, 0xfe, 0x96, 0x47, 0x03, 0x45, 0x72,
+        0x0f, 0xf4, 0xd1, 0xa8, 0xbb, 0xaf, 0xab, 0x45, 0xad, 0x07, 0xeb, 0x7b, 0xfe, 0x2c, 0xf0, 0x23,
+        0x37, 0x66, 0xe9, 0xf2, 0xf7, 0xa0, 0xe6, 0x7a, 0x0e, 0x7b, 0x69, 0xb9, 0x0e, 0x9a, 0x56, 0x91,
+        0x56, 0x71, 0x6c, 0x38, 0xdc, 0xe4, 0x4e, 0x65, 0x31, 0x55, 0xe4, 0x26, 0x87, 0x03, 0xed, 0x2f,
+        0x15, 0x28, 0x1b, 0x1c, 0xc1, 0x8d, 0x4f, 0x9e, 0x14, 0x7a, 0x8f, 0x30, 0x4c, 0x10, 0x24, 0x93,
+        0xfb, 0x50, 0x1b, 0x6a, 0xb6, 0x37, 0x66, 0xbc, 0xe2, 0xc3, 0x3c, 0x50, 0xa3, 0xe9, 0x98, 0x7c,
+        0x99, 0xd1, 0x9f, 0x82, 0x2e, 0x7b, 0x2f, 0xa3, 0x0a, 0x7c, 0xc1, 0x12, 0x2d, 0xb6, 0xff, 0xaa,
+        0x90, 0x49, 0x6e, 0xcb, 0x12, 0x4f, 0x1f, 0xea, 0x8e, 0x1b, 0x32, 0xac, 0x23, 0xe5, 0x41, 0x3f,
+        0xb8, 0x74, 0xe1, 0x4e, 0x2f, 0x81, 0xee, 0xd4, 0xbb, 0xa3, 0x3d, 0x7d, 0xd0, 0xe3, 0x99, 0xef,
+        0x7c, 0x01, 0xed, 0x23, 0xa8, 0xa7, 0x10, 0x0c, 0xc7, 0x09, 0x48, 0x2d, 0x70, 0xf5, 0xf6, 0xf4,
+        0x74, 0xac, 0x68, 0x7f, 0xad, 0x40, 0x33, 0xd5, 0xaf, 0xd0, 0xd0, 0x6d, 0xa8, 0xd8, 0x41, 0x90,
+        0xa8, 0xb6, 0x4e, 0xcb, 0x76, 0x10, 0x18, 0x8e, 0x8c, 0x2d, 0x0a, 0x6a, 0x9b, 0xc7, 0x96, 0x4f,
+        0x01, 0x1c, 0x36, 0x71, 0x3d, 0x17, 0x85, 0x2e, 0xa2, 0xc1, 0xab, 0x8b, 0x42, 0xd3, 0x0c, 0x86,
+        0x7c, 0x09, 0xe5, 0x28, 0xb6, 0x63, 0x91, 0x2b, 0x9b, 0xdb, 0xf7, 0x33, 0xe0, 0xbc, 0x08, 0x9d,
+        0x11, 0x87, 0x51, 0x81, 0x26, 0x5f, 0xc1, 0x2d, 0xdf, 0x9b, 0x9e, 0x59, 0xf3, 0x88, 0x59, 0xee,
+        0xc4, 0x0a, 0xd9, 0x0f, 0x73, 0x37, 0x64, 0x4e, 0x3e, 0xa7, 0xae, 0x73, 0xc8, 0x51, 0xc4, 0x8c,
+        0x09, 0x95, 0x7c, 0xed, 0x6b, 0x28, 0xe3, 0x3a, 0x7c, 0xcf, 0xdf, 0x51, 0xc3, 0xd4, 0xad, 0xe1,
+        0xa0, 0xff, 0x54, 0xe8, 0x80, 0xea, 0xdd, 0x9e, 0x85, 0x44, 0x55, 0xe1, 0xc1, 0xbe, 0xa7, 0xf7,
+        0x75, 0x53, 0xef, 0xa9, 0x45, 0x9e, 0x3d, 0x74, 0x4a, 0x87, 0x54, 0x2d, 0x69, 0xff, 0x53, 0x80,
+        0x15, 0x94, 0xe7, 0xd0, 0x8f, 0xe2, 0x89, 0xfb, 0x92, 0xec, 0x41, 0x43, 0x98, 0xdd, 0xa9, 0x2c,
+        0xe8, 0xb9, 0x33, 0x68, 0x8b, 0x7b, 0x96, 0x68, 0x31, 0x90, 0x75, 0xb4, 0x9b, 0x3e, 0x27, 0x21,
+        0x45, 0x41, 0xa7, 0xbf, 0x22, 0xa4, 0xbc, 0x05, 0x95, 0x67, 0x6c, 0xe2, 0x87, 0x22, 0x04, 0xd6,
+        0x76, 0x4a, 0x71, 0x38, 0x67, 0x54, 0xd2, 0xda, 0x36, 0xc0, 0xf9, 0xfa, 0xe4, 0x01, 0xac, 0x26,
+        0xc6, 0x66, 0xa1, 0x71, 0x89, 0x93, 0x5b, 0x49, 0x88, 0x83, 0x5c, 0x75, 0xa3, 0x5c, 0xab, 0xba,
+        0xd1, 0xbe, 0x86, 0xd5, 0x64, 0x3f, 0xe2, 0xfc, 0x54, 0x21, 0x79, 0x01, 0x63, 0xca, 0x82, 0x8c,
+        0xca, 0x45, 0x19, 0xb5, 0x9f, 0x41, 0x6d, 0xe4, 0xd9, 0x41, 0x74, 0xe2, 0xc7, 0xdc, 0x7a, 0xe2,
+        0x48, 0xfa, 0xaa, 0x12, 0x47, 0x9a, 0x06, 0x15, 0x7e, 0x38, 0xf3, 0x88, 0xbb, 0xbf, 0x31, 0xe8,
+        0xee, 0x99, 0xc6, 0xb7, 0xba, 0xfa, 0x06, 0x01, 0xa8, 0xc8, 0xe7, 0x82, 0xa6, 0x41, 0xd3, 0x90,
+        0xed, 0xd8, 0x63, 0x66, 0x3b, 0x2c, 0xe4, 0x12, 0xfc, 0xe0, 0x47, 0x89, 0x04, 0x3f, 0xf8, 0x91,
+        0xf6, 0x17, 0x05, 0x68, 0x98, 0xa1, 0xed, 0x45, 0xb6, 0x30, 0xf7, 0xcf, 0xa0, 0x72, 0x82, 0x58,
+        0x74, 0xa3, 0xc6, 0x82, 0x7f, 0x66, 0x17, 0xa3, 0x12, 0x48, 0xee, 0x40, 0xe5, 0xc4, 0xf6, 0x9c,
+        0xa9, 0xd0, 0x5a, 0x85, 0xca, 0x51, 0x92, 0x1b, 0x95, 0xf3, 0xdc, 0xb8, 0x05, 0x2b, 0x33, 0x3b,
+        0x7c, 0x6e, 0x8d, 0x4f, 0x6c, 0xef, 0x98, 0x45, 0xf2, 0x60, 0xa4, 0x05, 0x36, 0x38, 0x6b, 0x4f,
+        0x70, 0xb4, 0xbf, 0x5f, 0x81, 0xf2, 0x37, 0x73, 0x16, 0x9e, 0x65, 0x04, 0xfa, 0xe0, 0xba, 0x02,
+        0xc9, 0x17, 0x17, 0x2e, 0x4b, 0xca, 0x6f, 0x2f, 0x26, 0x65, 0x22, 0x53, 0x84, 0xc8, 0x95, 0x22,
+        0x0b, 0x7c, 0x9a, 0x09, 0x63, 0xeb, 0x57, 0xd8, 0xda, 0x79, 0x70, 0x7b, 0x08, 0x95, 0x89, 0x3b,
+        0x8d, 0x51, 0x75, 0x8b, 0xd5, 0x08, 0xee, 0xa5, 0xf3, 0x08, 0xd9, 0x54, 0xc2, 0xc8, 0xbb, 0xb0,
+        0x22, 0x2a, 0x59, 0xeb, 0x07, 0xce, 0xc6, 0x82, 0x95, 0xf7, 0xa6, 0x48, 0x13, 0xbb, 0xff, 0x18,
+        0xca, 0x7e, 0xc8, 0x37, 0x5f, 0xc7, 0x25, 0xef, 0x5c, 0x58, 0x72, 0xc8, 0xb9, 0x54, 0x80, 0xc8,
+        0x87, 0x50, 0x3a, 0x71, 0xbd, 0x18, 0xb3, 0x46, 0x73, 0xfb, 0xf6, 0x05, 0xf0, 0x63, 0xd7, 0x8b,
+        0x29, 0x42, 0x78, 0x98, 0x1f, 0xfb, 0x73, 0x2f, 0x6e, 0xdd, 0xc5, 0x0c, 0x23, 0x06, 0xe4, 0x1e,
+        0x54, 0xfc, 0xc9, 0x24, 0x62, 0x31, 0x76, 0x96, 0xe5, 0x9d, 0xc2, 0xa7, 0x54, 0x12, 0xf8, 0x84,
+        0xa9, 0x3b, 0x73, 0x63, 0xec, 0x43, 0xca, 0x54, 0x0c, 0xc8, 0x2e, 0xac, 0x8d, 0xfd, 0x59, 0xe0,
+        0x4e, 0x99, 0x63, 0x8d, 0xe7, 0x61, 0xe4, 0x87, 0xad, 0x77, 0x2e, 0x1c, 0xd3, 0x9e, 0x44, 0xec,
+        0x21, 0x80, 0x36, 0xc7, 0xb9, 0x31, 0x31, 0x60, 0x83, 0x79, 0x8e, 0xb5, 0xb8, 0xce, 0xfd, 0xd7,
+        0xad, 0xb3, 0xce, 0x3c, 0x27, 0x4f, 0x4a, 0xc4, 0xc1, 0x48, 0x68, 0x61, 0xcc, 0x68, 0x6d, 0x60,
+        0x90, 0xb9, 0x77, 0x69, 0xac, 0x14, 0xe2, 0x64, 0xc2, 0xf7, 0x6f, 0xc0, 0x2d, 0x19, 0x22, 0xad,
+        0x80, 0x85, 0x13, 0x36, 0x8e, 0xad, 0x60, 0x6a, 0x7b, 0x58, 0xca, 0xa5, 0xc6, 0x4a, 0x24, 0xe4,
+        0x50, 0x20, 0x0e, 0xa7, 0xb6, 0x47, 0x34, 0xa8, 0x3f, 0x67, 0x67, 0x91, 0xc5, 0x23, 0x29, 0x76,
+        0xae, 0x29, 0xba, 0xc6, 0xe9, 0x43, 0x6f, 0x7a, 0x46, 0x7e, 0x02, 0x8d, 0xf8, 0xdc, 0xdb, 0xb0,
+        0x61, 0x6d, 0xe4, 0x4e, 0x35, 0xe3, 0x8b, 0x34, 0x0b, 0x25, 0xf7, 0xa1, 0x2a, 0x35, 0xd4, 0xba,
+        0x97, 0x5d, 0x3b, 0xa1, 0xf2, 0xc4, 0x3c, 0xb1, 0xdd, 0xa9, 0x7f, 0xca, 0x42, 0x6b, 0x16, 0xb5,
+        0xda, 0xe2, 0xb6, 0x24, 0x21, 0x1d, 0x44, 0xdc, 0x4f, 0xa3, 0x38, 0xf4, 0xbd, 0xe3, 0xd6, 0x26,
+        0xde, 0x93, 0xc8, 0xd1, 0xc5, 0xe0, 0xf7, 0x2e, 0x66, 0xfe, 0x7c, 0xf0, 0xfb, 0x1c, 0xee, 0x60,
+        0x65, 0x66, 0x3d, 0x3b, 0xb3, 0xf2, 0x68, 0x0d, 0xd1, 0x1b, 0xc8, 0xdd, 0x3d, 0x3b, 0xcc, 0x4e,
+        0x6a, 0x43, 0xcd, 0x71, 0xa3, 0xd8, 0xf5, 0xc6, 0x71, 0xab, 0x85, 0xef, 0x4c, 0xc7, 0xe4, 0x33,
+        0xb8, 0x3d, 0x73, 0x3d, 0x2b, 0xb2, 0x27, 0xcc, 0x8a, 0x5d, 0xee, 0x9b, 0x6c, 0xec, 0x7b, 0x4e,
+        0xd4, 0x7a, 0x80, 0x82, 0x93, 0x99, 0xeb, 0x8d, 0xec, 0x09, 0x33, 0xdd, 0x19, 0x1b, 0x09, 0x0e,
+        0xf9, 0x08, 0xd6, 0x11, 0x1e, 0xb2, 0x60, 0xea, 0x8e, 0x6d, 0xf1, 0xfa, 0x1f, 0xe1, 0xeb, 0xd7,
+        0x38, 0x83, 0x0a, 0x3a, 0xbe, 0xfa, 0x63, 0x68, 0x06, 0x2c, 0x8c, 0xdc, 0x28, 0xb6, 0xa4, 0x45,
+        0xbf, 0x97, 0xd5, 0xda, 0xaa, 0x64, 0x0e, 0x91, 0xd7, 0xfe, 0xcf, 0x02, 0x54, 0x84, 0x73, 0x92,
+        0x4f, 0x41, 0xf1, 0x03, 0xbc, 0x06, 0x69, 0x6e, 0x6f, 0x5e, 0xe2, 0xc1, 0x9d, 0x61, 0xc0, 0xeb,
+        0x5e, 0x3f, 0xa4, 0x8a, 0x1f, 0xdc, 0xb8, 0x28, 0xd4, 0xfe, 0x10, 0x6a, 0xc9, 0x02, 0xbc, 0xbc,
+        0xe8, 0xeb, 0xa3, 0x91, 0x65, 0x3e, 0xee, 0x0e, 0xd4, 0x02, 0xb9, 0x03, 0x24, 0x1d, 0x5a, 0x43,
+        0x6a, 0xe9, 0xdf, 0x1c, 0x75, 0xfb, 0xaa, 0x82, 0x5d, 0x1a, 0xd5, 0xbb, 0xa6, 0x4e, 0x05, 0xb2,
+        0x48, 0xee, 0xc1, 0xed, 0x2c, 0xe5, 0x1c, 0x5c, 0xc2, 0x14, 0x8c, 0x8f, 0x65, 0x52, 0x01, 0xc5,
+        0x18, 0xa8, 0x15, 0x9e, 0x16, 0xf4, 0xef, 0x8d, 0x91, 0x39, 0x52, 0xab, 0xed, 0xbf, 0x29, 0x40,
+        0x19, 0xc3, 0x06, 0x3f, 0x9f, 0x54, 0x72, 0x71, 0x5d, 0x73, 0x5e, 0xb9, 0x1a, 0xd9, 0x92, 0xaa,
+        0x81, 0x01, 0x65, 0x73, 0x79, 0xf4, 0xf9, 0xb5, 0xd6, 0x53, 0x3f, 0x85, 0x12, 0x8f, 0x52, 0xbc,
+        0x43, 0x1c, 0xd2, 0x9e, 0x4e, 0xad, 0x47, 0x06, 0x1d, 0xf1, 0x2a, 0x97, 0x40, 0xb3, 0x3b, 0xd8,
+        0xd3, 0x47, 0xe6, 0x30, 0xa1, 0xa1, 0x56, 0x1e, 0x19, 0x7d, 0x33, 0x45, 0x15, 0xb5, 0x9f, 0xd7,
+        0x60, 0x35, 0x89, 0x09, 0x22, 0x82, 0x3e, 0x82, 0x46, 0x10, 0xba, 0x33, 0x3b, 0x3c, 0x8b, 0xc6,
+        0xb6, 0x87, 0x49, 0x01, 0xb6, 0x7f, 0xb4, 0x24, 0xaa, 0x88, 0x1d, 0x1d, 0x0a, 0xec, 0x68, 0x6c,
+        0x7b, 0x34, 0x3b, 0x91, 0xf4, 0x61, 0x75, 0xc6, 0xc2, 0x63, 0xf6, 0x7b, 0xbe, 0xeb, 0xe1, 0x4a,
+        0x55, 0x8c, 0xc8, 0xef, 0x5f, 0xba, 0xd2, 0x01, 0x47, 0xff, 0x8e, 0xef, 0x7a, 0xb8, 0x56, 0x7e,
+        0x32, 0xf9, 0x04, 0xea, 0xa2, 0x12, 0x72, 0xd8, 0x04, 0x63, 0xc5, 0xb2, 0xda, 0x4f, 0xd4, 0xe8,
+        0x3d, 0x36, 0xc9, 0xc4, 0x65, 0xb8, 0x34, 0x2e, 0x37, 0xb2, 0x71, 0xf9, 0xcd, 0x6c, 0x2c, 0x5a,
+        0x11, 0x55, 0x78, 0x1a, 0x84, 0x2e, 0x38, 0x7c, 0x6b, 0x89, 0xc3, 0x77, 0x60, 0x23, 0xf1, 0x55,
+        0xcb, 0xf5, 0x26, 0xee, 0x4b, 0x2b, 0x72, 0x5f, 0x89, 0xd8, 0x53, 0xa6, 0xeb, 0x09, 0xcb, 0xe0,
+        0x9c, 0x91, 0xfb, 0x8a, 0x11, 0x23, 0xe9, 0xe0, 0x64, 0x0e, 0x5c, 0xc5, 0xab, 0xc9, 0xf7, 0x2e,
+        0x55, 0x8f, 0x68, 0xbe, 0x64, 0x46, 0xcc, 0x4d, 0x6d, 0xff, 0x52, 0x81, 0x46, 0xe6, 0x1c, 0x78,
+        0xf6, 0x16, 0xca, 0x42, 0x61, 0xc5, 0x55, 0x94, 0x50, 0x1f, 0x4a, 0xfa, 0x26, 0xd4, 0xa3, 0xd8,
+        0x0e, 0x63, 0x8b, 0x17, 0x57, 0xb2, 0xdd, 0x45, 0xc2, 0x13, 0x76, 0x46, 0x3e, 0x80, 0x35, 0xc1,
+        0x74, 0xbd, 0xf1, 0x74, 0x1e, 0xb9, 0xa7, 0xa2, 0x99, 0xaf, 0xd1, 0x26, 0x92, 0x8d, 0x84, 0x4a,
+        0xee, 0x42, 0x95, 0x67, 0x21, 0xbe, 0x86, 0x68, 0xfa, 0x2a, 0xcc, 0x73, 0xf8, 0x0a, 0x0f, 0x60,
+        0x95, 0x33, 0xce, 0xe7, 0x57, 0xc4, 0x2d, 0x33, 0xf3, 0x9c, 0xf3, 0xd9, 0x1d, 0xd8, 0x10, 0xaf,
+        0x09, 0x44, 0xf1, 0x2a, 0x2b, 0xdc, 0x3b, 0xa8, 0xd8, 0x75, 0x64, 0xc9, 0xb2, 0x56, 0x14, 0x9c,
+        0x1f, 0x01, 0xcf, 0x5e, 0x0b, 0xe8, 0xbb, 0x22, 0x94, 0x31, 0xcf, 0xc9, 0x61, 0x77, 0xe1, 0x1d,
+        0x8e, 0x9d, 0x7b, 0x76, 0x10, 0x4c, 0x5d, 0xe6, 0x58, 0x53, 0xff, 0x18, 0x43, 0x66, 0x14, 0xdb,
+        0xb3, 0xc0, 0x9a, 0x47, 0xad, 0x0d, 0x0c, 0x99, 0x6d, 0xe6, 0x39, 0x47, 0x09, 0xa8, 0xef, 0x1f,
+        0x9b, 0x09, 0xe4, 0x28, 0x6a, 0xff, 0x3e, 0xac, 0xe6, 0xec, 0x71, 0x41, 0xa7, 0x35, 0x74, 0xfe,
+        0x8c, 0x4e, 0xdf, 0x85, 0x95, 0x20, 0x64, 0xe7, 0xa2, 0xd5, 0x51, 0xb4, 0x86, 0xa0, 0x09, 0xb1,
+        0xb6, 0x60, 0x05, 0x79, 0x96, 0x20, 0xe6, 0xf3, 0x63, 0x03, 0x59, 0x87, 0xc8, 0x69, 0xbf, 0x80,
+        0x95, 0xec, 0x69, 0x93, 0x77, 0x33, 0x69, 0xa1, 0x99, 0xcb, 0x93, 0x69, 0x76, 0x48, 0x2a, 0xb2,
+        0xf5, 0x4b, 0x2a, 0x32, 0x72, 0x9d, 0x8a, 0x4c, 0xfb, 0x2f, 0xd9, 0x9c, 0x65, 0x2a, 0x84, 0x9f,
+        0x41, 0x2d, 0x90, 0xf5, 0x38, 0x5a, 0x52, 0xfe, 0x12, 0x3e, 0x0f, 0xee, 0x24, 0x95, 0x3b, 0x4d,
+        0xe7, 0xb4, 0xff, 0x56, 0x81, 0x5a, 0x5a, 0xd0, 0xe7, 0x2c, 0xef, 0xcd, 0x05, 0xcb, 0x3b, 0x90,
+        0x1a, 0x16, 0x0a, 0x7c, 0x1b, 0xa3, 0xc5, 0x27, 0xaf, 0x7f, 0xd7, 0xc5, 0xb6, 0xe7, 0x34, 0xdb,
+        0xf6, 0x6c, 0xbe, 0xae, 0xed, 0xf9, 0xe4, 0xa2, 0xc1, 0xbf, 0x95, 0xe9, 0x2d, 0x16, 0xcc, 0xbe,
+        0xfd, 0x7d, 0xae, 0x0f, 0xca, 0x26, 0x84, 0x77, 0xc4, 0x7e, 0xd2, 0x84, 0x90, 0xb6, 0x3f, 0xf7,
+        0xaf, 0xd7, 0xfe, 0x6c, 0x43, 0x45, 0xea, 0xfc, 0x0e, 0x54, 0x64, 0x4d, 0x27, 0x1b, 0x04, 0x31,
+        0x3a, 0x6f, 0x10, 0x0a, 0xb2, 0x4e, 0xd7, 0x7e, 0xae, 0x40, 0x59, 0x0f, 0x43, 0x3f, 0xd4, 0xfe,
+        0x48, 0x81, 0x3a, 0x3e, 0xed, 0xf9, 0x0e, 0xe3, 0xd9, 0x60, 0xb7, 0xdb, 0xb3, 0xa8, 0xfe, 0xcd,
+        0x91, 0x8e, 0xd9, 0xa0, 0x0d, 0x77, 0xf6, 0x86, 0x83, 0xbd, 0x23, 0x4a, 0xf5, 0x81, 0x69, 0x99,
+        0xb4, 0x3b, 0x18, 0xf1, 0xb6, 0x67, 0x38, 0x50, 0x15, 0x9e, 0x29, 0x8c, 0x81, 0xa9, 0xd3, 0x41,
+        0xb7, 0x6f, 0x89, 0x56, 0xb4, 0x88, 0x77, 0xb3, 0xba, 0xde, 0xb3, 0xf0, 0xd6, 0x51, 0x2d, 0xf1,
+        0x96, 0xd5, 0x34, 0x0e, 0xf4, 0xe1, 0x91, 0xa9, 0x96, 0xc9, 0x6d, 0x58, 0x3f, 0xd4, 0xe9, 0x81,
+        0x31, 0x1a, 0x19, 0xc3, 0x81, 0xd5, 0xd3, 0x07, 0x86, 0xde, 0x53, 0x2b, 0x7c, 0x9d, 0x5d, 0x63,
+        0xdf, 0xec, 0xee, 0xf6, 0x75, 0xb9, 0x4e, 0x95, 0x6c, 0xc2, 0x5b, 0x7b, 0xc3, 0x83, 0x03, 0xc3,
+        0x34, 0xf5, 0x9e, 0xb5, 0x7b, 0x64, 0x5a, 0x23, 0xd3, 0xe8, 0xf7, 0xad, 0xee, 0xe1, 0x61, 0xff,
+        0x29, 0x4f, 0x60, 0x35, 0x72, 0x17, 0x36, 0xf6, 0xba, 0x87, 0xdd, 0x5d, 0xa3, 0x6f, 0x98, 0x4f,
+        0xad, 0x9e, 0x31, 0xe2, 0xf3, 0x7b, 0x6a, 0x9d, 0x27, 0x6c, 0x93, 0x3e, 0xb5, 0xba, 0x7d, 0x14,
+        0xcd, 0xd4, 0xad, 0xdd, 0xee, 0xde, 0x13, 0x7d, 0xd0, 0x53, 0x81, 0x0b, 0x30, 0xea, 0x3e, 0xd2,
+        0x2d, 0x2e, 0x92, 0x65, 0x0e, 0x87, 0xd6, 0xb0, 0xdf, 0x53, 0x1b, 0xda, 0xbf, 0x14, 0xa1, 0xb4,
+        0xe7, 0x47, 0x31, 0xf7, 0x46, 0xe1, 0xac, 0x2f, 0x42, 0x37, 0x66, 0xa2, 0x7f, 0x2b, 0x53, 0xd1,
+        0x4b, 0x7f, 0x87, 0x24, 0x1e, 0x50, 0x32, 0x10, 0xeb, 0xd9, 0x19, 0xc7, 0x29, 0x88, 0x5b, 0x3b,
+        0xc7, 0xed, 0x72, 0xb2, 0x88, 0x68, 0x78, 0x85, 0x23, 0xd7, 0x2b, 0x22, 0x4e, 0x06, 0x61, 0xb9,
+        0xe0, 0xc7, 0x40, 0xb2, 0x20, 0xb9, 0x62, 0x09, 0x91, 0x6a, 0x06, 0x29, 0x96, 0xdc, 0x01, 0x18,
+        0xfb, 0xb3, 0x99, 0x1b, 0x8f, 0xfd, 0x28, 0x96, 0x5f, 0xc8, 0xda, 0x39, 0x63, 0x8f, 0x62, 0x6e,
+        0xf1, 0x33, 0x37, 0xe6, 0x8f, 0x34, 0x83, 0x26, 0x3b, 0x70, 0xcf, 0x0e, 0x82, 0xd0, 0x7f, 0xe9,
+        0xce, 0xec, 0x98, 0x59, 0xdc, 0x73, 0xed, 0x63, 0x66, 0x39, 0x6c, 0x1a, 0xdb, 0xd8, 0x13, 0x95,
+        0xe9, 0xdd, 0x0c, 0x60, 0x24, 0xf8, 0x3d, 0xce, 0xe6, 0x71, 0xd7, 0x75, 0xac, 0x88, 0xfd, 0x30,
+        0xe7, 0x1e, 0x60, 0xcd, 0x03, 0xc7, 0xe6, 0x62, 0xd6, 0x45, 0x96, 0x72, 0x9d, 0x91, 0xe4, 0x1c,
+        0x09, 0x46, 0xfb, 0x15, 0xc0, 0xb9, 0x14, 0x64, 0x1b, 0x6e, 0xf3, 0x3a, 0x9e, 0x45, 0x31, 0x73,
+        0x2c, 0xb9, 0xdb, 0x60, 0x1e, 0x47, 0x18, 0xe2, 0xcb, 0x74, 0x23, 0x65, 0xca, 0x9b, 0xc2, 0x79,
+        0x1c, 0x91, 0x9f, 0x40, 0xeb, 0xc2, 0x1c, 0x87, 0x4d, 0x19, 0x7f, 0x6d, 0x15, 0xa7, 0xdd, 0x59,
+        0x98, 0xd6, 0x13, 0x5c, 0xed, 0x4f, 0x14, 0x80, 0x7d, 0x16, 0x53, 0xc1, 0xcd, 0x34, 0xb6, 0x95,
+        0xeb, 0x36, 0xb6, 0xef, 0x27, 0x17, 0x08, 0xc5, 0xab, 0x63, 0xc0, 0x42, 0x97, 0xa1, 0xdc, 0xa4,
+        0xcb, 0xc8, 0x35, 0x11, 0xc5, 0x2b, 0x9a, 0x88, 0x52, 0xae, 0x89, 0xf8, 0x18, 0x9a, 0xf6, 0x74,
+        0xea, 0xbf, 0xe0, 0x05, 0x0d, 0x0b, 0x43, 0xe6, 0xa0, 0x11, 0x9c, 0xd7, 0xdb, 0xc8, 0xec, 0x49,
+        0x9e, 0xf6, 0xe7, 0x0a, 0x34, 0x50, 0x15, 0x51, 0xe0, 0x7b, 0x11, 0x23, 0x5f, 0x42, 0x45, 0x5e,
+        0x44, 0x8b, 0x8b, 0xfc, 0xb7, 0x33, 0xb2, 0x66, 0x70, 0xb2, 0x68, 0xa0, 0x12, 0xcc, 0x33, 0x42,
+        0xe6, 0x75, 0x97, 0x2b, 0x25, 0x45, 0x91, 0xfb, 0x50, 0x73, 0x3d, 0x4b, 0xb4, 0xd4, 0x95, 0x4c,
+        0x58, 0xac, 0xba, 0x1e, 0xd6, 0xb2, 0xed, 0x57, 0x50, 0x11, 0x2f, 0x21, 0x9d, 0x54, 0xa6, 0x8b,
+        0xfa, 0xcb, 0xdc, 0x1c, 0xa7, 0xc2, 0xc8, 0xc3, 0x29, 0xbd, 0x2e, 0x40, 0xb7, 0xa0, 0x7a, 0xca,
+        0x9b, 0x0f, 0xbc, 0xf4, 0xe3, 0xea, 0x4d, 0x86, 0xda, 0x1f, 0x97, 0x00, 0x0e, 0xe7, 0x4b, 0x0c,
+        0xa4, 0x71, 0x5d, 0x03, 0xe9, 0xe4, 0xf4, 0xf8, 0x7a, 0x99, 0x7f, 0x75, 0x43, 0x59, 0xd2, 0x69,
+        0x17, 0x6f, 0xda, 0x69, 0xdf, 0x87, 0x6a, 0x1c, 0xce, 0xb9, 0xa3, 0x08, 0x63, 0x4a, 0x5b, 0x5a,
+        0x49, 0x25, 0x6f, 0x42, 0x79, 0xe2, 0x87, 0x63, 0x86, 0x8e, 0x95, 0xb2, 0x05, 0xed, 0xc2, 0x65,
+        0x52, 0xed, 0xb2, 0xcb, 0x24, 0xde, 0xa0, 0x45, 0xf2, 0x1e, 0x0d, 0x0b, 0x99, 0x7c, 0x83, 0x96,
+        0x5c, 0xb1, 0xd1, 0x14, 0x44, 0xbe, 0x81, 0xa6, 0x3d, 0x8f, 0x7d, 0xcb, 0xe5, 0x15, 0xda, 0xd4,
+        0x1d, 0x9f, 0x61, 0xd9, 0xdd, 0xcc, 0x7f, 0xaf, 0x4f, 0x0f, 0xaa, 0xd3, 0x9d, 0xc7, 0xbe, 0xe1,
+        0x1c, 0x22, 0x72, 0xa7, 0x2a, 0x93, 0x12, 0x5d, 0xb1, 0x33, 0x64, 0xed, 0xc7, 0xb0, 0x92, 0x85,
+        0xf1, 0x04, 0x24, 0x81, 0xea, 0x1b, 0x3c, 0x3b, 0x8d, 0x78, 0x6a, 0x1b, 0x98, 0x46, 0xb7, 0xaf,
+        0x16, 0xb4, 0x18, 0x1a, 0xb8, 0xbc, 0xf4, 0x8e, 0xeb, 0xba, 0xfd, 0x03, 0x28, 0x61, 0xf8, 0x55,
+        0x2e, 0x7c, 0x0f, 0xc1, 0x98, 0x8b, 0xcc, 0xbc, 0xf9, 0x15, 0xb3, 0xe6, 0xf7, 0xdf, 0x05, 0x58,
+        0x31, 0xfd, 0xf9, 0xf8, 0xe4, 0xa2, 0x01, 0xc2, 0xaf, 0x3b, 0x42, 0x2d, 0x31, 0x1f, 0xe5, 0xa6,
+        0xe6, 0x93, 0x5a, 0x47, 0x71, 0x89, 0x75, 0xdc, 0xf4, 0xcc, 0xb5, 0x2f, 0x60, 0x55, 0x6e, 0x5e,
+        0x6a, 0x3d, 0xd1, 0x66, 0xe1, 0x0a, 0x6d, 0x6a, 0xbf, 0x50, 0x60, 0x55, 0xc4, 0xf7, 0xff, 0xbb,
+        0xd2, 0x2a, 0x37, 0x0c, 0xeb, 0xe5, 0x1b, 0x5d, 0x1e, 0xfd, 0xbf, 0xf4, 0x34, 0x6d, 0x08, 0xcd,
+        0x44, 0x7d, 0x37, 0x50, 0xfb, 0x15, 0x46, 0xfc, 0x8b, 0x02, 0x34, 0x06, 0xec, 0xe5, 0x92, 0x20,
+        0x5a, 0xbe, 0xee, 0x71, 0x7c, 0x98, 0x2b, 0x57, 0x1b, 0xdb, 0xeb, 0x59, 0x19, 0xc4, 0xd5, 0x63,
+        0x52, 0xc1, 0xa6, 0xb7, 0xa8, 0xca, 0xf2, 0x5b, 0xd4, 0xd2, 0x62, 0xb7, 0x9e, 0xb9, 0xc5, 0x2b,
+        0x2e, 0xbb, 0xc5, 0xd3, 0xfe, 0xad, 0x08, 0x0d, 0x6c, 0x90, 0x29, 0x8b, 0xe6, 0xd3, 0x38, 0x27,
+        0x4c, 0xe1, 0x6a, 0x61, 0x3a, 0x50, 0x09, 0x71, 0x92, 0x74, 0xa5, 0x4b, 0x83, 0xbf, 0x40, 0x61,
+        0x6b, 0xfc, 0xdc, 0x0d, 0x02, 0xe6, 0x58, 0x82, 0x92, 0x14, 0x30, 0x4d, 0x49, 0x16, 0x22, 0x44,
+        0xbc, 0xfc, 0x9c, 0xf9, 0x21, 0x4b, 0x51, 0x45, 0xbc, 0x4f, 0x68, 0x70, 0x5a, 0x02, 0xc9, 0xdd,
+        0x37, 0x88, 0xca, 0xe0, 0xfc, 0xbe, 0x21, 0xed, 0x35, 0x91, 0x5b, 0x47, 0xae, 0xe8, 0x35, 0x91,
+        0xcd, 0xbb, 0xa8, 0x99, 0x3d, 0x9d, 0x5a, 0x7e, 0x10, 0xa1, 0xd3, 0xd4, 0x68, 0x0d, 0x09, 0xc3,
+        0x20, 0x22, 0x5f, 0x43, 0x7a, 0x5d, 0x2c, 0x6f, 0xc9, 0xc5, 0x39, 0xb6, 0x2e, 0xbb, 0x58, 0xa0,
+        0xab, 0xe3, 0xdc, 0xfd, 0xcf, 0x92, 0x1b, 0xea, 0xca, 0x4d, 0x6f, 0xa8, 0x1f, 0x42, 0x59, 0xc4,
+        0xa8, 0xda, 0xeb, 0x62, 0x94, 0xc0, 0x65, 0xed, 0xb3, 0x91, 0xb7, 0xcf, 0x5f, 0x16, 0x80, 0x74,
+        0xa7, 0x53, 0x7f, 0x6c, 0xc7, 0xcc, 0x70, 0xa2, 0x8b, 0x66, 0x7a, 0xed, 0xcf, 0x2e, 0x9f, 0x41,
+        0x7d, 0xe6, 0x3b, 0x6c, 0x6a, 0x25, 0xdf, 0x94, 0x2e, 0xad, 0x7e, 0x10, 0xc6, 0x5b, 0x52, 0x02,
+        0x25, 0xbc, 0xc4, 0x51, 0xb0, 0xee, 0xc0, 0x67, 0xde, 0x84, 0xcd, 0xec, 0x97, 0xb2, 0x14, 0xe1,
+        0x8f, 0xa4, 0x03, 0xd5, 0x90, 0x45, 0x2c, 0x3c, 0x65, 0x57, 0x16, 0x55, 0x09, 0x48, 0x7b, 0x06,
+        0x1b, 0xb9, 0x1d, 0x49, 0x47, 0xbe, 0x85, 0x5f, 0x2b, 0xc3, 0x58, 0x7e, 0xb4, 0x12, 0x03, 0xfe,
+        0x3a, 0xe6, 0x25, 0x9f, 0x41, 0xf9, 0x63, 0xea, 0xf0, 0xc5, 0xab, 0xe2, 0xec, 0x1e, 0xa8, 0x59,
+        0x4d, 0xbb, 0x63, 0x0c, 0x36, 0xf2, 0x54, 0x0a, 0xd7, 0x3b, 0x15, 0xed, 0xef, 0x0a, 0xb0, 0xde,
+        0x75, 0x1c, 0xf1, 0x77, 0xc3, 0x25, 0xaa, 0x2f, 0x5e, 0x57, 0xf5, 0x0b, 0x81, 0x58, 0x84, 0x89,
+        0x6b, 0x05, 0xe2, 0x0f, 0xa1, 0x92, 0xd6, 0x5a, 0xc5, 0x05, 0x77, 0x16, 0x72, 0x51, 0x09, 0xd0,
+        0x6e, 0x01, 0xc9, 0x0a, 0x2b, 0xb4, 0xaa, 0xfd, 0x69, 0x11, 0xee, 0xee, 0xb2, 0x63, 0xd7, 0xcb,
+        0xbe, 0xe2, 0x57, 0xdf, 0xc9, 0xc5, 0x4f, 0x65, 0x9f, 0xc1, 0xba, 0x28, 0xe4, 0x93, 0x7f, 0x62,
+        0x59, 0xec, 0x58, 0x7e, 0x9d, 0x94, 0xb1, 0x6a, 0x0d, 0xf9, 0x07, 0x92, 0xad, 0xe3, 0x7f, 0xc5,
+        0x1c, 0x3b, 0xb6, 0x9f, 0xd9, 0x11, 0xb3, 0x5c, 0x47, 0xfe, 0x59, 0x06, 0x12, 0x92, 0xe1, 0x90,
+        0x21, 0x94, 0xb8, 0x0d, 0xa2, 0xeb, 0x36, 0xb7, 0xb7, 0x33, 0x62, 0x5d, 0xb2, 0x95, 0xac, 0x02,
+        0x0f, 0x7c, 0x87, 0xed, 0x54, 0x8f, 0x06, 0x4f, 0x06, 0xc3, 0xef, 0x06, 0x14, 0x17, 0x22, 0x06,
+        0xdc, 0x0a, 0x42, 0x76, 0xea, 0xfa, 0xf3, 0xc8, 0xca, 0x9e, 0x44, 0xf5, 0xca, 0x94, 0xb8, 0x91,
+        0xcc, 0xc9, 0x10, 0xb5, 0x9f, 0xc2, 0xda, 0xc2, 0xcb, 0x78, 0x6d, 0x26, 0x5f, 0xa7, 0xbe, 0x41,
+        0x56, 0xa1, 0x8e, 0x1f, 0xbb, 0x97, 0x7f, 0xfb, 0xd6, 0xfe, 0xb5, 0x80, 0x57, 0x4c, 0x33, 0x37,
+        0xbe, 0x59, 0x06, 0xfb, 0xcd, 0x7c, 0x06, 0x83, 0xed, 0x77, 0xf3, 0xe6, 0x9b, 0x59, 0xb0, 0xf3,
+        0xad, 0x00, 0xa6, 0x41, 0xa4, 0x6d, 0x43, 0x55, 0xd2, 0xc8, 0x6f, 0xc1, 0x5a, 0xe8, 0xfb, 0x71,
+        0xd2, 0x89, 0x8a, 0x0e, 0xe4, 0xf2, 0x3f, 0xdb, 0xac, 0x72, 0xb0, 0x48, 0x06, 0x4f, 0xf2, 0xbd,
+        0x48, 0x59, 0xfc, 0x0d, 0x44, 0x0e, 0x77, 0x1b, 0xbf, 0x5b, 0x4f, 0xff, 0xb7, 0xfb, 0xbf, 0x01,
+        0x00, 0x00, 0xff, 0xff, 0x35, 0x9f, 0x30, 0x98, 0xf2, 0x2b, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.proto b/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.proto
new file mode 100644
index 0000000..497b4d9
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.proto
@@ -0,0 +1,551 @@
+syntax = "proto2";
+option go_package = "datastore";
+
+package appengine;
+
+message Action{}
+
+message PropertyValue {
+  optional int64 int64Value = 1;
+  optional bool booleanValue = 2;
+  optional string stringValue = 3;
+  optional double doubleValue = 4;
+
+  optional group PointValue = 5 {
+    required double x = 6;
+    required double y = 7;
+  }
+
+  optional group UserValue = 8 {
+    required string email = 9;
+    required string auth_domain = 10;
+    optional string nickname = 11;
+    optional string federated_identity = 21;
+    optional string federated_provider = 22;
+  }
+
+  optional group ReferenceValue = 12 {
+    required string app = 13;
+    optional string name_space = 20;
+    repeated group PathElement = 14 {
+      required string type = 15;
+      optional int64 id = 16;
+      optional string name = 17;
+    }
+  }
+}
+
+message Property {
+  enum Meaning {
+    NO_MEANING = 0;
+    BLOB = 14;
+    TEXT = 15;
+    BYTESTRING = 16;
+
+    ATOM_CATEGORY = 1;
+    ATOM_LINK = 2;
+    ATOM_TITLE = 3;
+    ATOM_CONTENT = 4;
+    ATOM_SUMMARY = 5;
+    ATOM_AUTHOR = 6;
+
+    GD_WHEN = 7;
+    GD_EMAIL = 8;
+    GEORSS_POINT = 9;
+    GD_IM = 10;
+
+    GD_PHONENUMBER = 11;
+    GD_POSTALADDRESS = 12;
+
+    GD_RATING = 13;
+
+    BLOBKEY = 17;
+    ENTITY_PROTO = 19;
+
+    INDEX_VALUE = 18;
+  };
+
+  optional Meaning meaning = 1 [default = NO_MEANING];
+  optional string meaning_uri = 2;
+
+  required string name = 3;
+
+  required PropertyValue value = 5;
+
+  required bool multiple = 4;
+
+  optional bool searchable = 6 [default=false];
+
+  enum FtsTokenizationOption {
+    HTML = 1;
+    ATOM = 2;
+  }
+
+  optional FtsTokenizationOption fts_tokenization_option = 8;
+
+  optional string locale = 9 [default = "en"];
+}
+
+message Path {
+  repeated group Element = 1 {
+    required string type = 2;
+    optional int64 id = 3;
+    optional string name = 4;
+  }
+}
+
+message Reference {
+  required string app = 13;
+  optional string name_space = 20;
+  required Path path = 14;
+}
+
+message User {
+  required string email = 1;
+  required string auth_domain = 2;
+  optional string nickname = 3;
+  optional string federated_identity = 6;
+  optional string federated_provider = 7;
+}
+
+message EntityProto {
+  required Reference key = 13;
+  required Path entity_group = 16;
+  optional User owner = 17;
+
+  enum Kind {
+    GD_CONTACT = 1;
+    GD_EVENT = 2;
+    GD_MESSAGE = 3;
+  }
+  optional Kind kind = 4;
+  optional string kind_uri = 5;
+
+  repeated Property property = 14;
+  repeated Property raw_property = 15;
+
+  optional int32 rank = 18;
+}
+
+message CompositeProperty {
+  required int64 index_id = 1;
+  repeated string value = 2;
+}
+
+message Index {
+  required string entity_type = 1;
+  required bool ancestor = 5;
+  repeated group Property = 2 {
+    required string name = 3;
+    enum Direction {
+      ASCENDING = 1;
+      DESCENDING = 2;
+    }
+    optional Direction direction = 4 [default = ASCENDING];
+  }
+}
+
+message CompositeIndex {
+  required string app_id = 1;
+  required int64 id = 2;
+  required Index definition = 3;
+
+  enum State {
+    WRITE_ONLY = 1;
+    READ_WRITE = 2;
+    DELETED = 3;
+    ERROR = 4;
+  }
+  required State state = 4;
+
+  optional bool only_use_if_required = 6 [default = false];
+}
+
+message IndexPostfix {
+  message IndexValue {
+    required string property_name = 1;
+    required PropertyValue value = 2;
+  }
+
+  repeated IndexValue index_value = 1;
+
+  optional Reference key = 2;
+
+  optional bool before = 3 [default=true];
+}
+
+message IndexPosition {
+  optional string key = 1;
+
+  optional bool before = 2 [default=true];
+}
+
+message Snapshot {
+  enum Status {
+    INACTIVE = 0;
+    ACTIVE = 1;
+  }
+
+  required int64 ts = 1;
+}
+
+message InternalHeader {
+  optional string qos = 1;
+}
+
+message Transaction {
+  optional InternalHeader header = 4;
+  required fixed64 handle = 1;
+  required string app = 2;
+  optional bool mark_changes = 3 [default = false];
+}
+
+message Query {
+  optional InternalHeader header = 39;
+
+  required string app = 1;
+  optional string name_space = 29;
+
+  optional string kind = 3;
+  optional Reference ancestor = 17;
+
+  repeated group Filter = 4 {
+    enum Operator {
+      LESS_THAN = 1;
+      LESS_THAN_OR_EQUAL = 2;
+      GREATER_THAN = 3;
+      GREATER_THAN_OR_EQUAL = 4;
+      EQUAL = 5;
+      IN = 6;
+      EXISTS = 7;
+    }
+
+    required Operator op = 6;
+    repeated Property property = 14;
+  }
+
+  optional string search_query = 8;
+
+  repeated group Order = 9 {
+    enum Direction {
+      ASCENDING = 1;
+      DESCENDING = 2;
+    }
+
+    required string property = 10;
+    optional Direction direction = 11 [default = ASCENDING];
+  }
+
+  enum Hint {
+    ORDER_FIRST = 1;
+    ANCESTOR_FIRST = 2;
+    FILTER_FIRST = 3;
+  }
+  optional Hint hint = 18;
+
+  optional int32 count = 23;
+
+  optional int32 offset = 12 [default = 0];
+
+  optional int32 limit = 16;
+
+  optional CompiledCursor compiled_cursor = 30;
+  optional CompiledCursor end_compiled_cursor = 31;
+
+  repeated CompositeIndex composite_index = 19;
+
+  optional bool require_perfect_plan = 20 [default = false];
+
+  optional bool keys_only = 21 [default = false];
+
+  optional Transaction transaction = 22;
+
+  optional bool compile = 25 [default = false];
+
+  optional int64 failover_ms = 26;
+
+  optional bool strong = 32;
+
+  repeated string property_name = 33;
+
+  repeated string group_by_property_name = 34;
+
+  optional bool distinct = 24;
+
+  optional int64 min_safe_time_seconds = 35;
+
+  repeated string safe_replica_name = 36;
+
+  optional bool persist_offset = 37 [default=false];
+}
+
+message CompiledQuery {
+  required group PrimaryScan = 1 {
+    optional string index_name = 2;
+
+    optional string start_key = 3;
+    optional bool start_inclusive = 4;
+    optional string end_key = 5;
+    optional bool end_inclusive = 6;
+
+    repeated string start_postfix_value = 22;
+    repeated string end_postfix_value = 23;
+
+    optional int64 end_unapplied_log_timestamp_us = 19;
+  }
+
+  repeated group MergeJoinScan = 7 {
+    required string index_name = 8;
+
+    repeated string prefix_value = 9;
+
+    optional bool value_prefix = 20 [default=false];
+  }
+
+  optional Index index_def = 21;
+
+  optional int32 offset = 10 [default = 0];
+
+  optional int32 limit = 11;
+
+  required bool keys_only = 12;
+
+  repeated string property_name = 24;
+
+  optional int32 distinct_infix_size = 25;
+
+  optional group EntityFilter = 13 {
+    optional bool distinct = 14 [default=false];
+
+    optional string kind = 17;
+    optional Reference ancestor = 18;
+  }
+}
+
+message CompiledCursor {
+  optional group Position = 2 {
+    optional string start_key = 27;
+
+    repeated group IndexValue = 29 {
+      optional string property = 30;
+      required PropertyValue value = 31;
+    }
+
+    optional Reference key = 32;
+
+    optional bool start_inclusive = 28 [default=true];
+  }
+}
+
+message Cursor {
+  required fixed64 cursor = 1;
+
+  optional string app = 2;
+}
+
+message Error {
+  enum ErrorCode {
+    BAD_REQUEST = 1;
+    CONCURRENT_TRANSACTION = 2;
+    INTERNAL_ERROR = 3;
+    NEED_INDEX = 4;
+    TIMEOUT = 5;
+    PERMISSION_DENIED = 6;
+    BIGTABLE_ERROR = 7;
+    COMMITTED_BUT_STILL_APPLYING = 8;
+    CAPABILITY_DISABLED = 9;
+    TRY_ALTERNATE_BACKEND = 10;
+    SAFE_TIME_TOO_OLD = 11;
+  }
+}
+
+message Cost {
+  optional int32 index_writes = 1;
+  optional int32 index_write_bytes = 2;
+  optional int32 entity_writes = 3;
+  optional int32 entity_write_bytes = 4;
+  optional group CommitCost = 5 {
+    optional int32 requested_entity_puts = 6;
+    optional int32 requested_entity_deletes = 7;
+  };
+  optional int32 approximate_storage_delta = 8;
+  optional int32 id_sequence_updates = 9;
+}
+
+message GetRequest {
+  optional InternalHeader header = 6;
+
+  repeated Reference key = 1;
+  optional Transaction transaction = 2;
+
+  optional int64 failover_ms = 3;
+
+  optional bool strong = 4;
+
+  optional bool allow_deferred = 5 [default=false];
+}
+
+message GetResponse {
+  repeated group Entity = 1 {
+    optional EntityProto entity = 2;
+    optional Reference key = 4;
+
+    optional int64 version = 3;
+  }
+
+  repeated Reference deferred = 5;
+
+  optional bool in_order = 6 [default=true];
+}
+
+message PutRequest {
+  optional InternalHeader header = 11;
+
+  repeated EntityProto entity = 1;
+  optional Transaction transaction = 2;
+  repeated CompositeIndex composite_index = 3;
+
+  optional bool trusted = 4 [default = false];
+
+  optional bool force = 7 [default = false];
+
+  optional bool mark_changes = 8 [default = false];
+  repeated Snapshot snapshot = 9;
+
+  enum AutoIdPolicy {
+    CURRENT = 0;
+    SEQUENTIAL = 1;
+  }
+  optional AutoIdPolicy auto_id_policy = 10 [default = CURRENT];
+}
+
+message PutResponse {
+  repeated Reference key = 1;
+  optional Cost cost = 2;
+  repeated int64 version = 3;
+}
+
+message TouchRequest {
+  optional InternalHeader header = 10;
+
+  repeated Reference key = 1;
+  repeated CompositeIndex composite_index = 2;
+  optional bool force = 3 [default = false];
+  repeated Snapshot snapshot = 9;
+}
+
+message TouchResponse {
+  optional Cost cost = 1;
+}
+
+message DeleteRequest {
+  optional InternalHeader header = 10;
+
+  repeated Reference key = 6;
+  optional Transaction transaction = 5;
+
+  optional bool trusted = 4 [default = false];
+
+  optional bool force = 7 [default = false];
+
+  optional bool mark_changes = 8 [default = false];
+  repeated Snapshot snapshot = 9;
+}
+
+message DeleteResponse {
+  optional Cost cost = 1;
+  repeated int64 version = 3;
+}
+
+message NextRequest {
+  optional InternalHeader header = 5;
+
+  required Cursor cursor = 1;
+  optional int32 count = 2;
+
+  optional int32 offset = 4 [default = 0];
+
+  optional bool compile = 3 [default = false];
+}
+
+message QueryResult {
+  optional Cursor cursor = 1;
+
+  repeated EntityProto result = 2;
+
+  optional int32 skipped_results = 7;
+
+  required bool more_results = 3;
+
+  optional bool keys_only = 4;
+
+  optional bool index_only = 9;
+
+  optional bool small_ops = 10;
+
+  optional CompiledQuery compiled_query = 5;
+
+  optional CompiledCursor compiled_cursor = 6;
+
+  repeated CompositeIndex index = 8;
+
+  repeated int64 version = 11;
+}
+
+message AllocateIdsRequest {
+  optional InternalHeader header = 4;
+
+  optional Reference model_key = 1;
+
+  optional int64 size = 2;
+
+  optional int64 max = 3;
+
+  repeated Reference reserve = 5;
+}
+
+message AllocateIdsResponse {
+  required int64 start = 1;
+  required int64 end = 2;
+  optional Cost cost = 3;
+}
+
+message CompositeIndices {
+  repeated CompositeIndex index = 1;
+}
+
+message AddActionsRequest {
+  optional InternalHeader header = 3;
+
+  required Transaction transaction = 1;
+  repeated Action action = 2;
+}
+
+message AddActionsResponse {
+}
+
+message BeginTransactionRequest {
+  optional InternalHeader header = 3;
+
+  required string app = 1;
+  optional bool allow_multiple_eg = 2 [default = false];
+  optional string database_id = 4;
+
+  enum TransactionMode {
+    UNKNOWN = 0;
+    READ_ONLY = 1;
+    READ_WRITE = 2;
+  }
+  optional TransactionMode mode = 5 [default = UNKNOWN];
+
+  optional Transaction previous_transaction = 7;
+}
+
+message CommitResponse {
+  optional Cost cost = 1;
+
+  repeated group Version = 3 {
+    required Reference root_entity_key = 4;
+    required int64 version = 5;
+  }
+}
diff --git a/vendor/google.golang.org/appengine/internal/identity.go b/vendor/google.golang.org/appengine/internal/identity.go
new file mode 100644
index 0000000..9b4134e
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/identity.go
@@ -0,0 +1,55 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package internal
+
+import (
+        "os"
+
+        netcontext "golang.org/x/net/context"
+)
+
+var (
+        // This is set to true in identity_classic.go, which is behind the appengine build tag.
+        // The appengine build tag is set for the first generation runtimes (<= Go 1.9) but not
+        // the second generation runtimes (>= Go 1.11), so this indicates whether we're on a
+        // first-gen runtime. See IsStandard below for the second-gen check.
+        appengineStandard bool
+
+        // This is set to true in identity_flex.go, which is behind the appenginevm build tag.
+        appengineFlex bool
+)
+
+// AppID is the implementation of the wrapper function of the same name in
+// ../identity.go. See that file for commentary.
+func AppID(c netcontext.Context) string {
+        return appID(FullyQualifiedAppID(c))
+}
+
+// IsStandard is the implementation of the wrapper function of the same name in
+// ../appengine.go. See that file for commentary.
+func IsStandard() bool {
+        // appengineStandard will be true for first-gen runtimes (<= Go 1.9) but not
+        // second-gen (>= Go 1.11).
+        return appengineStandard || IsSecondGen()
+}
+
+// IsStandard is the implementation of the wrapper function of the same name in
+// ../appengine.go. See that file for commentary.
+func IsSecondGen() bool {
+        // Second-gen runtimes set $GAE_ENV so we use that to check if we're on a second-gen runtime.
+        return os.Getenv("GAE_ENV") == "standard"
+}
+
+// IsFlex is the implementation of the wrapper function of the same name in
+// ../appengine.go. See that file for commentary.
+func IsFlex() bool {
+        return appengineFlex
+}
+
+// IsAppEngine is the implementation of the wrapper function of the same name in
+// ../appengine.go. See that file for commentary.
+func IsAppEngine() bool {
+        return IsStandard() || IsFlex()
+}
diff --git a/vendor/google.golang.org/appengine/internal/identity_classic.go b/vendor/google.golang.org/appengine/internal/identity_classic.go
new file mode 100644
index 0000000..4e979f4
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/identity_classic.go
@@ -0,0 +1,61 @@
+// Copyright 2015 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+package internal
+
+import (
+        "appengine"
+
+        netcontext "golang.org/x/net/context"
+)
+
+func init() {
+        appengineStandard = true
+}
+
+func DefaultVersionHostname(ctx netcontext.Context) string {
+        c := fromContext(ctx)
+        if c == nil {
+                panic(errNotAppEngineContext)
+        }
+        return appengine.DefaultVersionHostname(c)
+}
+
+func Datacenter(_ netcontext.Context) string { return appengine.Datacenter() }
+func ServerSoftware() string                 { return appengine.ServerSoftware() }
+func InstanceID() string                     { return appengine.InstanceID() }
+func IsDevAppServer() bool                   { return appengine.IsDevAppServer() }
+
+func RequestID(ctx netcontext.Context) string {
+        c := fromContext(ctx)
+        if c == nil {
+                panic(errNotAppEngineContext)
+        }
+        return appengine.RequestID(c)
+}
+
+func ModuleName(ctx netcontext.Context) string {
+        c := fromContext(ctx)
+        if c == nil {
+                panic(errNotAppEngineContext)
+        }
+        return appengine.ModuleName(c)
+}
+func VersionID(ctx netcontext.Context) string {
+        c := fromContext(ctx)
+        if c == nil {
+                panic(errNotAppEngineContext)
+        }
+        return appengine.VersionID(c)
+}
+
+func fullyQualifiedAppID(ctx netcontext.Context) string {
+        c := fromContext(ctx)
+        if c == nil {
+                panic(errNotAppEngineContext)
+        }
+        return c.FullyQualifiedAppID()
+}
diff --git a/vendor/google.golang.org/appengine/internal/identity_flex.go b/vendor/google.golang.org/appengine/internal/identity_flex.go
new file mode 100644
index 0000000..d5e2e7b
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/identity_flex.go
@@ -0,0 +1,11 @@
+// Copyright 2018 Google LLC. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build appenginevm
+
+package internal
+
+func init() {
+        appengineFlex = true
+}
diff --git a/vendor/google.golang.org/appengine/internal/identity_vm.go b/vendor/google.golang.org/appengine/internal/identity_vm.go
new file mode 100644
index 0000000..5d80672
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/identity_vm.go
@@ -0,0 +1,134 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build !appengine
+
+package internal
+
+import (
+        "log"
+        "net/http"
+        "os"
+        "strings"
+
+        netcontext "golang.org/x/net/context"
+)
+
+// These functions are implementations of the wrapper functions
+// in ../appengine/identity.go. See that file for commentary.
+
+const (
+        hDefaultVersionHostname = "X-AppEngine-Default-Version-Hostname"
+        hRequestLogId           = "X-AppEngine-Request-Log-Id"
+        hDatacenter             = "X-AppEngine-Datacenter"
+)
+
+func ctxHeaders(ctx netcontext.Context) http.Header {
+        c := fromContext(ctx)
+        if c == nil {
+                return nil
+        }
+        return c.Request().Header
+}
+
+func DefaultVersionHostname(ctx netcontext.Context) string {
+        return ctxHeaders(ctx).Get(hDefaultVersionHostname)
+}
+
+func RequestID(ctx netcontext.Context) string {
+        return ctxHeaders(ctx).Get(hRequestLogId)
+}
+
+func Datacenter(ctx netcontext.Context) string {
+        if dc := ctxHeaders(ctx).Get(hDatacenter); dc != "" {
+                return dc
+        }
+        // If the header isn't set, read zone from the metadata service.
+        // It has the format projects/[NUMERIC_PROJECT_ID]/zones/[ZONE]
+        zone, err := getMetadata("instance/zone")
+        if err != nil {
+                log.Printf("Datacenter: %v", err)
+                return ""
+        }
+        parts := strings.Split(string(zone), "/")
+        if len(parts) == 0 {
+                return ""
+        }
+        return parts[len(parts)-1]
+}
+
+func ServerSoftware() string {
+        // TODO(dsymonds): Remove fallback when we've verified this.
+        if s := os.Getenv("SERVER_SOFTWARE"); s != "" {
+                return s
+        }
+        if s := os.Getenv("GAE_ENV"); s != "" {
+                return s
+        }
+        return "Google App Engine/1.x.x"
+}
+
+// TODO(dsymonds): Remove the metadata fetches.
+
+func ModuleName(_ netcontext.Context) string {
+        if s := os.Getenv("GAE_MODULE_NAME"); s != "" {
+                return s
+        }
+        if s := os.Getenv("GAE_SERVICE"); s != "" {
+                return s
+        }
+        return string(mustGetMetadata("instance/attributes/gae_backend_name"))
+}
+
+func VersionID(_ netcontext.Context) string {
+        if s1, s2 := os.Getenv("GAE_MODULE_VERSION"), os.Getenv("GAE_MINOR_VERSION"); s1 != "" && s2 != "" {
+                return s1 + "." + s2
+        }
+        if s1, s2 := os.Getenv("GAE_VERSION"), os.Getenv("GAE_DEPLOYMENT_ID"); s1 != "" && s2 != "" {
+                return s1 + "." + s2
+        }
+        return string(mustGetMetadata("instance/attributes/gae_backend_version")) + "." + string(mustGetMetadata("instance/attributes/gae_backend_minor_version"))
+}
+
+func InstanceID() string {
+        if s := os.Getenv("GAE_MODULE_INSTANCE"); s != "" {
+                return s
+        }
+        if s := os.Getenv("GAE_INSTANCE"); s != "" {
+                return s
+        }
+        return string(mustGetMetadata("instance/attributes/gae_backend_instance"))
+}
+
+func partitionlessAppID() string {
+        // gae_project has everything except the partition prefix.
+        if appID := os.Getenv("GAE_LONG_APP_ID"); appID != "" {
+                return appID
+        }
+        if project := os.Getenv("GOOGLE_CLOUD_PROJECT"); project != "" {
+                return project
+        }
+        return string(mustGetMetadata("instance/attributes/gae_project"))
+}
+
+func fullyQualifiedAppID(_ netcontext.Context) string {
+        if s := os.Getenv("GAE_APPLICATION"); s != "" {
+                return s
+        }
+        appID := partitionlessAppID()
+
+        part := os.Getenv("GAE_PARTITION")
+        if part == "" {
+                part = string(mustGetMetadata("instance/attributes/gae_partition"))
+        }
+
+        if part != "" {
+                appID = part + "~" + appID
+        }
+        return appID
+}
+
+func IsDevAppServer() bool {
+        return os.Getenv("RUN_WITH_DEVAPPSERVER") != ""
+}
diff --git a/vendor/google.golang.org/appengine/internal/internal.go b/vendor/google.golang.org/appengine/internal/internal.go
new file mode 100644
index 0000000..051ea39
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/internal.go
@@ -0,0 +1,110 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// Package internal provides support for package appengine.
+//
+// Programs should not use this package directly. Its API is not stable.
+// Use packages appengine and appengine/* instead.
+package internal
+
+import (
+        "fmt"
+
+        "github.com/golang/protobuf/proto"
+
+        remotepb "google.golang.org/appengine/internal/remote_api"
+)
+
+// errorCodeMaps is a map of service name to the error code map for the service.
+var errorCodeMaps = make(map[string]map[int32]string)
+
+// RegisterErrorCodeMap is called from API implementations to register their
+// error code map. This should only be called from init functions.
+func RegisterErrorCodeMap(service string, m map[int32]string) {
+        errorCodeMaps[service] = m
+}
+
+type timeoutCodeKey struct {
+        service string
+        code    int32
+}
+
+// timeoutCodes is the set of service+code pairs that represent timeouts.
+var timeoutCodes = make(map[timeoutCodeKey]bool)
+
+func RegisterTimeoutErrorCode(service string, code int32) {
+        timeoutCodes[timeoutCodeKey{service, code}] = true
+}
+
+// APIError is the type returned by appengine.Context's Call method
+// when an API call fails in an API-specific way. This may be, for instance,
+// a taskqueue API call failing with TaskQueueServiceError::UNKNOWN_QUEUE.
+type APIError struct {
+        Service string
+        Detail  string
+        Code    int32 // API-specific error code
+}
+
+func (e *APIError) Error() string {
+        if e.Code == 0 {
+                if e.Detail == "" {
+                        return "APIError <empty>"
+                }
+                return e.Detail
+        }
+        s := fmt.Sprintf("API error %d", e.Code)
+        if m, ok := errorCodeMaps[e.Service]; ok {
+                s += " (" + e.Service + ": " + m[e.Code] + ")"
+        } else {
+                // Shouldn't happen, but provide a bit more detail if it does.
+                s = e.Service + " " + s
+        }
+        if e.Detail != "" {
+                s += ": " + e.Detail
+        }
+        return s
+}
+
+func (e *APIError) IsTimeout() bool {
+        return timeoutCodes[timeoutCodeKey{e.Service, e.Code}]
+}
+
+// CallError is the type returned by appengine.Context's Call method when an
+// API call fails in a generic way, such as RpcError::CAPABILITY_DISABLED.
+type CallError struct {
+        Detail string
+        Code   int32
+        // TODO: Remove this if we get a distinguishable error code.
+        Timeout bool
+}
+
+func (e *CallError) Error() string {
+        var msg string
+        switch remotepb.RpcError_ErrorCode(e.Code) {
+        case remotepb.RpcError_UNKNOWN:
+                return e.Detail
+        case remotepb.RpcError_OVER_QUOTA:
+                msg = "Over quota"
+        case remotepb.RpcError_CAPABILITY_DISABLED:
+                msg = "Capability disabled"
+        case remotepb.RpcError_CANCELLED:
+                msg = "Canceled"
+        default:
+                msg = fmt.Sprintf("Call error %d", e.Code)
+        }
+        s := msg + ": " + e.Detail
+        if e.Timeout {
+                s += " (timeout)"
+        }
+        return s
+}
+
+func (e *CallError) IsTimeout() bool {
+        return e.Timeout
+}
+
+// NamespaceMods is a map from API service to a function that will mutate an RPC request to attach a namespace.
+// The function should be prepared to be called on the same message more than once; it should only modify the
+// RPC request the first time.
+var NamespaceMods = make(map[string]func(m proto.Message, namespace string))
diff --git a/vendor/google.golang.org/appengine/internal/log/log_service.pb.go b/vendor/google.golang.org/appengine/internal/log/log_service.pb.go
new file mode 100644
index 0000000..8545ac4
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/log/log_service.pb.go
@@ -0,0 +1,1313 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google.golang.org/appengine/internal/log/log_service.proto
+
+package log
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type LogServiceError_ErrorCode int32
+
+const (
+        LogServiceError_OK              LogServiceError_ErrorCode = 0
+        LogServiceError_INVALID_REQUEST LogServiceError_ErrorCode = 1
+        LogServiceError_STORAGE_ERROR   LogServiceError_ErrorCode = 2
+)
+
+var LogServiceError_ErrorCode_name = map[int32]string{
+        0: "OK",
+        1: "INVALID_REQUEST",
+        2: "STORAGE_ERROR",
+}
+var LogServiceError_ErrorCode_value = map[string]int32{
+        "OK":              0,
+        "INVALID_REQUEST": 1,
+        "STORAGE_ERROR":   2,
+}
+
+func (x LogServiceError_ErrorCode) Enum() *LogServiceError_ErrorCode {
+        p := new(LogServiceError_ErrorCode)
+        *p = x
+        return p
+}
+func (x LogServiceError_ErrorCode) String() string {
+        return proto.EnumName(LogServiceError_ErrorCode_name, int32(x))
+}
+func (x *LogServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(LogServiceError_ErrorCode_value, data, "LogServiceError_ErrorCode")
+        if err != nil {
+                return err
+        }
+        *x = LogServiceError_ErrorCode(value)
+        return nil
+}
+func (LogServiceError_ErrorCode) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{0, 0}
+}
+
+type LogServiceError struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *LogServiceError) Reset()         { *m = LogServiceError{} }
+func (m *LogServiceError) String() string { return proto.CompactTextString(m) }
+func (*LogServiceError) ProtoMessage()    {}
+func (*LogServiceError) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{0}
+}
+func (m *LogServiceError) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_LogServiceError.Unmarshal(m, b)
+}
+func (m *LogServiceError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_LogServiceError.Marshal(b, m, deterministic)
+}
+func (dst *LogServiceError) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_LogServiceError.Merge(dst, src)
+}
+func (m *LogServiceError) XXX_Size() int {
+        return xxx_messageInfo_LogServiceError.Size(m)
+}
+func (m *LogServiceError) XXX_DiscardUnknown() {
+        xxx_messageInfo_LogServiceError.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LogServiceError proto.InternalMessageInfo
+
+type UserAppLogLine struct {
+        TimestampUsec        *int64   `protobuf:"varint,1,req,name=timestamp_usec,json=timestampUsec" json:"timestamp_usec,omitempty"`
+        Level                *int64   `protobuf:"varint,2,req,name=level" json:"level,omitempty"`
+        Message              *string  `protobuf:"bytes,3,req,name=message" json:"message,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *UserAppLogLine) Reset()         { *m = UserAppLogLine{} }
+func (m *UserAppLogLine) String() string { return proto.CompactTextString(m) }
+func (*UserAppLogLine) ProtoMessage()    {}
+func (*UserAppLogLine) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{1}
+}
+func (m *UserAppLogLine) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_UserAppLogLine.Unmarshal(m, b)
+}
+func (m *UserAppLogLine) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_UserAppLogLine.Marshal(b, m, deterministic)
+}
+func (dst *UserAppLogLine) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_UserAppLogLine.Merge(dst, src)
+}
+func (m *UserAppLogLine) XXX_Size() int {
+        return xxx_messageInfo_UserAppLogLine.Size(m)
+}
+func (m *UserAppLogLine) XXX_DiscardUnknown() {
+        xxx_messageInfo_UserAppLogLine.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UserAppLogLine proto.InternalMessageInfo
+
+func (m *UserAppLogLine) GetTimestampUsec() int64 {
+        if m != nil && m.TimestampUsec != nil {
+                return *m.TimestampUsec
+        }
+        return 0
+}
+
+func (m *UserAppLogLine) GetLevel() int64 {
+        if m != nil && m.Level != nil {
+                return *m.Level
+        }
+        return 0
+}
+
+func (m *UserAppLogLine) GetMessage() string {
+        if m != nil && m.Message != nil {
+                return *m.Message
+        }
+        return ""
+}
+
+type UserAppLogGroup struct {
+        LogLine              []*UserAppLogLine `protobuf:"bytes,2,rep,name=log_line,json=logLine" json:"log_line,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+        XXX_unrecognized     []byte            `json:"-"`
+        XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *UserAppLogGroup) Reset()         { *m = UserAppLogGroup{} }
+func (m *UserAppLogGroup) String() string { return proto.CompactTextString(m) }
+func (*UserAppLogGroup) ProtoMessage()    {}
+func (*UserAppLogGroup) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{2}
+}
+func (m *UserAppLogGroup) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_UserAppLogGroup.Unmarshal(m, b)
+}
+func (m *UserAppLogGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_UserAppLogGroup.Marshal(b, m, deterministic)
+}
+func (dst *UserAppLogGroup) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_UserAppLogGroup.Merge(dst, src)
+}
+func (m *UserAppLogGroup) XXX_Size() int {
+        return xxx_messageInfo_UserAppLogGroup.Size(m)
+}
+func (m *UserAppLogGroup) XXX_DiscardUnknown() {
+        xxx_messageInfo_UserAppLogGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UserAppLogGroup proto.InternalMessageInfo
+
+func (m *UserAppLogGroup) GetLogLine() []*UserAppLogLine {
+        if m != nil {
+                return m.LogLine
+        }
+        return nil
+}
+
+type FlushRequest struct {
+        Logs                 []byte   `protobuf:"bytes,1,opt,name=logs" json:"logs,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *FlushRequest) Reset()         { *m = FlushRequest{} }
+func (m *FlushRequest) String() string { return proto.CompactTextString(m) }
+func (*FlushRequest) ProtoMessage()    {}
+func (*FlushRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{3}
+}
+func (m *FlushRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_FlushRequest.Unmarshal(m, b)
+}
+func (m *FlushRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_FlushRequest.Marshal(b, m, deterministic)
+}
+func (dst *FlushRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_FlushRequest.Merge(dst, src)
+}
+func (m *FlushRequest) XXX_Size() int {
+        return xxx_messageInfo_FlushRequest.Size(m)
+}
+func (m *FlushRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_FlushRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FlushRequest proto.InternalMessageInfo
+
+func (m *FlushRequest) GetLogs() []byte {
+        if m != nil {
+                return m.Logs
+        }
+        return nil
+}
+
+type SetStatusRequest struct {
+        Status               *string  `protobuf:"bytes,1,req,name=status" json:"status,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SetStatusRequest) Reset()         { *m = SetStatusRequest{} }
+func (m *SetStatusRequest) String() string { return proto.CompactTextString(m) }
+func (*SetStatusRequest) ProtoMessage()    {}
+func (*SetStatusRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{4}
+}
+func (m *SetStatusRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_SetStatusRequest.Unmarshal(m, b)
+}
+func (m *SetStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_SetStatusRequest.Marshal(b, m, deterministic)
+}
+func (dst *SetStatusRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_SetStatusRequest.Merge(dst, src)
+}
+func (m *SetStatusRequest) XXX_Size() int {
+        return xxx_messageInfo_SetStatusRequest.Size(m)
+}
+func (m *SetStatusRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_SetStatusRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetStatusRequest proto.InternalMessageInfo
+
+func (m *SetStatusRequest) GetStatus() string {
+        if m != nil && m.Status != nil {
+                return *m.Status
+        }
+        return ""
+}
+
+type LogOffset struct {
+        RequestId            []byte   `protobuf:"bytes,1,opt,name=request_id,json=requestId" json:"request_id,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *LogOffset) Reset()         { *m = LogOffset{} }
+func (m *LogOffset) String() string { return proto.CompactTextString(m) }
+func (*LogOffset) ProtoMessage()    {}
+func (*LogOffset) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{5}
+}
+func (m *LogOffset) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_LogOffset.Unmarshal(m, b)
+}
+func (m *LogOffset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_LogOffset.Marshal(b, m, deterministic)
+}
+func (dst *LogOffset) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_LogOffset.Merge(dst, src)
+}
+func (m *LogOffset) XXX_Size() int {
+        return xxx_messageInfo_LogOffset.Size(m)
+}
+func (m *LogOffset) XXX_DiscardUnknown() {
+        xxx_messageInfo_LogOffset.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LogOffset proto.InternalMessageInfo
+
+func (m *LogOffset) GetRequestId() []byte {
+        if m != nil {
+                return m.RequestId
+        }
+        return nil
+}
+
+type LogLine struct {
+        Time                 *int64   `protobuf:"varint,1,req,name=time" json:"time,omitempty"`
+        Level                *int32   `protobuf:"varint,2,req,name=level" json:"level,omitempty"`
+        LogMessage           *string  `protobuf:"bytes,3,req,name=log_message,json=logMessage" json:"log_message,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *LogLine) Reset()         { *m = LogLine{} }
+func (m *LogLine) String() string { return proto.CompactTextString(m) }
+func (*LogLine) ProtoMessage()    {}
+func (*LogLine) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{6}
+}
+func (m *LogLine) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_LogLine.Unmarshal(m, b)
+}
+func (m *LogLine) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_LogLine.Marshal(b, m, deterministic)
+}
+func (dst *LogLine) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_LogLine.Merge(dst, src)
+}
+func (m *LogLine) XXX_Size() int {
+        return xxx_messageInfo_LogLine.Size(m)
+}
+func (m *LogLine) XXX_DiscardUnknown() {
+        xxx_messageInfo_LogLine.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LogLine proto.InternalMessageInfo
+
+func (m *LogLine) GetTime() int64 {
+        if m != nil && m.Time != nil {
+                return *m.Time
+        }
+        return 0
+}
+
+func (m *LogLine) GetLevel() int32 {
+        if m != nil && m.Level != nil {
+                return *m.Level
+        }
+        return 0
+}
+
+func (m *LogLine) GetLogMessage() string {
+        if m != nil && m.LogMessage != nil {
+                return *m.LogMessage
+        }
+        return ""
+}
+
+type RequestLog struct {
+        AppId                   *string    `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
+        ModuleId                *string    `protobuf:"bytes,37,opt,name=module_id,json=moduleId,def=default" json:"module_id,omitempty"`
+        VersionId               *string    `protobuf:"bytes,2,req,name=version_id,json=versionId" json:"version_id,omitempty"`
+        RequestId               []byte     `protobuf:"bytes,3,req,name=request_id,json=requestId" json:"request_id,omitempty"`
+        Offset                  *LogOffset `protobuf:"bytes,35,opt,name=offset" json:"offset,omitempty"`
+        Ip                      *string    `protobuf:"bytes,4,req,name=ip" json:"ip,omitempty"`
+        Nickname                *string    `protobuf:"bytes,5,opt,name=nickname" json:"nickname,omitempty"`
+        StartTime               *int64     `protobuf:"varint,6,req,name=start_time,json=startTime" json:"start_time,omitempty"`
+        EndTime                 *int64     `protobuf:"varint,7,req,name=end_time,json=endTime" json:"end_time,omitempty"`
+        Latency                 *int64     `protobuf:"varint,8,req,name=latency" json:"latency,omitempty"`
+        Mcycles                 *int64     `protobuf:"varint,9,req,name=mcycles" json:"mcycles,omitempty"`
+        Method                  *string    `protobuf:"bytes,10,req,name=method" json:"method,omitempty"`
+        Resource                *string    `protobuf:"bytes,11,req,name=resource" json:"resource,omitempty"`
+        HttpVersion             *string    `protobuf:"bytes,12,req,name=http_version,json=httpVersion" json:"http_version,omitempty"`
+        Status                  *int32     `protobuf:"varint,13,req,name=status" json:"status,omitempty"`
+        ResponseSize            *int64     `protobuf:"varint,14,req,name=response_size,json=responseSize" json:"response_size,omitempty"`
+        Referrer                *string    `protobuf:"bytes,15,opt,name=referrer" json:"referrer,omitempty"`
+        UserAgent               *string    `protobuf:"bytes,16,opt,name=user_agent,json=userAgent" json:"user_agent,omitempty"`
+        UrlMapEntry             *string    `protobuf:"bytes,17,req,name=url_map_entry,json=urlMapEntry" json:"url_map_entry,omitempty"`
+        Combined                *string    `protobuf:"bytes,18,req,name=combined" json:"combined,omitempty"`
+        ApiMcycles              *int64     `protobuf:"varint,19,opt,name=api_mcycles,json=apiMcycles" json:"api_mcycles,omitempty"`
+        Host                    *string    `protobuf:"bytes,20,opt,name=host" json:"host,omitempty"`
+        Cost                    *float64   `protobuf:"fixed64,21,opt,name=cost" json:"cost,omitempty"`
+        TaskQueueName           *string    `protobuf:"bytes,22,opt,name=task_queue_name,json=taskQueueName" json:"task_queue_name,omitempty"`
+        TaskName                *string    `protobuf:"bytes,23,opt,name=task_name,json=taskName" json:"task_name,omitempty"`
+        WasLoadingRequest       *bool      `protobuf:"varint,24,opt,name=was_loading_request,json=wasLoadingRequest" json:"was_loading_request,omitempty"`
+        PendingTime             *int64     `protobuf:"varint,25,opt,name=pending_time,json=pendingTime" json:"pending_time,omitempty"`
+        ReplicaIndex            *int32     `protobuf:"varint,26,opt,name=replica_index,json=replicaIndex,def=-1" json:"replica_index,omitempty"`
+        Finished                *bool      `protobuf:"varint,27,opt,name=finished,def=1" json:"finished,omitempty"`
+        CloneKey                []byte     `protobuf:"bytes,28,opt,name=clone_key,json=cloneKey" json:"clone_key,omitempty"`
+        Line                    []*LogLine `protobuf:"bytes,29,rep,name=line" json:"line,omitempty"`
+        LinesIncomplete         *bool      `protobuf:"varint,36,opt,name=lines_incomplete,json=linesIncomplete" json:"lines_incomplete,omitempty"`
+        AppEngineRelease        []byte     `protobuf:"bytes,38,opt,name=app_engine_release,json=appEngineRelease" json:"app_engine_release,omitempty"`
+        ExitReason              *int32     `protobuf:"varint,30,opt,name=exit_reason,json=exitReason" json:"exit_reason,omitempty"`
+        WasThrottledForTime     *bool      `protobuf:"varint,31,opt,name=was_throttled_for_time,json=wasThrottledForTime" json:"was_throttled_for_time,omitempty"`
+        WasThrottledForRequests *bool      `protobuf:"varint,32,opt,name=was_throttled_for_requests,json=wasThrottledForRequests" json:"was_throttled_for_requests,omitempty"`
+        ThrottledTime           *int64     `protobuf:"varint,33,opt,name=throttled_time,json=throttledTime" json:"throttled_time,omitempty"`
+        ServerName              []byte     `protobuf:"bytes,34,opt,name=server_name,json=serverName" json:"server_name,omitempty"`
+        XXX_NoUnkeyedLiteral    struct{}   `json:"-"`
+        XXX_unrecognized        []byte     `json:"-"`
+        XXX_sizecache           int32      `json:"-"`
+}
+
+func (m *RequestLog) Reset()         { *m = RequestLog{} }
+func (m *RequestLog) String() string { return proto.CompactTextString(m) }
+func (*RequestLog) ProtoMessage()    {}
+func (*RequestLog) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{7}
+}
+func (m *RequestLog) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_RequestLog.Unmarshal(m, b)
+}
+func (m *RequestLog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_RequestLog.Marshal(b, m, deterministic)
+}
+func (dst *RequestLog) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_RequestLog.Merge(dst, src)
+}
+func (m *RequestLog) XXX_Size() int {
+        return xxx_messageInfo_RequestLog.Size(m)
+}
+func (m *RequestLog) XXX_DiscardUnknown() {
+        xxx_messageInfo_RequestLog.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RequestLog proto.InternalMessageInfo
+
+const Default_RequestLog_ModuleId string = "default"
+const Default_RequestLog_ReplicaIndex int32 = -1
+const Default_RequestLog_Finished bool = true
+
+func (m *RequestLog) GetAppId() string {
+        if m != nil && m.AppId != nil {
+                return *m.AppId
+        }
+        return ""
+}
+
+func (m *RequestLog) GetModuleId() string {
+        if m != nil && m.ModuleId != nil {
+                return *m.ModuleId
+        }
+        return Default_RequestLog_ModuleId
+}
+
+func (m *RequestLog) GetVersionId() string {
+        if m != nil && m.VersionId != nil {
+                return *m.VersionId
+        }
+        return ""
+}
+
+func (m *RequestLog) GetRequestId() []byte {
+        if m != nil {
+                return m.RequestId
+        }
+        return nil
+}
+
+func (m *RequestLog) GetOffset() *LogOffset {
+        if m != nil {
+                return m.Offset
+        }
+        return nil
+}
+
+func (m *RequestLog) GetIp() string {
+        if m != nil && m.Ip != nil {
+                return *m.Ip
+        }
+        return ""
+}
+
+func (m *RequestLog) GetNickname() string {
+        if m != nil && m.Nickname != nil {
+                return *m.Nickname
+        }
+        return ""
+}
+
+func (m *RequestLog) GetStartTime() int64 {
+        if m != nil && m.StartTime != nil {
+                return *m.StartTime
+        }
+        return 0
+}
+
+func (m *RequestLog) GetEndTime() int64 {
+        if m != nil && m.EndTime != nil {
+                return *m.EndTime
+        }
+        return 0
+}
+
+func (m *RequestLog) GetLatency() int64 {
+        if m != nil && m.Latency != nil {
+                return *m.Latency
+        }
+        return 0
+}
+
+func (m *RequestLog) GetMcycles() int64 {
+        if m != nil && m.Mcycles != nil {
+                return *m.Mcycles
+        }
+        return 0
+}
+
+func (m *RequestLog) GetMethod() string {
+        if m != nil && m.Method != nil {
+                return *m.Method
+        }
+        return ""
+}
+
+func (m *RequestLog) GetResource() string {
+        if m != nil && m.Resource != nil {
+                return *m.Resource
+        }
+        return ""
+}
+
+func (m *RequestLog) GetHttpVersion() string {
+        if m != nil && m.HttpVersion != nil {
+                return *m.HttpVersion
+        }
+        return ""
+}
+
+func (m *RequestLog) GetStatus() int32 {
+        if m != nil && m.Status != nil {
+                return *m.Status
+        }
+        return 0
+}
+
+func (m *RequestLog) GetResponseSize() int64 {
+        if m != nil && m.ResponseSize != nil {
+                return *m.ResponseSize
+        }
+        return 0
+}
+
+func (m *RequestLog) GetReferrer() string {
+        if m != nil && m.Referrer != nil {
+                return *m.Referrer
+        }
+        return ""
+}
+
+func (m *RequestLog) GetUserAgent() string {
+        if m != nil && m.UserAgent != nil {
+                return *m.UserAgent
+        }
+        return ""
+}
+
+func (m *RequestLog) GetUrlMapEntry() string {
+        if m != nil && m.UrlMapEntry != nil {
+                return *m.UrlMapEntry
+        }
+        return ""
+}
+
+func (m *RequestLog) GetCombined() string {
+        if m != nil && m.Combined != nil {
+                return *m.Combined
+        }
+        return ""
+}
+
+func (m *RequestLog) GetApiMcycles() int64 {
+        if m != nil && m.ApiMcycles != nil {
+                return *m.ApiMcycles
+        }
+        return 0
+}
+
+func (m *RequestLog) GetHost() string {
+        if m != nil && m.Host != nil {
+                return *m.Host
+        }
+        return ""
+}
+
+func (m *RequestLog) GetCost() float64 {
+        if m != nil && m.Cost != nil {
+                return *m.Cost
+        }
+        return 0
+}
+
+func (m *RequestLog) GetTaskQueueName() string {
+        if m != nil && m.TaskQueueName != nil {
+                return *m.TaskQueueName
+        }
+        return ""
+}
+
+func (m *RequestLog) GetTaskName() string {
+        if m != nil && m.TaskName != nil {
+                return *m.TaskName
+        }
+        return ""
+}
+
+func (m *RequestLog) GetWasLoadingRequest() bool {
+        if m != nil && m.WasLoadingRequest != nil {
+                return *m.WasLoadingRequest
+        }
+        return false
+}
+
+func (m *RequestLog) GetPendingTime() int64 {
+        if m != nil && m.PendingTime != nil {
+                return *m.PendingTime
+        }
+        return 0
+}
+
+func (m *RequestLog) GetReplicaIndex() int32 {
+        if m != nil && m.ReplicaIndex != nil {
+                return *m.ReplicaIndex
+        }
+        return Default_RequestLog_ReplicaIndex
+}
+
+func (m *RequestLog) GetFinished() bool {
+        if m != nil && m.Finished != nil {
+                return *m.Finished
+        }
+        return Default_RequestLog_Finished
+}
+
+func (m *RequestLog) GetCloneKey() []byte {
+        if m != nil {
+                return m.CloneKey
+        }
+        return nil
+}
+
+func (m *RequestLog) GetLine() []*LogLine {
+        if m != nil {
+                return m.Line
+        }
+        return nil
+}
+
+func (m *RequestLog) GetLinesIncomplete() bool {
+        if m != nil && m.LinesIncomplete != nil {
+                return *m.LinesIncomplete
+        }
+        return false
+}
+
+func (m *RequestLog) GetAppEngineRelease() []byte {
+        if m != nil {
+                return m.AppEngineRelease
+        }
+        return nil
+}
+
+func (m *RequestLog) GetExitReason() int32 {
+        if m != nil && m.ExitReason != nil {
+                return *m.ExitReason
+        }
+        return 0
+}
+
+func (m *RequestLog) GetWasThrottledForTime() bool {
+        if m != nil && m.WasThrottledForTime != nil {
+                return *m.WasThrottledForTime
+        }
+        return false
+}
+
+func (m *RequestLog) GetWasThrottledForRequests() bool {
+        if m != nil && m.WasThrottledForRequests != nil {
+                return *m.WasThrottledForRequests
+        }
+        return false
+}
+
+func (m *RequestLog) GetThrottledTime() int64 {
+        if m != nil && m.ThrottledTime != nil {
+                return *m.ThrottledTime
+        }
+        return 0
+}
+
+func (m *RequestLog) GetServerName() []byte {
+        if m != nil {
+                return m.ServerName
+        }
+        return nil
+}
+
+type LogModuleVersion struct {
+        ModuleId             *string  `protobuf:"bytes,1,opt,name=module_id,json=moduleId,def=default" json:"module_id,omitempty"`
+        VersionId            *string  `protobuf:"bytes,2,opt,name=version_id,json=versionId" json:"version_id,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *LogModuleVersion) Reset()         { *m = LogModuleVersion{} }
+func (m *LogModuleVersion) String() string { return proto.CompactTextString(m) }
+func (*LogModuleVersion) ProtoMessage()    {}
+func (*LogModuleVersion) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{8}
+}
+func (m *LogModuleVersion) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_LogModuleVersion.Unmarshal(m, b)
+}
+func (m *LogModuleVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_LogModuleVersion.Marshal(b, m, deterministic)
+}
+func (dst *LogModuleVersion) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_LogModuleVersion.Merge(dst, src)
+}
+func (m *LogModuleVersion) XXX_Size() int {
+        return xxx_messageInfo_LogModuleVersion.Size(m)
+}
+func (m *LogModuleVersion) XXX_DiscardUnknown() {
+        xxx_messageInfo_LogModuleVersion.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LogModuleVersion proto.InternalMessageInfo
+
+const Default_LogModuleVersion_ModuleId string = "default"
+
+func (m *LogModuleVersion) GetModuleId() string {
+        if m != nil && m.ModuleId != nil {
+                return *m.ModuleId
+        }
+        return Default_LogModuleVersion_ModuleId
+}
+
+func (m *LogModuleVersion) GetVersionId() string {
+        if m != nil && m.VersionId != nil {
+                return *m.VersionId
+        }
+        return ""
+}
+
+type LogReadRequest struct {
+        AppId                *string             `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
+        VersionId            []string            `protobuf:"bytes,2,rep,name=version_id,json=versionId" json:"version_id,omitempty"`
+        ModuleVersion        []*LogModuleVersion `protobuf:"bytes,19,rep,name=module_version,json=moduleVersion" json:"module_version,omitempty"`
+        StartTime            *int64              `protobuf:"varint,3,opt,name=start_time,json=startTime" json:"start_time,omitempty"`
+        EndTime              *int64              `protobuf:"varint,4,opt,name=end_time,json=endTime" json:"end_time,omitempty"`
+        Offset               *LogOffset          `protobuf:"bytes,5,opt,name=offset" json:"offset,omitempty"`
+        RequestId            [][]byte            `protobuf:"bytes,6,rep,name=request_id,json=requestId" json:"request_id,omitempty"`
+        MinimumLogLevel      *int32              `protobuf:"varint,7,opt,name=minimum_log_level,json=minimumLogLevel" json:"minimum_log_level,omitempty"`
+        IncludeIncomplete    *bool               `protobuf:"varint,8,opt,name=include_incomplete,json=includeIncomplete" json:"include_incomplete,omitempty"`
+        Count                *int64              `protobuf:"varint,9,opt,name=count" json:"count,omitempty"`
+        CombinedLogRegex     *string             `protobuf:"bytes,14,opt,name=combined_log_regex,json=combinedLogRegex" json:"combined_log_regex,omitempty"`
+        HostRegex            *string             `protobuf:"bytes,15,opt,name=host_regex,json=hostRegex" json:"host_regex,omitempty"`
+        ReplicaIndex         *int32              `protobuf:"varint,16,opt,name=replica_index,json=replicaIndex" json:"replica_index,omitempty"`
+        IncludeAppLogs       *bool               `protobuf:"varint,10,opt,name=include_app_logs,json=includeAppLogs" json:"include_app_logs,omitempty"`
+        AppLogsPerRequest    *int32              `protobuf:"varint,17,opt,name=app_logs_per_request,json=appLogsPerRequest" json:"app_logs_per_request,omitempty"`
+        IncludeHost          *bool               `protobuf:"varint,11,opt,name=include_host,json=includeHost" json:"include_host,omitempty"`
+        IncludeAll           *bool               `protobuf:"varint,12,opt,name=include_all,json=includeAll" json:"include_all,omitempty"`
+        CacheIterator        *bool               `protobuf:"varint,13,opt,name=cache_iterator,json=cacheIterator" json:"cache_iterator,omitempty"`
+        NumShards            *int32              `protobuf:"varint,18,opt,name=num_shards,json=numShards" json:"num_shards,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}            `json:"-"`
+        XXX_unrecognized     []byte              `json:"-"`
+        XXX_sizecache        int32               `json:"-"`
+}
+
+func (m *LogReadRequest) Reset()         { *m = LogReadRequest{} }
+func (m *LogReadRequest) String() string { return proto.CompactTextString(m) }
+func (*LogReadRequest) ProtoMessage()    {}
+func (*LogReadRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{9}
+}
+func (m *LogReadRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_LogReadRequest.Unmarshal(m, b)
+}
+func (m *LogReadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_LogReadRequest.Marshal(b, m, deterministic)
+}
+func (dst *LogReadRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_LogReadRequest.Merge(dst, src)
+}
+func (m *LogReadRequest) XXX_Size() int {
+        return xxx_messageInfo_LogReadRequest.Size(m)
+}
+func (m *LogReadRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_LogReadRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LogReadRequest proto.InternalMessageInfo
+
+func (m *LogReadRequest) GetAppId() string {
+        if m != nil && m.AppId != nil {
+                return *m.AppId
+        }
+        return ""
+}
+
+func (m *LogReadRequest) GetVersionId() []string {
+        if m != nil {
+                return m.VersionId
+        }
+        return nil
+}
+
+func (m *LogReadRequest) GetModuleVersion() []*LogModuleVersion {
+        if m != nil {
+                return m.ModuleVersion
+        }
+        return nil
+}
+
+func (m *LogReadRequest) GetStartTime() int64 {
+        if m != nil && m.StartTime != nil {
+                return *m.StartTime
+        }
+        return 0
+}
+
+func (m *LogReadRequest) GetEndTime() int64 {
+        if m != nil && m.EndTime != nil {
+                return *m.EndTime
+        }
+        return 0
+}
+
+func (m *LogReadRequest) GetOffset() *LogOffset {
+        if m != nil {
+                return m.Offset
+        }
+        return nil
+}
+
+func (m *LogReadRequest) GetRequestId() [][]byte {
+        if m != nil {
+                return m.RequestId
+        }
+        return nil
+}
+
+func (m *LogReadRequest) GetMinimumLogLevel() int32 {
+        if m != nil && m.MinimumLogLevel != nil {
+                return *m.MinimumLogLevel
+        }
+        return 0
+}
+
+func (m *LogReadRequest) GetIncludeIncomplete() bool {
+        if m != nil && m.IncludeIncomplete != nil {
+                return *m.IncludeIncomplete
+        }
+        return false
+}
+
+func (m *LogReadRequest) GetCount() int64 {
+        if m != nil && m.Count != nil {
+                return *m.Count
+        }
+        return 0
+}
+
+func (m *LogReadRequest) GetCombinedLogRegex() string {
+        if m != nil && m.CombinedLogRegex != nil {
+                return *m.CombinedLogRegex
+        }
+        return ""
+}
+
+func (m *LogReadRequest) GetHostRegex() string {
+        if m != nil && m.HostRegex != nil {
+                return *m.HostRegex
+        }
+        return ""
+}
+
+func (m *LogReadRequest) GetReplicaIndex() int32 {
+        if m != nil && m.ReplicaIndex != nil {
+                return *m.ReplicaIndex
+        }
+        return 0
+}
+
+func (m *LogReadRequest) GetIncludeAppLogs() bool {
+        if m != nil && m.IncludeAppLogs != nil {
+                return *m.IncludeAppLogs
+        }
+        return false
+}
+
+func (m *LogReadRequest) GetAppLogsPerRequest() int32 {
+        if m != nil && m.AppLogsPerRequest != nil {
+                return *m.AppLogsPerRequest
+        }
+        return 0
+}
+
+func (m *LogReadRequest) GetIncludeHost() bool {
+        if m != nil && m.IncludeHost != nil {
+                return *m.IncludeHost
+        }
+        return false
+}
+
+func (m *LogReadRequest) GetIncludeAll() bool {
+        if m != nil && m.IncludeAll != nil {
+                return *m.IncludeAll
+        }
+        return false
+}
+
+func (m *LogReadRequest) GetCacheIterator() bool {
+        if m != nil && m.CacheIterator != nil {
+                return *m.CacheIterator
+        }
+        return false
+}
+
+func (m *LogReadRequest) GetNumShards() int32 {
+        if m != nil && m.NumShards != nil {
+                return *m.NumShards
+        }
+        return 0
+}
+
+type LogReadResponse struct {
+        Log                  []*RequestLog `protobuf:"bytes,1,rep,name=log" json:"log,omitempty"`
+        Offset               *LogOffset    `protobuf:"bytes,2,opt,name=offset" json:"offset,omitempty"`
+        LastEndTime          *int64        `protobuf:"varint,3,opt,name=last_end_time,json=lastEndTime" json:"last_end_time,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}      `json:"-"`
+        XXX_unrecognized     []byte        `json:"-"`
+        XXX_sizecache        int32         `json:"-"`
+}
+
+func (m *LogReadResponse) Reset()         { *m = LogReadResponse{} }
+func (m *LogReadResponse) String() string { return proto.CompactTextString(m) }
+func (*LogReadResponse) ProtoMessage()    {}
+func (*LogReadResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{10}
+}
+func (m *LogReadResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_LogReadResponse.Unmarshal(m, b)
+}
+func (m *LogReadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_LogReadResponse.Marshal(b, m, deterministic)
+}
+func (dst *LogReadResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_LogReadResponse.Merge(dst, src)
+}
+func (m *LogReadResponse) XXX_Size() int {
+        return xxx_messageInfo_LogReadResponse.Size(m)
+}
+func (m *LogReadResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_LogReadResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LogReadResponse proto.InternalMessageInfo
+
+func (m *LogReadResponse) GetLog() []*RequestLog {
+        if m != nil {
+                return m.Log
+        }
+        return nil
+}
+
+func (m *LogReadResponse) GetOffset() *LogOffset {
+        if m != nil {
+                return m.Offset
+        }
+        return nil
+}
+
+func (m *LogReadResponse) GetLastEndTime() int64 {
+        if m != nil && m.LastEndTime != nil {
+                return *m.LastEndTime
+        }
+        return 0
+}
+
+type LogUsageRecord struct {
+        VersionId            *string  `protobuf:"bytes,1,opt,name=version_id,json=versionId" json:"version_id,omitempty"`
+        StartTime            *int32   `protobuf:"varint,2,opt,name=start_time,json=startTime" json:"start_time,omitempty"`
+        EndTime              *int32   `protobuf:"varint,3,opt,name=end_time,json=endTime" json:"end_time,omitempty"`
+        Count                *int64   `protobuf:"varint,4,opt,name=count" json:"count,omitempty"`
+        TotalSize            *int64   `protobuf:"varint,5,opt,name=total_size,json=totalSize" json:"total_size,omitempty"`
+        Records              *int32   `protobuf:"varint,6,opt,name=records" json:"records,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *LogUsageRecord) Reset()         { *m = LogUsageRecord{} }
+func (m *LogUsageRecord) String() string { return proto.CompactTextString(m) }
+func (*LogUsageRecord) ProtoMessage()    {}
+func (*LogUsageRecord) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{11}
+}
+func (m *LogUsageRecord) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_LogUsageRecord.Unmarshal(m, b)
+}
+func (m *LogUsageRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_LogUsageRecord.Marshal(b, m, deterministic)
+}
+func (dst *LogUsageRecord) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_LogUsageRecord.Merge(dst, src)
+}
+func (m *LogUsageRecord) XXX_Size() int {
+        return xxx_messageInfo_LogUsageRecord.Size(m)
+}
+func (m *LogUsageRecord) XXX_DiscardUnknown() {
+        xxx_messageInfo_LogUsageRecord.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LogUsageRecord proto.InternalMessageInfo
+
+func (m *LogUsageRecord) GetVersionId() string {
+        if m != nil && m.VersionId != nil {
+                return *m.VersionId
+        }
+        return ""
+}
+
+func (m *LogUsageRecord) GetStartTime() int32 {
+        if m != nil && m.StartTime != nil {
+                return *m.StartTime
+        }
+        return 0
+}
+
+func (m *LogUsageRecord) GetEndTime() int32 {
+        if m != nil && m.EndTime != nil {
+                return *m.EndTime
+        }
+        return 0
+}
+
+func (m *LogUsageRecord) GetCount() int64 {
+        if m != nil && m.Count != nil {
+                return *m.Count
+        }
+        return 0
+}
+
+func (m *LogUsageRecord) GetTotalSize() int64 {
+        if m != nil && m.TotalSize != nil {
+                return *m.TotalSize
+        }
+        return 0
+}
+
+func (m *LogUsageRecord) GetRecords() int32 {
+        if m != nil && m.Records != nil {
+                return *m.Records
+        }
+        return 0
+}
+
+type LogUsageRequest struct {
+        AppId                *string  `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"`
+        VersionId            []string `protobuf:"bytes,2,rep,name=version_id,json=versionId" json:"version_id,omitempty"`
+        StartTime            *int32   `protobuf:"varint,3,opt,name=start_time,json=startTime" json:"start_time,omitempty"`
+        EndTime              *int32   `protobuf:"varint,4,opt,name=end_time,json=endTime" json:"end_time,omitempty"`
+        ResolutionHours      *uint32  `protobuf:"varint,5,opt,name=resolution_hours,json=resolutionHours,def=1" json:"resolution_hours,omitempty"`
+        CombineVersions      *bool    `protobuf:"varint,6,opt,name=combine_versions,json=combineVersions" json:"combine_versions,omitempty"`
+        UsageVersion         *int32   `protobuf:"varint,7,opt,name=usage_version,json=usageVersion" json:"usage_version,omitempty"`
+        VersionsOnly         *bool    `protobuf:"varint,8,opt,name=versions_only,json=versionsOnly" json:"versions_only,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *LogUsageRequest) Reset()         { *m = LogUsageRequest{} }
+func (m *LogUsageRequest) String() string { return proto.CompactTextString(m) }
+func (*LogUsageRequest) ProtoMessage()    {}
+func (*LogUsageRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{12}
+}
+func (m *LogUsageRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_LogUsageRequest.Unmarshal(m, b)
+}
+func (m *LogUsageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_LogUsageRequest.Marshal(b, m, deterministic)
+}
+func (dst *LogUsageRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_LogUsageRequest.Merge(dst, src)
+}
+func (m *LogUsageRequest) XXX_Size() int {
+        return xxx_messageInfo_LogUsageRequest.Size(m)
+}
+func (m *LogUsageRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_LogUsageRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LogUsageRequest proto.InternalMessageInfo
+
+const Default_LogUsageRequest_ResolutionHours uint32 = 1
+
+func (m *LogUsageRequest) GetAppId() string {
+        if m != nil && m.AppId != nil {
+                return *m.AppId
+        }
+        return ""
+}
+
+func (m *LogUsageRequest) GetVersionId() []string {
+        if m != nil {
+                return m.VersionId
+        }
+        return nil
+}
+
+func (m *LogUsageRequest) GetStartTime() int32 {
+        if m != nil && m.StartTime != nil {
+                return *m.StartTime
+        }
+        return 0
+}
+
+func (m *LogUsageRequest) GetEndTime() int32 {
+        if m != nil && m.EndTime != nil {
+                return *m.EndTime
+        }
+        return 0
+}
+
+func (m *LogUsageRequest) GetResolutionHours() uint32 {
+        if m != nil && m.ResolutionHours != nil {
+                return *m.ResolutionHours
+        }
+        return Default_LogUsageRequest_ResolutionHours
+}
+
+func (m *LogUsageRequest) GetCombineVersions() bool {
+        if m != nil && m.CombineVersions != nil {
+                return *m.CombineVersions
+        }
+        return false
+}
+
+func (m *LogUsageRequest) GetUsageVersion() int32 {
+        if m != nil && m.UsageVersion != nil {
+                return *m.UsageVersion
+        }
+        return 0
+}
+
+func (m *LogUsageRequest) GetVersionsOnly() bool {
+        if m != nil && m.VersionsOnly != nil {
+                return *m.VersionsOnly
+        }
+        return false
+}
+
+type LogUsageResponse struct {
+        Usage                []*LogUsageRecord `protobuf:"bytes,1,rep,name=usage" json:"usage,omitempty"`
+        Summary              *LogUsageRecord   `protobuf:"bytes,2,opt,name=summary" json:"summary,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+        XXX_unrecognized     []byte            `json:"-"`
+        XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *LogUsageResponse) Reset()         { *m = LogUsageResponse{} }
+func (m *LogUsageResponse) String() string { return proto.CompactTextString(m) }
+func (*LogUsageResponse) ProtoMessage()    {}
+func (*LogUsageResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_log_service_f054fd4b5012319d, []int{13}
+}
+func (m *LogUsageResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_LogUsageResponse.Unmarshal(m, b)
+}
+func (m *LogUsageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_LogUsageResponse.Marshal(b, m, deterministic)
+}
+func (dst *LogUsageResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_LogUsageResponse.Merge(dst, src)
+}
+func (m *LogUsageResponse) XXX_Size() int {
+        return xxx_messageInfo_LogUsageResponse.Size(m)
+}
+func (m *LogUsageResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_LogUsageResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_LogUsageResponse proto.InternalMessageInfo
+
+func (m *LogUsageResponse) GetUsage() []*LogUsageRecord {
+        if m != nil {
+                return m.Usage
+        }
+        return nil
+}
+
+func (m *LogUsageResponse) GetSummary() *LogUsageRecord {
+        if m != nil {
+                return m.Summary
+        }
+        return nil
+}
+
+func init() {
+        proto.RegisterType((*LogServiceError)(nil), "appengine.LogServiceError")
+        proto.RegisterType((*UserAppLogLine)(nil), "appengine.UserAppLogLine")
+        proto.RegisterType((*UserAppLogGroup)(nil), "appengine.UserAppLogGroup")
+        proto.RegisterType((*FlushRequest)(nil), "appengine.FlushRequest")
+        proto.RegisterType((*SetStatusRequest)(nil), "appengine.SetStatusRequest")
+        proto.RegisterType((*LogOffset)(nil), "appengine.LogOffset")
+        proto.RegisterType((*LogLine)(nil), "appengine.LogLine")
+        proto.RegisterType((*RequestLog)(nil), "appengine.RequestLog")
+        proto.RegisterType((*LogModuleVersion)(nil), "appengine.LogModuleVersion")
+        proto.RegisterType((*LogReadRequest)(nil), "appengine.LogReadRequest")
+        proto.RegisterType((*LogReadResponse)(nil), "appengine.LogReadResponse")
+        proto.RegisterType((*LogUsageRecord)(nil), "appengine.LogUsageRecord")
+        proto.RegisterType((*LogUsageRequest)(nil), "appengine.LogUsageRequest")
+        proto.RegisterType((*LogUsageResponse)(nil), "appengine.LogUsageResponse")
+}
+
+func init() {
+        proto.RegisterFile("google.golang.org/appengine/internal/log/log_service.proto", fileDescriptor_log_service_f054fd4b5012319d)
+}
+
+var fileDescriptor_log_service_f054fd4b5012319d = []byte{
+        // 1553 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xdd, 0x72, 0xdb, 0xc6,
+        0x15, 0x2e, 0x48, 0x51, 0x24, 0x0f, 0x49, 0x91, 0x5a, 0xcb, 0xce, 0xda, 0xae, 0x6b, 0x1a, 0x4e,
+        0x1c, 0xd6, 0x93, 0x48, 0x93, 0xa4, 0x57, 0xca, 0x95, 0xd3, 0x2a, 0x8e, 0x26, 0xb4, 0xd5, 0x40,
+        0x72, 0x3a, 0xd3, 0x1b, 0x0c, 0x0a, 0x1c, 0x81, 0x18, 0x2f, 0xb1, 0xc8, 0xee, 0xc2, 0x91, 0x72,
+        0xdb, 0xdb, 0x3e, 0x46, 0x1f, 0xa2, 0xaf, 0xd2, 0xb7, 0xe9, 0xec, 0xd9, 0x05, 0x44, 0x2a, 0x4d,
+        0xc6, 0x33, 0xb9, 0xe0, 0x10, 0xfb, 0x9d, 0x83, 0xdd, 0xf3, 0xf3, 0x9d, 0x6f, 0x01, 0xc7, 0xb9,
+        0x94, 0xb9, 0xc0, 0xc3, 0x5c, 0x8a, 0xa4, 0xcc, 0x0f, 0xa5, 0xca, 0x8f, 0x92, 0xaa, 0xc2, 0x32,
+        0x2f, 0x4a, 0x3c, 0x2a, 0x4a, 0x83, 0xaa, 0x4c, 0xc4, 0x91, 0x90, 0xb9, 0xfd, 0xc5, 0x1a, 0xd5,
+        0xbb, 0x22, 0xc5, 0xc3, 0x4a, 0x49, 0x23, 0xd9, 0xb0, 0xf5, 0x0c, 0x5f, 0xc3, 0x74, 0x29, 0xf3,
+        0x73, 0x67, 0x3e, 0x51, 0x4a, 0xaa, 0xf0, 0x4b, 0x18, 0xd2, 0xc3, 0x9f, 0x65, 0x86, 0x6c, 0x17,
+        0x3a, 0x67, 0xdf, 0xce, 0x7e, 0xc7, 0xee, 0xc0, 0xf4, 0xf4, 0xf5, 0xf7, 0x2f, 0x96, 0xa7, 0x7f,
+        0x89, 0xa3, 0x93, 0xef, 0xde, 0x9c, 0x9c, 0x5f, 0xcc, 0x02, 0xb6, 0x0f, 0x93, 0xf3, 0x8b, 0xb3,
+        0xe8, 0xc5, 0xcb, 0x93, 0xf8, 0x24, 0x8a, 0xce, 0xa2, 0x59, 0x27, 0xcc, 0x61, 0xef, 0x8d, 0x46,
+        0xf5, 0xa2, 0xaa, 0x96, 0x32, 0x5f, 0x16, 0x25, 0xb2, 0x8f, 0x60, 0xcf, 0x14, 0x6b, 0xd4, 0x26,
+        0x59, 0x57, 0x71, 0xad, 0x31, 0xe5, 0xc1, 0xbc, 0xb3, 0xe8, 0x46, 0x93, 0x16, 0x7d, 0xa3, 0x31,
+        0x65, 0x07, 0xd0, 0x13, 0xf8, 0x0e, 0x05, 0xef, 0x90, 0xd5, 0x2d, 0x18, 0x87, 0xfe, 0x1a, 0xb5,
+        0x4e, 0x72, 0xe4, 0xdd, 0x79, 0x67, 0x31, 0x8c, 0x9a, 0x65, 0xf8, 0x12, 0xa6, 0x37, 0x07, 0xbd,
+        0x54, 0xb2, 0xae, 0xd8, 0x9f, 0x60, 0x60, 0x73, 0x15, 0x45, 0x89, 0xbc, 0x33, 0xef, 0x2e, 0x46,
+        0x9f, 0xdf, 0x3f, 0x6c, 0x33, 0x3d, 0xdc, 0x0e, 0x2b, 0xea, 0x0b, 0xf7, 0x10, 0x86, 0x30, 0xfe,
+        0x5a, 0xd4, 0x7a, 0x15, 0xe1, 0x0f, 0x35, 0x6a, 0xc3, 0x18, 0xec, 0x08, 0x99, 0x6b, 0x1e, 0xcc,
+        0x83, 0xc5, 0x38, 0xa2, 0xe7, 0xf0, 0x39, 0xcc, 0xce, 0xd1, 0x9c, 0x9b, 0xc4, 0xd4, 0xba, 0xf1,
+        0xbb, 0x07, 0xbb, 0x9a, 0x00, 0xca, 0x67, 0x18, 0xf9, 0x55, 0xf8, 0x1c, 0x86, 0x4b, 0x99, 0x9f,
+        0x5d, 0x5e, 0x6a, 0x34, 0xec, 0x11, 0x80, 0x72, 0xfe, 0x71, 0x91, 0xf9, 0x2d, 0x87, 0x1e, 0x39,
+        0xcd, 0xc2, 0x0b, 0xe8, 0x37, 0x65, 0x62, 0xb0, 0x63, 0x0b, 0xe2, 0x8b, 0x43, 0xcf, 0xdb, 0x35,
+        0xe9, 0x35, 0x35, 0x79, 0x0c, 0x23, 0x9b, 0xe6, 0x76, 0x5d, 0x40, 0xc8, 0xfc, 0x95, 0x2f, 0xcd,
+        0x3f, 0x01, 0xc0, 0x47, 0xb9, 0x94, 0x39, 0xbb, 0x0b, 0xbb, 0x49, 0x55, 0xb9, 0xf3, 0xad, 0x6b,
+        0x2f, 0xa9, 0xaa, 0xd3, 0x8c, 0x7d, 0x08, 0xc3, 0xb5, 0xcc, 0x6a, 0x81, 0xd6, 0xf2, 0xd1, 0x3c,
+        0x58, 0x0c, 0x8f, 0xfb, 0x19, 0x5e, 0x26, 0xb5, 0x30, 0xd1, 0xc0, 0x59, 0x4e, 0x33, 0x9b, 0xc0,
+        0x3b, 0x54, 0xba, 0x90, 0xa5, 0x75, 0xeb, 0xd0, 0x06, 0x43, 0x8f, 0x38, 0xf3, 0x46, 0x7e, 0x36,
+        0x94, 0xcd, 0xfc, 0xd8, 0x27, 0xb0, 0x2b, 0xa9, 0x10, 0xfc, 0xe9, 0x3c, 0x58, 0x8c, 0x3e, 0x3f,
+        0xd8, 0xe8, 0x47, 0x5b, 0xa4, 0xc8, 0xfb, 0xb0, 0x3d, 0xe8, 0x14, 0x15, 0xdf, 0xa1, 0x33, 0x3a,
+        0x45, 0xc5, 0x1e, 0xc0, 0xa0, 0x2c, 0xd2, 0xb7, 0x65, 0xb2, 0x46, 0xde, 0xb3, 0x01, 0x46, 0xed,
+        0xda, 0x1e, 0xac, 0x4d, 0xa2, 0x4c, 0x4c, 0x45, 0xdb, 0xa5, 0xa2, 0x0d, 0x09, 0xb9, 0xb0, 0x95,
+        0xbb, 0x0f, 0x03, 0x2c, 0x33, 0x67, 0xec, 0x93, 0xb1, 0x8f, 0x65, 0x46, 0x26, 0x0e, 0x7d, 0x91,
+        0x18, 0x2c, 0xd3, 0x6b, 0x3e, 0x70, 0x16, 0xbf, 0x24, 0xb2, 0xa5, 0xd7, 0xa9, 0x40, 0xcd, 0x87,
+        0xce, 0xe2, 0x97, 0xb6, 0xd7, 0x6b, 0x34, 0x2b, 0x99, 0x71, 0x70, 0xbd, 0x76, 0x2b, 0x1b, 0xa1,
+        0x42, 0x2d, 0x6b, 0x95, 0x22, 0x1f, 0x91, 0xa5, 0x5d, 0xb3, 0x27, 0x30, 0x5e, 0x19, 0x53, 0xc5,
+        0xbe, 0x58, 0x7c, 0x4c, 0xf6, 0x91, 0xc5, 0xbe, 0x77, 0xd0, 0x06, 0x85, 0x26, 0xd4, 0x60, 0xbf,
+        0x62, 0x4f, 0x61, 0xa2, 0x50, 0x57, 0xb2, 0xd4, 0x18, 0xeb, 0xe2, 0x27, 0xe4, 0x7b, 0x14, 0xce,
+        0xb8, 0x01, 0xcf, 0x8b, 0x9f, 0xd0, 0x9d, 0x7d, 0x89, 0x4a, 0xa1, 0xe2, 0x53, 0x57, 0x9d, 0x66,
+        0x6d, 0xab, 0x53, 0x6b, 0x54, 0x71, 0x92, 0x63, 0x69, 0xf8, 0x8c, 0xac, 0x43, 0x8b, 0xbc, 0xb0,
+        0x00, 0x0b, 0x61, 0x52, 0x2b, 0x11, 0xaf, 0x93, 0x2a, 0xc6, 0xd2, 0xa8, 0x6b, 0xbe, 0xef, 0x62,
+        0xab, 0x95, 0x78, 0x95, 0x54, 0x27, 0x16, 0xb2, 0xdb, 0xa7, 0x72, 0xfd, 0x8f, 0xa2, 0xc4, 0x8c,
+        0x33, 0x97, 0x5a, 0xb3, 0xb6, 0x0c, 0x4c, 0xaa, 0x22, 0x6e, 0x8a, 0x75, 0x67, 0x1e, 0x2c, 0xba,
+        0x11, 0x24, 0x55, 0xf1, 0xca, 0xd7, 0x8b, 0xc1, 0xce, 0x4a, 0x6a, 0xc3, 0x0f, 0xe8, 0x64, 0x7a,
+        0xb6, 0x58, 0x6a, 0xb1, 0xbb, 0xf3, 0x60, 0x11, 0x44, 0xf4, 0xcc, 0x9e, 0xc1, 0xd4, 0x24, 0xfa,
+        0x6d, 0xfc, 0x43, 0x8d, 0x35, 0xc6, 0xd4, 0xe8, 0x7b, 0xf4, 0xca, 0xc4, 0xc2, 0xdf, 0x59, 0xf4,
+        0xb5, 0xed, 0xf6, 0x43, 0x18, 0x92, 0x1f, 0x79, 0x7c, 0xe0, 0x92, 0xb5, 0x00, 0x19, 0x0f, 0xe1,
+        0xce, 0x8f, 0x89, 0x8e, 0x85, 0x4c, 0xb2, 0xa2, 0xcc, 0x63, 0xcf, 0x3e, 0xce, 0xe7, 0xc1, 0x62,
+        0x10, 0xed, 0xff, 0x98, 0xe8, 0xa5, 0xb3, 0x34, 0x83, 0xfb, 0x04, 0xc6, 0x15, 0x96, 0xe4, 0x4b,
+        0xfc, 0xb8, 0x4f, 0xe1, 0x8f, 0x3c, 0x46, 0x1c, 0xf9, 0xd8, 0x36, 0xa0, 0x12, 0x45, 0x9a, 0xc4,
+        0x45, 0x99, 0xe1, 0x15, 0x7f, 0x30, 0x0f, 0x16, 0xbd, 0xe3, 0xce, 0xa7, 0x9f, 0xd9, 0x26, 0x90,
+        0xe1, 0xd4, 0xe2, 0x6c, 0x0e, 0x83, 0xcb, 0xa2, 0x2c, 0xf4, 0x0a, 0x33, 0xfe, 0xd0, 0x1e, 0x78,
+        0xbc, 0x63, 0x54, 0x8d, 0x51, 0x8b, 0xda, 0xd0, 0x53, 0x21, 0x4b, 0x8c, 0xdf, 0xe2, 0x35, 0xff,
+        0x3d, 0x09, 0xc0, 0x80, 0x80, 0x6f, 0xf1, 0x9a, 0x3d, 0x83, 0x1d, 0x52, 0xab, 0x47, 0xa4, 0x56,
+        0x6c, 0x7b, 0x3a, 0x48, 0xa6, 0xc8, 0xce, 0xfe, 0x08, 0x33, 0xfb, 0xaf, 0xe3, 0xa2, 0x4c, 0xe5,
+        0xba, 0x12, 0x68, 0x90, 0x7f, 0x48, 0xf9, 0x4d, 0x09, 0x3f, 0x6d, 0x61, 0xf6, 0x09, 0x30, 0x3b,
+        0xed, 0x6e, 0x9b, 0x58, 0xa1, 0xc0, 0x44, 0x23, 0x7f, 0x46, 0x07, 0xcf, 0x92, 0xaa, 0x3a, 0x21,
+        0x43, 0xe4, 0x70, 0xdb, 0x49, 0xbc, 0x2a, 0x4c, 0xac, 0x30, 0xd1, 0xb2, 0xe4, 0x7f, 0xb0, 0x69,
+        0x46, 0x60, 0xa1, 0x88, 0x10, 0xf6, 0x05, 0xdc, 0xb3, 0xc5, 0x35, 0x2b, 0x25, 0x8d, 0x11, 0x98,
+        0xc5, 0x97, 0x52, 0xb9, 0xb2, 0x3d, 0xa6, 0xf3, 0x6d, 0xe9, 0x2f, 0x1a, 0xe3, 0xd7, 0x52, 0x51,
+        0xf9, 0xbe, 0x84, 0x07, 0x3f, 0x7f, 0xc9, 0xf7, 0x45, 0xf3, 0x39, 0xbd, 0xf8, 0xc1, 0xad, 0x17,
+        0x7d, 0x77, 0x34, 0xdd, 0x17, 0xed, 0x8b, 0x74, 0xd2, 0x13, 0x6a, 0xd0, 0xa4, 0x45, 0xe9, 0x8c,
+        0xc7, 0x30, 0xb2, 0x97, 0x1a, 0x2a, 0x47, 0x8a, 0x90, 0x12, 0x04, 0x07, 0x59, 0x5a, 0x84, 0x7f,
+        0x83, 0xd9, 0x52, 0xe6, 0xaf, 0x48, 0xc8, 0x9a, 0x81, 0xdb, 0xd2, 0xbc, 0xe0, 0x7d, 0x35, 0x2f,
+        0xd8, 0xd2, 0xbc, 0xf0, 0xbf, 0x3d, 0xd8, 0x5b, 0xca, 0x3c, 0xc2, 0x24, 0x6b, 0x28, 0xf5, 0x0b,
+        0x12, 0x7b, 0x7b, 0xa3, 0xee, 0xb6, 0x78, 0x7e, 0x05, 0x7b, 0x3e, 0x9a, 0x46, 0x23, 0xee, 0x10,
+        0x0f, 0x1e, 0x6e, 0xf3, 0x60, 0x2b, 0x85, 0x68, 0xb2, 0xde, 0xca, 0x68, 0x5b, 0x07, 0xbb, 0x54,
+        0xa9, 0x5f, 0xd0, 0xc1, 0x1d, 0x32, 0xb6, 0x3a, 0x78, 0xa3, 0xcd, 0xbd, 0xf7, 0xd0, 0xe6, 0x6d,
+        0xa1, 0xdf, 0x9d, 0x77, 0xb7, 0x85, 0xfe, 0x39, 0xec, 0xaf, 0x8b, 0xb2, 0x58, 0xd7, 0xeb, 0x98,
+        0xae, 0x60, 0xba, 0xb5, 0xfa, 0xc4, 0xa6, 0xa9, 0x37, 0x58, 0x46, 0xd3, 0xfd, 0xf5, 0x29, 0xb0,
+        0xa2, 0x4c, 0x45, 0x9d, 0xe1, 0x26, 0x9d, 0x07, 0x6e, 0x5c, 0xbd, 0x65, 0x83, 0xd0, 0x07, 0xd0,
+        0x4b, 0x65, 0x5d, 0x1a, 0x3e, 0xa4, 0xf8, 0xdd, 0xc2, 0xd2, 0xbc, 0x91, 0x23, 0x3a, 0x51, 0x61,
+        0x8e, 0x57, 0x7c, 0x8f, 0x7a, 0x35, 0x6b, 0x2c, 0xd4, 0xa5, 0x1c, 0xaf, 0x6c, 0xf4, 0x56, 0x83,
+        0xbc, 0x97, 0x53, 0xcb, 0xa1, 0x45, 0x9c, 0xf9, 0xe9, 0xed, 0x71, 0x9f, 0x51, 0xe4, 0xdb, 0xa3,
+        0xbe, 0x80, 0x59, 0x13, 0xb6, 0xed, 0x35, 0x7d, 0x23, 0x00, 0x05, 0xbd, 0xe7, 0x71, 0xf7, 0x75,
+        0xa1, 0xd9, 0x11, 0x1c, 0x34, 0x1e, 0x71, 0x85, 0x2d, 0xf3, 0xf9, 0x3e, 0xed, 0xba, 0x9f, 0x38,
+        0xb7, 0xbf, 0xa2, 0xda, 0x50, 0xa4, 0x66, 0x6b, 0x92, 0xcd, 0x11, 0x6d, 0x3b, 0xf2, 0xd8, 0x37,
+        0x56, 0x29, 0x1f, 0xc3, 0xa8, 0x3d, 0x5d, 0x08, 0x3e, 0x26, 0x0f, 0x68, 0x0e, 0x16, 0xc2, 0x8e,
+        0x4d, 0x9a, 0xa4, 0x2b, 0x8c, 0x0b, 0x83, 0x2a, 0x31, 0x52, 0xf1, 0x09, 0xf9, 0x4c, 0x08, 0x3d,
+        0xf5, 0xa0, 0xad, 0x44, 0x59, 0xaf, 0x63, 0xbd, 0x4a, 0x54, 0xa6, 0x39, 0xa3, 0x88, 0x86, 0x65,
+        0xbd, 0x3e, 0x27, 0x20, 0xfc, 0x57, 0x40, 0xdf, 0x83, 0x8e, 0xdb, 0xee, 0xb2, 0x61, 0x1f, 0x43,
+        0x57, 0xc8, 0x9c, 0x07, 0xc4, 0xcd, 0xbb, 0x1b, 0x2c, 0xb9, 0xf9, 0xc6, 0x88, 0xac, 0xc7, 0x06,
+        0xa3, 0x3a, 0xef, 0xc1, 0xa8, 0x10, 0x26, 0x22, 0xd1, 0x26, 0x6e, 0xf9, 0xe9, 0xc8, 0x3b, 0xb2,
+        0xe0, 0x89, 0xe3, 0x68, 0xf8, 0x9f, 0x80, 0x46, 0xed, 0x8d, 0xfd, 0xac, 0x89, 0x30, 0x95, 0xea,
+        0xf6, 0x4c, 0x05, 0xb7, 0x86, 0xf3, 0xd6, 0x3c, 0x74, 0x5c, 0x7e, 0xff, 0x7f, 0x1e, 0xba, 0x64,
+        0x6c, 0xe7, 0xa1, 0xe5, 0xd9, 0xce, 0x26, 0xcf, 0x1e, 0x01, 0x18, 0x69, 0x12, 0xe1, 0xee, 0xe1,
+        0x9e, 0x9b, 0x2f, 0x42, 0xe8, 0x12, 0xe6, 0xd0, 0x57, 0x14, 0x97, 0xe6, 0xbb, 0x6e, 0x3b, 0xbf,
+        0x0c, 0xff, 0xdd, 0xa1, 0x4a, 0xfa, 0xd0, 0x7f, 0x8b, 0x4c, 0xfc, 0x7c, 0xc4, 0x7b, 0xbf, 0x36,
+        0xe2, 0xbd, 0xcd, 0x11, 0x9f, 0xd9, 0xcf, 0x11, 0x51, 0x1b, 0xbb, 0xf7, 0x4a, 0xd6, 0x4a, 0x53,
+        0x0a, 0x93, 0xe3, 0xe0, 0xb3, 0x68, 0x7a, 0x63, 0xfa, 0xc6, 0x5a, 0xec, 0x25, 0xe3, 0x07, 0xa7,
+        0xd1, 0x23, 0x97, 0xd4, 0x20, 0x9a, 0x7a, 0xdc, 0x8b, 0x0e, 0x7d, 0xa0, 0xd4, 0x36, 0xb1, 0x56,
+        0xb8, 0xdc, 0xa8, 0x8f, 0x09, 0x6c, 0xa4, 0xe9, 0x29, 0x4c, 0x9a, 0x7d, 0x62, 0x59, 0x8a, 0x6b,
+        0x3f, 0xe2, 0xe3, 0x06, 0x3c, 0x2b, 0xc5, 0x75, 0x78, 0x45, 0x2a, 0xed, 0xab, 0xe4, 0x09, 0x77,
+        0x04, 0x3d, 0xda, 0xc8, 0x53, 0xee, 0xfe, 0x36, 0x8d, 0x36, 0xc8, 0x10, 0x39, 0x3f, 0xf6, 0x05,
+        0xf4, 0x75, 0xbd, 0x5e, 0x27, 0xea, 0xda, 0x33, 0xef, 0x57, 0x5e, 0x69, 0x3c, 0xbf, 0xea, 0xfd,
+        0xdd, 0x92, 0xf6, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x70, 0xd9, 0xa0, 0xf8, 0x48, 0x0d, 0x00,
+        0x00,
+}
diff --git a/vendor/google.golang.org/appengine/internal/log/log_service.proto b/vendor/google.golang.org/appengine/internal/log/log_service.proto
new file mode 100644
index 0000000..8981dc4
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/log/log_service.proto
@@ -0,0 +1,150 @@
+syntax = "proto2";
+option go_package = "log";
+
+package appengine;
+
+message LogServiceError {
+  enum ErrorCode {
+    OK  = 0;
+    INVALID_REQUEST = 1;
+    STORAGE_ERROR = 2;
+  }
+}
+
+message UserAppLogLine {
+  required int64 timestamp_usec = 1;
+  required int64 level = 2;
+  required string message = 3;
+}
+
+message UserAppLogGroup {
+  repeated UserAppLogLine log_line = 2;
+}
+
+message FlushRequest {
+  optional bytes logs = 1;
+}
+
+message SetStatusRequest {
+  required string status = 1;
+}
+
+
+message LogOffset {
+  optional bytes request_id = 1;
+}
+
+message LogLine {
+  required int64 time = 1;
+  required int32 level = 2;
+  required string log_message = 3;
+}
+
+message RequestLog {
+  required string app_id = 1;
+  optional string module_id = 37 [default="default"];
+  required string version_id = 2;
+  required bytes request_id = 3;
+  optional LogOffset offset = 35;
+  required string ip = 4;
+  optional string nickname = 5;
+  required int64 start_time = 6;
+  required int64 end_time = 7;
+  required int64 latency = 8;
+  required int64 mcycles = 9;
+  required string method = 10;
+  required string resource = 11;
+  required string http_version = 12;
+  required int32 status = 13;
+  required int64 response_size = 14;
+  optional string referrer = 15;
+  optional string user_agent = 16;
+  required string url_map_entry = 17;
+  required string combined = 18;
+  optional int64 api_mcycles = 19;
+  optional string host = 20;
+  optional double cost = 21;
+
+  optional string task_queue_name = 22;
+  optional string task_name = 23;
+
+  optional bool was_loading_request = 24;
+  optional int64 pending_time = 25;
+  optional int32 replica_index = 26 [default = -1];
+  optional bool finished = 27 [default = true];
+  optional bytes clone_key = 28;
+
+  repeated LogLine line = 29;
+
+  optional bool lines_incomplete = 36;
+  optional bytes app_engine_release = 38;
+
+  optional int32 exit_reason = 30;
+  optional bool was_throttled_for_time = 31;
+  optional bool was_throttled_for_requests = 32;
+  optional int64 throttled_time = 33;
+
+  optional bytes server_name = 34;
+}
+
+message LogModuleVersion {
+  optional string module_id = 1 [default="default"];
+  optional string version_id = 2;
+}
+
+message LogReadRequest {
+  required string app_id = 1;
+  repeated string version_id = 2;
+  repeated LogModuleVersion module_version = 19;
+
+  optional int64 start_time = 3;
+  optional int64 end_time = 4;
+  optional LogOffset offset = 5;
+  repeated bytes request_id = 6;
+
+  optional int32 minimum_log_level = 7;
+  optional bool include_incomplete = 8;
+  optional int64 count = 9;
+
+  optional string combined_log_regex = 14;
+  optional string host_regex = 15;
+  optional int32 replica_index = 16;
+
+  optional bool include_app_logs = 10;
+  optional int32 app_logs_per_request = 17;
+  optional bool include_host = 11;
+  optional bool include_all = 12;
+  optional bool cache_iterator = 13;
+  optional int32 num_shards = 18;
+}
+
+message LogReadResponse {
+  repeated RequestLog log = 1;
+  optional LogOffset offset = 2;
+  optional int64 last_end_time = 3;
+}
+
+message LogUsageRecord {
+  optional string version_id = 1;
+  optional int32 start_time = 2;
+  optional int32 end_time = 3;
+  optional int64 count = 4;
+  optional int64 total_size = 5;
+  optional int32 records = 6;
+}
+
+message LogUsageRequest {
+  required string app_id = 1;
+  repeated string version_id = 2;
+  optional int32 start_time = 3;
+  optional int32 end_time = 4;
+  optional uint32 resolution_hours = 5 [default = 1];
+  optional bool combine_versions = 6;
+  optional int32 usage_version = 7;
+  optional bool versions_only = 8;
+}
+
+message LogUsageResponse {
+  repeated LogUsageRecord usage = 1;
+  optional LogUsageRecord summary = 2;
+}
diff --git a/vendor/google.golang.org/appengine/internal/main.go b/vendor/google.golang.org/appengine/internal/main.go
new file mode 100644
index 0000000..1e76531
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/main.go
@@ -0,0 +1,16 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+package internal
+
+import (
+        "appengine_internal"
+)
+
+func Main() {
+        MainPath = ""
+        appengine_internal.Main()
+}
diff --git a/vendor/google.golang.org/appengine/internal/main_common.go b/vendor/google.golang.org/appengine/internal/main_common.go
new file mode 100644
index 0000000..357dce4
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/main_common.go
@@ -0,0 +1,7 @@
+package internal
+
+// MainPath stores the file path of the main package. On App Engine Standard
+// using Go version 1.9 and below, this will be unset. On App Engine Flex and
+// App Engine Standard second-gen (Go 1.11 and above), this will be the
+// filepath to package main.
+var MainPath string
diff --git a/vendor/google.golang.org/appengine/internal/main_vm.go b/vendor/google.golang.org/appengine/internal/main_vm.go
new file mode 100644
index 0000000..ddb79a3
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/main_vm.go
@@ -0,0 +1,69 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// +build !appengine
+
+package internal
+
+import (
+        "io"
+        "log"
+        "net/http"
+        "net/url"
+        "os"
+        "path/filepath"
+        "runtime"
+)
+
+func Main() {
+        MainPath = filepath.Dir(findMainPath())
+        installHealthChecker(http.DefaultServeMux)
+
+        port := "8080"
+        if s := os.Getenv("PORT"); s != "" {
+                port = s
+        }
+
+        host := ""
+        if IsDevAppServer() {
+                host = "127.0.0.1"
+        }
+        if err := http.ListenAndServe(host+":"+port, http.HandlerFunc(handleHTTP)); err != nil {
+                log.Fatalf("http.ListenAndServe: %v", err)
+        }
+}
+
+// Find the path to package main by looking at the root Caller.
+func findMainPath() string {
+        pc := make([]uintptr, 100)
+        n := runtime.Callers(2, pc)
+        frames := runtime.CallersFrames(pc[:n])
+        for {
+                frame, more := frames.Next()
+                // Tests won't have package main, instead they have testing.tRunner
+                if frame.Function == "main.main" || frame.Function == "testing.tRunner" {
+                        return frame.File
+                }
+                if !more {
+                        break
+                }
+        }
+        return ""
+}
+
+func installHealthChecker(mux *http.ServeMux) {
+        // If no health check handler has been installed by this point, add a trivial one.
+        const healthPath = "/_ah/health"
+        hreq := &http.Request{
+                Method: "GET",
+                URL: &url.URL{
+                        Path: healthPath,
+                },
+        }
+        if _, pat := mux.Handler(hreq); pat != healthPath {
+                mux.HandleFunc(healthPath, func(w http.ResponseWriter, r *http.Request) {
+                        io.WriteString(w, "ok")
+                })
+        }
+}
diff --git a/vendor/google.golang.org/appengine/internal/metadata.go b/vendor/google.golang.org/appengine/internal/metadata.go
new file mode 100644
index 0000000..c4ba63b
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/metadata.go
@@ -0,0 +1,60 @@
+// Copyright 2014 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package internal
+
+// This file has code for accessing metadata.
+//
+// References:
+//      https://cloud.google.com/compute/docs/metadata
+
+import (
+        "fmt"
+        "io/ioutil"
+        "net/http"
+        "net/url"
+)
+
+const (
+        metadataHost = "metadata"
+        metadataPath = "/computeMetadata/v1/"
+)
+
+var (
+        metadataRequestHeaders = http.Header{
+                "Metadata-Flavor": []string{"Google"},
+        }
+)
+
+// TODO(dsymonds): Do we need to support default values, like Python?
+func mustGetMetadata(key string) []byte {
+        b, err := getMetadata(key)
+        if err != nil {
+                panic(fmt.Sprintf("Metadata fetch failed for '%s': %v", key, err))
+        }
+        return b
+}
+
+func getMetadata(key string) ([]byte, error) {
+        // TODO(dsymonds): May need to use url.Parse to support keys with query args.
+        req := &http.Request{
+                Method: "GET",
+                URL: &url.URL{
+                        Scheme: "http",
+                        Host:   metadataHost,
+                        Path:   metadataPath + key,
+                },
+                Header: metadataRequestHeaders,
+                Host:   metadataHost,
+        }
+        resp, err := http.DefaultClient.Do(req)
+        if err != nil {
+                return nil, err
+        }
+        defer resp.Body.Close()
+        if resp.StatusCode != 200 {
+                return nil, fmt.Errorf("metadata server returned HTTP %d", resp.StatusCode)
+        }
+        return ioutil.ReadAll(resp.Body)
+}
diff --git a/vendor/google.golang.org/appengine/internal/modules/modules_service.pb.go b/vendor/google.golang.org/appengine/internal/modules/modules_service.pb.go
new file mode 100644
index 0000000..ddfc0c0
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/modules/modules_service.pb.go
@@ -0,0 +1,786 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google.golang.org/appengine/internal/modules/modules_service.proto
+
+package modules
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type ModulesServiceError_ErrorCode int32
+
+const (
+        ModulesServiceError_OK                ModulesServiceError_ErrorCode = 0
+        ModulesServiceError_INVALID_MODULE    ModulesServiceError_ErrorCode = 1
+        ModulesServiceError_INVALID_VERSION   ModulesServiceError_ErrorCode = 2
+        ModulesServiceError_INVALID_INSTANCES ModulesServiceError_ErrorCode = 3
+        ModulesServiceError_TRANSIENT_ERROR   ModulesServiceError_ErrorCode = 4
+        ModulesServiceError_UNEXPECTED_STATE  ModulesServiceError_ErrorCode = 5
+)
+
+var ModulesServiceError_ErrorCode_name = map[int32]string{
+        0: "OK",
+        1: "INVALID_MODULE",
+        2: "INVALID_VERSION",
+        3: "INVALID_INSTANCES",
+        4: "TRANSIENT_ERROR",
+        5: "UNEXPECTED_STATE",
+}
+var ModulesServiceError_ErrorCode_value = map[string]int32{
+        "OK":                0,
+        "INVALID_MODULE":    1,
+        "INVALID_VERSION":   2,
+        "INVALID_INSTANCES": 3,
+        "TRANSIENT_ERROR":   4,
+        "UNEXPECTED_STATE":  5,
+}
+
+func (x ModulesServiceError_ErrorCode) Enum() *ModulesServiceError_ErrorCode {
+        p := new(ModulesServiceError_ErrorCode)
+        *p = x
+        return p
+}
+func (x ModulesServiceError_ErrorCode) String() string {
+        return proto.EnumName(ModulesServiceError_ErrorCode_name, int32(x))
+}
+func (x *ModulesServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(ModulesServiceError_ErrorCode_value, data, "ModulesServiceError_ErrorCode")
+        if err != nil {
+                return err
+        }
+        *x = ModulesServiceError_ErrorCode(value)
+        return nil
+}
+func (ModulesServiceError_ErrorCode) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{0, 0}
+}
+
+type ModulesServiceError struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ModulesServiceError) Reset()         { *m = ModulesServiceError{} }
+func (m *ModulesServiceError) String() string { return proto.CompactTextString(m) }
+func (*ModulesServiceError) ProtoMessage()    {}
+func (*ModulesServiceError) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{0}
+}
+func (m *ModulesServiceError) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_ModulesServiceError.Unmarshal(m, b)
+}
+func (m *ModulesServiceError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_ModulesServiceError.Marshal(b, m, deterministic)
+}
+func (dst *ModulesServiceError) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_ModulesServiceError.Merge(dst, src)
+}
+func (m *ModulesServiceError) XXX_Size() int {
+        return xxx_messageInfo_ModulesServiceError.Size(m)
+}
+func (m *ModulesServiceError) XXX_DiscardUnknown() {
+        xxx_messageInfo_ModulesServiceError.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ModulesServiceError proto.InternalMessageInfo
+
+type GetModulesRequest struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetModulesRequest) Reset()         { *m = GetModulesRequest{} }
+func (m *GetModulesRequest) String() string { return proto.CompactTextString(m) }
+func (*GetModulesRequest) ProtoMessage()    {}
+func (*GetModulesRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{1}
+}
+func (m *GetModulesRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetModulesRequest.Unmarshal(m, b)
+}
+func (m *GetModulesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetModulesRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetModulesRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetModulesRequest.Merge(dst, src)
+}
+func (m *GetModulesRequest) XXX_Size() int {
+        return xxx_messageInfo_GetModulesRequest.Size(m)
+}
+func (m *GetModulesRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetModulesRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetModulesRequest proto.InternalMessageInfo
+
+type GetModulesResponse struct {
+        Module               []string `protobuf:"bytes,1,rep,name=module" json:"module,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetModulesResponse) Reset()         { *m = GetModulesResponse{} }
+func (m *GetModulesResponse) String() string { return proto.CompactTextString(m) }
+func (*GetModulesResponse) ProtoMessage()    {}
+func (*GetModulesResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{2}
+}
+func (m *GetModulesResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetModulesResponse.Unmarshal(m, b)
+}
+func (m *GetModulesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetModulesResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetModulesResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetModulesResponse.Merge(dst, src)
+}
+func (m *GetModulesResponse) XXX_Size() int {
+        return xxx_messageInfo_GetModulesResponse.Size(m)
+}
+func (m *GetModulesResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetModulesResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetModulesResponse proto.InternalMessageInfo
+
+func (m *GetModulesResponse) GetModule() []string {
+        if m != nil {
+                return m.Module
+        }
+        return nil
+}
+
+type GetVersionsRequest struct {
+        Module               *string  `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetVersionsRequest) Reset()         { *m = GetVersionsRequest{} }
+func (m *GetVersionsRequest) String() string { return proto.CompactTextString(m) }
+func (*GetVersionsRequest) ProtoMessage()    {}
+func (*GetVersionsRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{3}
+}
+func (m *GetVersionsRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetVersionsRequest.Unmarshal(m, b)
+}
+func (m *GetVersionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetVersionsRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetVersionsRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetVersionsRequest.Merge(dst, src)
+}
+func (m *GetVersionsRequest) XXX_Size() int {
+        return xxx_messageInfo_GetVersionsRequest.Size(m)
+}
+func (m *GetVersionsRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetVersionsRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetVersionsRequest proto.InternalMessageInfo
+
+func (m *GetVersionsRequest) GetModule() string {
+        if m != nil && m.Module != nil {
+                return *m.Module
+        }
+        return ""
+}
+
+type GetVersionsResponse struct {
+        Version              []string `protobuf:"bytes,1,rep,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetVersionsResponse) Reset()         { *m = GetVersionsResponse{} }
+func (m *GetVersionsResponse) String() string { return proto.CompactTextString(m) }
+func (*GetVersionsResponse) ProtoMessage()    {}
+func (*GetVersionsResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{4}
+}
+func (m *GetVersionsResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetVersionsResponse.Unmarshal(m, b)
+}
+func (m *GetVersionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetVersionsResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetVersionsResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetVersionsResponse.Merge(dst, src)
+}
+func (m *GetVersionsResponse) XXX_Size() int {
+        return xxx_messageInfo_GetVersionsResponse.Size(m)
+}
+func (m *GetVersionsResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetVersionsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetVersionsResponse proto.InternalMessageInfo
+
+func (m *GetVersionsResponse) GetVersion() []string {
+        if m != nil {
+                return m.Version
+        }
+        return nil
+}
+
+type GetDefaultVersionRequest struct {
+        Module               *string  `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetDefaultVersionRequest) Reset()         { *m = GetDefaultVersionRequest{} }
+func (m *GetDefaultVersionRequest) String() string { return proto.CompactTextString(m) }
+func (*GetDefaultVersionRequest) ProtoMessage()    {}
+func (*GetDefaultVersionRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{5}
+}
+func (m *GetDefaultVersionRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetDefaultVersionRequest.Unmarshal(m, b)
+}
+func (m *GetDefaultVersionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetDefaultVersionRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetDefaultVersionRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetDefaultVersionRequest.Merge(dst, src)
+}
+func (m *GetDefaultVersionRequest) XXX_Size() int {
+        return xxx_messageInfo_GetDefaultVersionRequest.Size(m)
+}
+func (m *GetDefaultVersionRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetDefaultVersionRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetDefaultVersionRequest proto.InternalMessageInfo
+
+func (m *GetDefaultVersionRequest) GetModule() string {
+        if m != nil && m.Module != nil {
+                return *m.Module
+        }
+        return ""
+}
+
+type GetDefaultVersionResponse struct {
+        Version              *string  `protobuf:"bytes,1,req,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetDefaultVersionResponse) Reset()         { *m = GetDefaultVersionResponse{} }
+func (m *GetDefaultVersionResponse) String() string { return proto.CompactTextString(m) }
+func (*GetDefaultVersionResponse) ProtoMessage()    {}
+func (*GetDefaultVersionResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{6}
+}
+func (m *GetDefaultVersionResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetDefaultVersionResponse.Unmarshal(m, b)
+}
+func (m *GetDefaultVersionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetDefaultVersionResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetDefaultVersionResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetDefaultVersionResponse.Merge(dst, src)
+}
+func (m *GetDefaultVersionResponse) XXX_Size() int {
+        return xxx_messageInfo_GetDefaultVersionResponse.Size(m)
+}
+func (m *GetDefaultVersionResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetDefaultVersionResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetDefaultVersionResponse proto.InternalMessageInfo
+
+func (m *GetDefaultVersionResponse) GetVersion() string {
+        if m != nil && m.Version != nil {
+                return *m.Version
+        }
+        return ""
+}
+
+type GetNumInstancesRequest struct {
+        Module               *string  `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
+        Version              *string  `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetNumInstancesRequest) Reset()         { *m = GetNumInstancesRequest{} }
+func (m *GetNumInstancesRequest) String() string { return proto.CompactTextString(m) }
+func (*GetNumInstancesRequest) ProtoMessage()    {}
+func (*GetNumInstancesRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{7}
+}
+func (m *GetNumInstancesRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetNumInstancesRequest.Unmarshal(m, b)
+}
+func (m *GetNumInstancesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetNumInstancesRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetNumInstancesRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetNumInstancesRequest.Merge(dst, src)
+}
+func (m *GetNumInstancesRequest) XXX_Size() int {
+        return xxx_messageInfo_GetNumInstancesRequest.Size(m)
+}
+func (m *GetNumInstancesRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetNumInstancesRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetNumInstancesRequest proto.InternalMessageInfo
+
+func (m *GetNumInstancesRequest) GetModule() string {
+        if m != nil && m.Module != nil {
+                return *m.Module
+        }
+        return ""
+}
+
+func (m *GetNumInstancesRequest) GetVersion() string {
+        if m != nil && m.Version != nil {
+                return *m.Version
+        }
+        return ""
+}
+
+type GetNumInstancesResponse struct {
+        Instances            *int64   `protobuf:"varint,1,req,name=instances" json:"instances,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetNumInstancesResponse) Reset()         { *m = GetNumInstancesResponse{} }
+func (m *GetNumInstancesResponse) String() string { return proto.CompactTextString(m) }
+func (*GetNumInstancesResponse) ProtoMessage()    {}
+func (*GetNumInstancesResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{8}
+}
+func (m *GetNumInstancesResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetNumInstancesResponse.Unmarshal(m, b)
+}
+func (m *GetNumInstancesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetNumInstancesResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetNumInstancesResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetNumInstancesResponse.Merge(dst, src)
+}
+func (m *GetNumInstancesResponse) XXX_Size() int {
+        return xxx_messageInfo_GetNumInstancesResponse.Size(m)
+}
+func (m *GetNumInstancesResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetNumInstancesResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetNumInstancesResponse proto.InternalMessageInfo
+
+func (m *GetNumInstancesResponse) GetInstances() int64 {
+        if m != nil && m.Instances != nil {
+                return *m.Instances
+        }
+        return 0
+}
+
+type SetNumInstancesRequest struct {
+        Module               *string  `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
+        Version              *string  `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
+        Instances            *int64   `protobuf:"varint,3,req,name=instances" json:"instances,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SetNumInstancesRequest) Reset()         { *m = SetNumInstancesRequest{} }
+func (m *SetNumInstancesRequest) String() string { return proto.CompactTextString(m) }
+func (*SetNumInstancesRequest) ProtoMessage()    {}
+func (*SetNumInstancesRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{9}
+}
+func (m *SetNumInstancesRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_SetNumInstancesRequest.Unmarshal(m, b)
+}
+func (m *SetNumInstancesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_SetNumInstancesRequest.Marshal(b, m, deterministic)
+}
+func (dst *SetNumInstancesRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_SetNumInstancesRequest.Merge(dst, src)
+}
+func (m *SetNumInstancesRequest) XXX_Size() int {
+        return xxx_messageInfo_SetNumInstancesRequest.Size(m)
+}
+func (m *SetNumInstancesRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_SetNumInstancesRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetNumInstancesRequest proto.InternalMessageInfo
+
+func (m *SetNumInstancesRequest) GetModule() string {
+        if m != nil && m.Module != nil {
+                return *m.Module
+        }
+        return ""
+}
+
+func (m *SetNumInstancesRequest) GetVersion() string {
+        if m != nil && m.Version != nil {
+                return *m.Version
+        }
+        return ""
+}
+
+func (m *SetNumInstancesRequest) GetInstances() int64 {
+        if m != nil && m.Instances != nil {
+                return *m.Instances
+        }
+        return 0
+}
+
+type SetNumInstancesResponse struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SetNumInstancesResponse) Reset()         { *m = SetNumInstancesResponse{} }
+func (m *SetNumInstancesResponse) String() string { return proto.CompactTextString(m) }
+func (*SetNumInstancesResponse) ProtoMessage()    {}
+func (*SetNumInstancesResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{10}
+}
+func (m *SetNumInstancesResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_SetNumInstancesResponse.Unmarshal(m, b)
+}
+func (m *SetNumInstancesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_SetNumInstancesResponse.Marshal(b, m, deterministic)
+}
+func (dst *SetNumInstancesResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_SetNumInstancesResponse.Merge(dst, src)
+}
+func (m *SetNumInstancesResponse) XXX_Size() int {
+        return xxx_messageInfo_SetNumInstancesResponse.Size(m)
+}
+func (m *SetNumInstancesResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_SetNumInstancesResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetNumInstancesResponse proto.InternalMessageInfo
+
+type StartModuleRequest struct {
+        Module               *string  `protobuf:"bytes,1,req,name=module" json:"module,omitempty"`
+        Version              *string  `protobuf:"bytes,2,req,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *StartModuleRequest) Reset()         { *m = StartModuleRequest{} }
+func (m *StartModuleRequest) String() string { return proto.CompactTextString(m) }
+func (*StartModuleRequest) ProtoMessage()    {}
+func (*StartModuleRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{11}
+}
+func (m *StartModuleRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_StartModuleRequest.Unmarshal(m, b)
+}
+func (m *StartModuleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_StartModuleRequest.Marshal(b, m, deterministic)
+}
+func (dst *StartModuleRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_StartModuleRequest.Merge(dst, src)
+}
+func (m *StartModuleRequest) XXX_Size() int {
+        return xxx_messageInfo_StartModuleRequest.Size(m)
+}
+func (m *StartModuleRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_StartModuleRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StartModuleRequest proto.InternalMessageInfo
+
+func (m *StartModuleRequest) GetModule() string {
+        if m != nil && m.Module != nil {
+                return *m.Module
+        }
+        return ""
+}
+
+func (m *StartModuleRequest) GetVersion() string {
+        if m != nil && m.Version != nil {
+                return *m.Version
+        }
+        return ""
+}
+
+type StartModuleResponse struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *StartModuleResponse) Reset()         { *m = StartModuleResponse{} }
+func (m *StartModuleResponse) String() string { return proto.CompactTextString(m) }
+func (*StartModuleResponse) ProtoMessage()    {}
+func (*StartModuleResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{12}
+}
+func (m *StartModuleResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_StartModuleResponse.Unmarshal(m, b)
+}
+func (m *StartModuleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_StartModuleResponse.Marshal(b, m, deterministic)
+}
+func (dst *StartModuleResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_StartModuleResponse.Merge(dst, src)
+}
+func (m *StartModuleResponse) XXX_Size() int {
+        return xxx_messageInfo_StartModuleResponse.Size(m)
+}
+func (m *StartModuleResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_StartModuleResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StartModuleResponse proto.InternalMessageInfo
+
+type StopModuleRequest struct {
+        Module               *string  `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
+        Version              *string  `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *StopModuleRequest) Reset()         { *m = StopModuleRequest{} }
+func (m *StopModuleRequest) String() string { return proto.CompactTextString(m) }
+func (*StopModuleRequest) ProtoMessage()    {}
+func (*StopModuleRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{13}
+}
+func (m *StopModuleRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_StopModuleRequest.Unmarshal(m, b)
+}
+func (m *StopModuleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_StopModuleRequest.Marshal(b, m, deterministic)
+}
+func (dst *StopModuleRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_StopModuleRequest.Merge(dst, src)
+}
+func (m *StopModuleRequest) XXX_Size() int {
+        return xxx_messageInfo_StopModuleRequest.Size(m)
+}
+func (m *StopModuleRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_StopModuleRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StopModuleRequest proto.InternalMessageInfo
+
+func (m *StopModuleRequest) GetModule() string {
+        if m != nil && m.Module != nil {
+                return *m.Module
+        }
+        return ""
+}
+
+func (m *StopModuleRequest) GetVersion() string {
+        if m != nil && m.Version != nil {
+                return *m.Version
+        }
+        return ""
+}
+
+type StopModuleResponse struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *StopModuleResponse) Reset()         { *m = StopModuleResponse{} }
+func (m *StopModuleResponse) String() string { return proto.CompactTextString(m) }
+func (*StopModuleResponse) ProtoMessage()    {}
+func (*StopModuleResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{14}
+}
+func (m *StopModuleResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_StopModuleResponse.Unmarshal(m, b)
+}
+func (m *StopModuleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_StopModuleResponse.Marshal(b, m, deterministic)
+}
+func (dst *StopModuleResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_StopModuleResponse.Merge(dst, src)
+}
+func (m *StopModuleResponse) XXX_Size() int {
+        return xxx_messageInfo_StopModuleResponse.Size(m)
+}
+func (m *StopModuleResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_StopModuleResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StopModuleResponse proto.InternalMessageInfo
+
+type GetHostnameRequest struct {
+        Module               *string  `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
+        Version              *string  `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
+        Instance             *string  `protobuf:"bytes,3,opt,name=instance" json:"instance,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetHostnameRequest) Reset()         { *m = GetHostnameRequest{} }
+func (m *GetHostnameRequest) String() string { return proto.CompactTextString(m) }
+func (*GetHostnameRequest) ProtoMessage()    {}
+func (*GetHostnameRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{15}
+}
+func (m *GetHostnameRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetHostnameRequest.Unmarshal(m, b)
+}
+func (m *GetHostnameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetHostnameRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetHostnameRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetHostnameRequest.Merge(dst, src)
+}
+func (m *GetHostnameRequest) XXX_Size() int {
+        return xxx_messageInfo_GetHostnameRequest.Size(m)
+}
+func (m *GetHostnameRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetHostnameRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetHostnameRequest proto.InternalMessageInfo
+
+func (m *GetHostnameRequest) GetModule() string {
+        if m != nil && m.Module != nil {
+                return *m.Module
+        }
+        return ""
+}
+
+func (m *GetHostnameRequest) GetVersion() string {
+        if m != nil && m.Version != nil {
+                return *m.Version
+        }
+        return ""
+}
+
+func (m *GetHostnameRequest) GetInstance() string {
+        if m != nil && m.Instance != nil {
+                return *m.Instance
+        }
+        return ""
+}
+
+type GetHostnameResponse struct {
+        Hostname             *string  `protobuf:"bytes,1,req,name=hostname" json:"hostname,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetHostnameResponse) Reset()         { *m = GetHostnameResponse{} }
+func (m *GetHostnameResponse) String() string { return proto.CompactTextString(m) }
+func (*GetHostnameResponse) ProtoMessage()    {}
+func (*GetHostnameResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{16}
+}
+func (m *GetHostnameResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetHostnameResponse.Unmarshal(m, b)
+}
+func (m *GetHostnameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetHostnameResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetHostnameResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetHostnameResponse.Merge(dst, src)
+}
+func (m *GetHostnameResponse) XXX_Size() int {
+        return xxx_messageInfo_GetHostnameResponse.Size(m)
+}
+func (m *GetHostnameResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetHostnameResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetHostnameResponse proto.InternalMessageInfo
+
+func (m *GetHostnameResponse) GetHostname() string {
+        if m != nil && m.Hostname != nil {
+                return *m.Hostname
+        }
+        return ""
+}
+
+func init() {
+        proto.RegisterType((*ModulesServiceError)(nil), "appengine.ModulesServiceError")
+        proto.RegisterType((*GetModulesRequest)(nil), "appengine.GetModulesRequest")
+        proto.RegisterType((*GetModulesResponse)(nil), "appengine.GetModulesResponse")
+        proto.RegisterType((*GetVersionsRequest)(nil), "appengine.GetVersionsRequest")
+        proto.RegisterType((*GetVersionsResponse)(nil), "appengine.GetVersionsResponse")
+        proto.RegisterType((*GetDefaultVersionRequest)(nil), "appengine.GetDefaultVersionRequest")
+        proto.RegisterType((*GetDefaultVersionResponse)(nil), "appengine.GetDefaultVersionResponse")
+        proto.RegisterType((*GetNumInstancesRequest)(nil), "appengine.GetNumInstancesRequest")
+        proto.RegisterType((*GetNumInstancesResponse)(nil), "appengine.GetNumInstancesResponse")
+        proto.RegisterType((*SetNumInstancesRequest)(nil), "appengine.SetNumInstancesRequest")
+        proto.RegisterType((*SetNumInstancesResponse)(nil), "appengine.SetNumInstancesResponse")
+        proto.RegisterType((*StartModuleRequest)(nil), "appengine.StartModuleRequest")
+        proto.RegisterType((*StartModuleResponse)(nil), "appengine.StartModuleResponse")
+        proto.RegisterType((*StopModuleRequest)(nil), "appengine.StopModuleRequest")
+        proto.RegisterType((*StopModuleResponse)(nil), "appengine.StopModuleResponse")
+        proto.RegisterType((*GetHostnameRequest)(nil), "appengine.GetHostnameRequest")
+        proto.RegisterType((*GetHostnameResponse)(nil), "appengine.GetHostnameResponse")
+}
+
+func init() {
+        proto.RegisterFile("google.golang.org/appengine/internal/modules/modules_service.proto", fileDescriptor_modules_service_9cd3bffe4e91c59a)
+}
+
+var fileDescriptor_modules_service_9cd3bffe4e91c59a = []byte{
+        // 457 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0xc1, 0x6f, 0xd3, 0x30,
+        0x14, 0xc6, 0x69, 0x02, 0xdb, 0xf2, 0x0e, 0x90, 0x3a, 0x5b, 0xd7, 0x4d, 0x1c, 0x50, 0x4e, 0x1c,
+        0x50, 0x2b, 0x90, 0x10, 0xe7, 0xae, 0x35, 0x25, 0xb0, 0xa5, 0x28, 0xce, 0x2a, 0xc4, 0xa5, 0x0a,
+        0xdb, 0x23, 0x8b, 0x94, 0xda, 0xc1, 0x76, 0x77, 0xe4, 0xbf, 0xe0, 0xff, 0x45, 0x4b, 0xed, 0xb6,
+        0x81, 0x4e, 0x45, 0x68, 0xa7, 0xe4, 0x7d, 0xfe, 0xfc, 0x7b, 0x9f, 0x5f, 0xac, 0xc0, 0x59, 0x2e,
+        0x44, 0x5e, 0x62, 0x2f, 0x17, 0x65, 0xc6, 0xf3, 0x9e, 0x90, 0x79, 0x3f, 0xab, 0x2a, 0xe4, 0x79,
+        0xc1, 0xb1, 0x5f, 0x70, 0x8d, 0x92, 0x67, 0x65, 0x7f, 0x2e, 0xae, 0x17, 0x25, 0x2a, 0xfb, 0x9c,
+        0x29, 0x94, 0xb7, 0xc5, 0x15, 0xf6, 0x2a, 0x29, 0xb4, 0x20, 0xde, 0x6a, 0x47, 0xf8, 0xab, 0x05,
+        0xc1, 0xc5, 0xd2, 0xc4, 0x96, 0x1e, 0x2a, 0xa5, 0x90, 0xe1, 0x4f, 0xf0, 0xea, 0x97, 0xa1, 0xb8,
+        0x46, 0xb2, 0x07, 0xce, 0xe4, 0x93, 0xff, 0x88, 0x10, 0x78, 0x1a, 0xc5, 0xd3, 0xc1, 0x79, 0x34,
+        0x9a, 0x5d, 0x4c, 0x46, 0x97, 0xe7, 0xd4, 0x6f, 0x91, 0x00, 0x9e, 0x59, 0x6d, 0x4a, 0x13, 0x16,
+        0x4d, 0x62, 0xdf, 0x21, 0x47, 0xd0, 0xb6, 0x62, 0x14, 0xb3, 0x74, 0x10, 0x0f, 0x29, 0xf3, 0xdd,
+        0x3b, 0x6f, 0x9a, 0x0c, 0x62, 0x16, 0xd1, 0x38, 0x9d, 0xd1, 0x24, 0x99, 0x24, 0xfe, 0x63, 0x72,
+        0x08, 0xfe, 0x65, 0x4c, 0xbf, 0x7c, 0xa6, 0xc3, 0x94, 0x8e, 0x66, 0x2c, 0x1d, 0xa4, 0xd4, 0x7f,
+        0x12, 0x06, 0xd0, 0x1e, 0xa3, 0x36, 0xc9, 0x12, 0xfc, 0xb1, 0x40, 0xa5, 0xc3, 0x57, 0x40, 0x36,
+        0x45, 0x55, 0x09, 0xae, 0x90, 0x74, 0x60, 0x6f, 0x79, 0xcc, 0x6e, 0xeb, 0x85, 0xfb, 0xd2, 0x4b,
+        0x4c, 0x65, 0xdc, 0x53, 0x94, 0xaa, 0x10, 0xdc, 0x32, 0x1a, 0xee, 0xd6, 0x86, 0xbb, 0x0f, 0x41,
+        0xc3, 0x6d, 0xe0, 0x5d, 0xd8, 0xbf, 0x5d, 0x6a, 0x86, 0x6e, 0xcb, 0xf0, 0x0d, 0x74, 0xc7, 0xa8,
+        0x47, 0xf8, 0x3d, 0x5b, 0x94, 0x76, 0xdf, 0xae, 0x26, 0x6f, 0xe1, 0x64, 0xcb, 0x9e, 0x6d, 0xad,
+        0x9c, 0xcd, 0x56, 0x1f, 0xa1, 0x33, 0x46, 0x1d, 0x2f, 0xe6, 0x11, 0x57, 0x3a, 0xe3, 0x57, 0xb8,
+        0xeb, 0x34, 0x9b, 0x2c, 0xa7, 0x5e, 0x58, 0xb1, 0xde, 0xc1, 0xf1, 0x5f, 0x2c, 0x13, 0xe0, 0x39,
+        0x78, 0x85, 0x15, 0xeb, 0x08, 0x6e, 0xb2, 0x16, 0xc2, 0x1b, 0xe8, 0xb0, 0x07, 0x0a, 0xd1, 0xec,
+        0xe4, 0xfe, 0xd9, 0xe9, 0x04, 0x8e, 0xd9, 0xf6, 0x88, 0xe1, 0x7b, 0x20, 0x4c, 0x67, 0xd2, 0xdc,
+        0x81, 0x6d, 0x01, 0x9c, 0xfb, 0x02, 0x34, 0x26, 0x7a, 0x04, 0x41, 0x83, 0x63, 0xf0, 0x14, 0xda,
+        0x4c, 0x8b, 0xea, 0x7e, 0xfa, 0xbf, 0xcd, 0xf8, 0xf0, 0x2e, 0xe5, 0x1a, 0x63, 0xe0, 0xdf, 0xea,
+        0xfb, 0xf8, 0x41, 0x28, 0xcd, 0xb3, 0xf9, 0xff, 0xd3, 0xc9, 0x29, 0x1c, 0xd8, 0x59, 0x75, 0xdd,
+        0x7a, 0x69, 0x55, 0x87, 0xaf, 0xeb, 0x5b, 0xbc, 0xee, 0x61, 0xbe, 0xec, 0x29, 0x1c, 0xdc, 0x18,
+        0xcd, 0x8c, 0x68, 0x55, 0x9f, 0x79, 0x5f, 0xf7, 0xcd, 0x5f, 0xe2, 0x77, 0x00, 0x00, 0x00, 0xff,
+        0xff, 0x6e, 0xbc, 0xe0, 0x61, 0x5c, 0x04, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/appengine/internal/modules/modules_service.proto b/vendor/google.golang.org/appengine/internal/modules/modules_service.proto
new file mode 100644
index 0000000..d29f006
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/modules/modules_service.proto
@@ -0,0 +1,80 @@
+syntax = "proto2";
+option go_package = "modules";
+
+package appengine;
+
+message ModulesServiceError {
+  enum ErrorCode {
+    OK  = 0;
+    INVALID_MODULE = 1;
+    INVALID_VERSION = 2;
+    INVALID_INSTANCES = 3;
+    TRANSIENT_ERROR = 4;
+    UNEXPECTED_STATE = 5;
+  }
+}
+
+message GetModulesRequest {
+}
+
+message GetModulesResponse {
+  repeated string module = 1;
+}
+
+message GetVersionsRequest {
+  optional string module = 1;
+}
+
+message GetVersionsResponse {
+  repeated string version = 1;
+}
+
+message GetDefaultVersionRequest {
+  optional string module = 1;
+}
+
+message GetDefaultVersionResponse {
+  required string version = 1;
+}
+
+message GetNumInstancesRequest {
+  optional string module = 1;
+  optional string version = 2;
+}
+
+message GetNumInstancesResponse {
+  required int64 instances = 1;
+}
+
+message SetNumInstancesRequest {
+  optional string module = 1;
+  optional string version = 2;
+  required int64 instances = 3;
+}
+
+message SetNumInstancesResponse {}
+
+message StartModuleRequest {
+  required string module = 1;
+  required string version = 2;
+}
+
+message StartModuleResponse {}
+
+message StopModuleRequest {
+  optional string module = 1;
+  optional string version = 2;
+}
+
+message StopModuleResponse {}
+
+message GetHostnameRequest {
+  optional string module = 1;
+  optional string version = 2;
+  optional string instance = 3;
+}
+
+message GetHostnameResponse {
+  required string hostname = 1;
+}
+
diff --git a/vendor/google.golang.org/appengine/internal/net.go b/vendor/google.golang.org/appengine/internal/net.go
new file mode 100644
index 0000000..3b94cf0
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/net.go
@@ -0,0 +1,56 @@
+// Copyright 2014 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package internal
+
+// This file implements a network dialer that limits the number of concurrent connections.
+// It is only used for API calls.
+
+import (
+        "log"
+        "net"
+        "runtime"
+        "sync"
+        "time"
+)
+
+var limitSem = make(chan int, 100) // TODO(dsymonds): Use environment variable.
+
+func limitRelease() {
+        // non-blocking
+        select {
+        case <-limitSem:
+        default:
+                // This should not normally happen.
+                log.Print("appengine: unbalanced limitSem release!")
+        }
+}
+
+func limitDial(network, addr string) (net.Conn, error) {
+        limitSem <- 1
+
+        // Dial with a timeout in case the API host is MIA.
+        // The connection should normally be very fast.
+        conn, err := net.DialTimeout(network, addr, 500*time.Millisecond)
+        if err != nil {
+                limitRelease()
+                return nil, err
+        }
+        lc := &limitConn{Conn: conn}
+        runtime.SetFinalizer(lc, (*limitConn).Close) // shouldn't usually be required
+        return lc, nil
+}
+
+type limitConn struct {
+        close sync.Once
+        net.Conn
+}
+
+func (lc *limitConn) Close() error {
+        defer lc.close.Do(func() {
+                limitRelease()
+                runtime.SetFinalizer(lc, nil)
+        })
+        return lc.Conn.Close()
+}
diff --git a/vendor/google.golang.org/appengine/internal/regen.sh b/vendor/google.golang.org/appengine/internal/regen.sh
new file mode 100644
index 0000000..2fdb546
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/regen.sh
@@ -0,0 +1,40 @@
+#!/bin/bash -e
+#
+# This script rebuilds the generated code for the protocol buffers.
+# To run this you will need protoc and goprotobuf installed;
+# see https://github.com/golang/protobuf for instructions.
+
+PKG=google.golang.org/appengine
+
+function die() {
+        echo 1>&2 $*
+        exit 1
+}
+
+# Sanity check that the right tools are accessible.
+for tool in go protoc protoc-gen-go; do
+        q=$(which $tool) || die "didn't find $tool"
+        echo 1>&2 "$tool: $q"
+done
+
+echo -n 1>&2 "finding package dir... "
+pkgdir=$(go list -f '{{.Dir}}' $PKG)
+echo 1>&2 $pkgdir
+base=$(echo $pkgdir | sed "s,/$PKG\$,,")
+echo 1>&2 "base: $base"
+cd $base
+
+# Run protoc once per package.
+for dir in $(find $PKG/internal -name '*.proto' | xargs dirname | sort | uniq); do
+        echo 1>&2 "* $dir"
+        protoc --go_out=. $dir/*.proto
+done
+
+for f in $(find $PKG/internal -name '*.pb.go'); do
+  # Remove proto.RegisterEnum calls.
+  # These cause duplicate registration panics when these packages
+  # are used on classic App Engine. proto.RegisterEnum only affects
+  # parsing the text format; we don't care about that.
+  # https://code.google.com/p/googleappengine/issues/detail?id=11670#c17
+  sed -i '/proto.RegisterEnum/d' $f
+done
diff --git a/vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go b/vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go
new file mode 100644
index 0000000..8d782a3
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go
@@ -0,0 +1,361 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google.golang.org/appengine/internal/remote_api/remote_api.proto
+
+package remote_api
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type RpcError_ErrorCode int32
+
+const (
+        RpcError_UNKNOWN             RpcError_ErrorCode = 0
+        RpcError_CALL_NOT_FOUND      RpcError_ErrorCode = 1
+        RpcError_PARSE_ERROR         RpcError_ErrorCode = 2
+        RpcError_SECURITY_VIOLATION  RpcError_ErrorCode = 3
+        RpcError_OVER_QUOTA          RpcError_ErrorCode = 4
+        RpcError_REQUEST_TOO_LARGE   RpcError_ErrorCode = 5
+        RpcError_CAPABILITY_DISABLED RpcError_ErrorCode = 6
+        RpcError_FEATURE_DISABLED    RpcError_ErrorCode = 7
+        RpcError_BAD_REQUEST         RpcError_ErrorCode = 8
+        RpcError_RESPONSE_TOO_LARGE  RpcError_ErrorCode = 9
+        RpcError_CANCELLED           RpcError_ErrorCode = 10
+        RpcError_REPLAY_ERROR        RpcError_ErrorCode = 11
+        RpcError_DEADLINE_EXCEEDED   RpcError_ErrorCode = 12
+)
+
+var RpcError_ErrorCode_name = map[int32]string{
+        0:  "UNKNOWN",
+        1:  "CALL_NOT_FOUND",
+        2:  "PARSE_ERROR",
+        3:  "SECURITY_VIOLATION",
+        4:  "OVER_QUOTA",
+        5:  "REQUEST_TOO_LARGE",
+        6:  "CAPABILITY_DISABLED",
+        7:  "FEATURE_DISABLED",
+        8:  "BAD_REQUEST",
+        9:  "RESPONSE_TOO_LARGE",
+        10: "CANCELLED",
+        11: "REPLAY_ERROR",
+        12: "DEADLINE_EXCEEDED",
+}
+var RpcError_ErrorCode_value = map[string]int32{
+        "UNKNOWN":             0,
+        "CALL_NOT_FOUND":      1,
+        "PARSE_ERROR":         2,
+        "SECURITY_VIOLATION":  3,
+        "OVER_QUOTA":          4,
+        "REQUEST_TOO_LARGE":   5,
+        "CAPABILITY_DISABLED": 6,
+        "FEATURE_DISABLED":    7,
+        "BAD_REQUEST":         8,
+        "RESPONSE_TOO_LARGE":  9,
+        "CANCELLED":           10,
+        "REPLAY_ERROR":        11,
+        "DEADLINE_EXCEEDED":   12,
+}
+
+func (x RpcError_ErrorCode) Enum() *RpcError_ErrorCode {
+        p := new(RpcError_ErrorCode)
+        *p = x
+        return p
+}
+func (x RpcError_ErrorCode) String() string {
+        return proto.EnumName(RpcError_ErrorCode_name, int32(x))
+}
+func (x *RpcError_ErrorCode) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(RpcError_ErrorCode_value, data, "RpcError_ErrorCode")
+        if err != nil {
+                return err
+        }
+        *x = RpcError_ErrorCode(value)
+        return nil
+}
+func (RpcError_ErrorCode) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_remote_api_1978114ec33a273d, []int{2, 0}
+}
+
+type Request struct {
+        ServiceName          *string  `protobuf:"bytes,2,req,name=service_name,json=serviceName" json:"service_name,omitempty"`
+        Method               *string  `protobuf:"bytes,3,req,name=method" json:"method,omitempty"`
+        Request              []byte   `protobuf:"bytes,4,req,name=request" json:"request,omitempty"`
+        RequestId            *string  `protobuf:"bytes,5,opt,name=request_id,json=requestId" json:"request_id,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Request) Reset()         { *m = Request{} }
+func (m *Request) String() string { return proto.CompactTextString(m) }
+func (*Request) ProtoMessage()    {}
+func (*Request) Descriptor() ([]byte, []int) {
+        return fileDescriptor_remote_api_1978114ec33a273d, []int{0}
+}
+func (m *Request) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Request.Unmarshal(m, b)
+}
+func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Request.Marshal(b, m, deterministic)
+}
+func (dst *Request) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Request.Merge(dst, src)
+}
+func (m *Request) XXX_Size() int {
+        return xxx_messageInfo_Request.Size(m)
+}
+func (m *Request) XXX_DiscardUnknown() {
+        xxx_messageInfo_Request.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Request proto.InternalMessageInfo
+
+func (m *Request) GetServiceName() string {
+        if m != nil && m.ServiceName != nil {
+                return *m.ServiceName
+        }
+        return ""
+}
+
+func (m *Request) GetMethod() string {
+        if m != nil && m.Method != nil {
+                return *m.Method
+        }
+        return ""
+}
+
+func (m *Request) GetRequest() []byte {
+        if m != nil {
+                return m.Request
+        }
+        return nil
+}
+
+func (m *Request) GetRequestId() string {
+        if m != nil && m.RequestId != nil {
+                return *m.RequestId
+        }
+        return ""
+}
+
+type ApplicationError struct {
+        Code                 *int32   `protobuf:"varint,1,req,name=code" json:"code,omitempty"`
+        Detail               *string  `protobuf:"bytes,2,req,name=detail" json:"detail,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ApplicationError) Reset()         { *m = ApplicationError{} }
+func (m *ApplicationError) String() string { return proto.CompactTextString(m) }
+func (*ApplicationError) ProtoMessage()    {}
+func (*ApplicationError) Descriptor() ([]byte, []int) {
+        return fileDescriptor_remote_api_1978114ec33a273d, []int{1}
+}
+func (m *ApplicationError) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_ApplicationError.Unmarshal(m, b)
+}
+func (m *ApplicationError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_ApplicationError.Marshal(b, m, deterministic)
+}
+func (dst *ApplicationError) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_ApplicationError.Merge(dst, src)
+}
+func (m *ApplicationError) XXX_Size() int {
+        return xxx_messageInfo_ApplicationError.Size(m)
+}
+func (m *ApplicationError) XXX_DiscardUnknown() {
+        xxx_messageInfo_ApplicationError.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ApplicationError proto.InternalMessageInfo
+
+func (m *ApplicationError) GetCode() int32 {
+        if m != nil && m.Code != nil {
+                return *m.Code
+        }
+        return 0
+}
+
+func (m *ApplicationError) GetDetail() string {
+        if m != nil && m.Detail != nil {
+                return *m.Detail
+        }
+        return ""
+}
+
+type RpcError struct {
+        Code                 *int32   `protobuf:"varint,1,req,name=code" json:"code,omitempty"`
+        Detail               *string  `protobuf:"bytes,2,opt,name=detail" json:"detail,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *RpcError) Reset()         { *m = RpcError{} }
+func (m *RpcError) String() string { return proto.CompactTextString(m) }
+func (*RpcError) ProtoMessage()    {}
+func (*RpcError) Descriptor() ([]byte, []int) {
+        return fileDescriptor_remote_api_1978114ec33a273d, []int{2}
+}
+func (m *RpcError) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_RpcError.Unmarshal(m, b)
+}
+func (m *RpcError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_RpcError.Marshal(b, m, deterministic)
+}
+func (dst *RpcError) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_RpcError.Merge(dst, src)
+}
+func (m *RpcError) XXX_Size() int {
+        return xxx_messageInfo_RpcError.Size(m)
+}
+func (m *RpcError) XXX_DiscardUnknown() {
+        xxx_messageInfo_RpcError.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RpcError proto.InternalMessageInfo
+
+func (m *RpcError) GetCode() int32 {
+        if m != nil && m.Code != nil {
+                return *m.Code
+        }
+        return 0
+}
+
+func (m *RpcError) GetDetail() string {
+        if m != nil && m.Detail != nil {
+                return *m.Detail
+        }
+        return ""
+}
+
+type Response struct {
+        Response             []byte            `protobuf:"bytes,1,opt,name=response" json:"response,omitempty"`
+        Exception            []byte            `protobuf:"bytes,2,opt,name=exception" json:"exception,omitempty"`
+        ApplicationError     *ApplicationError `protobuf:"bytes,3,opt,name=application_error,json=applicationError" json:"application_error,omitempty"`
+        JavaException        []byte            `protobuf:"bytes,4,opt,name=java_exception,json=javaException" json:"java_exception,omitempty"`
+        RpcError             *RpcError         `protobuf:"bytes,5,opt,name=rpc_error,json=rpcError" json:"rpc_error,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+        XXX_unrecognized     []byte            `json:"-"`
+        XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *Response) Reset()         { *m = Response{} }
+func (m *Response) String() string { return proto.CompactTextString(m) }
+func (*Response) ProtoMessage()    {}
+func (*Response) Descriptor() ([]byte, []int) {
+        return fileDescriptor_remote_api_1978114ec33a273d, []int{3}
+}
+func (m *Response) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Response.Unmarshal(m, b)
+}
+func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Response.Marshal(b, m, deterministic)
+}
+func (dst *Response) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Response.Merge(dst, src)
+}
+func (m *Response) XXX_Size() int {
+        return xxx_messageInfo_Response.Size(m)
+}
+func (m *Response) XXX_DiscardUnknown() {
+        xxx_messageInfo_Response.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Response proto.InternalMessageInfo
+
+func (m *Response) GetResponse() []byte {
+        if m != nil {
+                return m.Response
+        }
+        return nil
+}
+
+func (m *Response) GetException() []byte {
+        if m != nil {
+                return m.Exception
+        }
+        return nil
+}
+
+func (m *Response) GetApplicationError() *ApplicationError {
+        if m != nil {
+                return m.ApplicationError
+        }
+        return nil
+}
+
+func (m *Response) GetJavaException() []byte {
+        if m != nil {
+                return m.JavaException
+        }
+        return nil
+}
+
+func (m *Response) GetRpcError() *RpcError {
+        if m != nil {
+                return m.RpcError
+        }
+        return nil
+}
+
+func init() {
+        proto.RegisterType((*Request)(nil), "remote_api.Request")
+        proto.RegisterType((*ApplicationError)(nil), "remote_api.ApplicationError")
+        proto.RegisterType((*RpcError)(nil), "remote_api.RpcError")
+        proto.RegisterType((*Response)(nil), "remote_api.Response")
+}
+
+func init() {
+        proto.RegisterFile("google.golang.org/appengine/internal/remote_api/remote_api.proto", fileDescriptor_remote_api_1978114ec33a273d)
+}
+
+var fileDescriptor_remote_api_1978114ec33a273d = []byte{
+        // 531 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0x51, 0x6e, 0xd3, 0x40,
+        0x10, 0x86, 0xb1, 0x9b, 0x34, 0xf1, 0xc4, 0x2d, 0xdb, 0xa5, 0x14, 0x0b, 0x15, 0x29, 0x44, 0x42,
+        0xca, 0x53, 0x2a, 0x38, 0x00, 0x62, 0x63, 0x6f, 0x91, 0x85, 0x65, 0xa7, 0x6b, 0xbb, 0x50, 0x5e,
+        0x56, 0x2b, 0x67, 0x65, 0x8c, 0x12, 0xaf, 0xd9, 0x98, 0x8a, 0x17, 0x6e, 0xc0, 0xb5, 0x38, 0x0c,
+        0xb7, 0x40, 0x36, 0x6e, 0x63, 0xf5, 0x89, 0xb7, 0x7f, 0x7e, 0x7b, 0xe6, 0x1b, 0xcd, 0xcc, 0xc2,
+        0xbb, 0x5c, 0xa9, 0x7c, 0x23, 0x17, 0xb9, 0xda, 0x88, 0x32, 0x5f, 0x28, 0x9d, 0x5f, 0x88, 0xaa,
+        0x92, 0x65, 0x5e, 0x94, 0xf2, 0xa2, 0x28, 0x6b, 0xa9, 0x4b, 0xb1, 0xb9, 0xd0, 0x72, 0xab, 0x6a,
+        0xc9, 0x45, 0x55, 0xf4, 0xe4, 0xa2, 0xd2, 0xaa, 0x56, 0x18, 0xf6, 0xce, 0xec, 0x27, 0x8c, 0x98,
+        0xfc, 0xf6, 0x5d, 0xee, 0x6a, 0xfc, 0x12, 0xec, 0x9d, 0xd4, 0xb7, 0x45, 0x26, 0x79, 0x29, 0xb6,
+        0xd2, 0x31, 0xa7, 0xe6, 0xdc, 0x62, 0x93, 0xce, 0x0b, 0xc5, 0x56, 0xe2, 0x33, 0x38, 0xdc, 0xca,
+        0xfa, 0x8b, 0x5a, 0x3b, 0x07, 0xed, 0xc7, 0x2e, 0xc2, 0x0e, 0x8c, 0xf4, 0xbf, 0x2a, 0xce, 0x60,
+        0x6a, 0xce, 0x6d, 0x76, 0x17, 0xe2, 0x17, 0x00, 0x9d, 0xe4, 0xc5, 0xda, 0x19, 0x4e, 0x8d, 0xb9,
+        0xc5, 0xac, 0xce, 0xf1, 0xd7, 0xb3, 0xb7, 0x80, 0x48, 0x55, 0x6d, 0x8a, 0x4c, 0xd4, 0x85, 0x2a,
+        0xa9, 0xd6, 0x4a, 0x63, 0x0c, 0x83, 0x4c, 0xad, 0xa5, 0x63, 0x4c, 0xcd, 0xf9, 0x90, 0xb5, 0xba,
+        0x01, 0xaf, 0x65, 0x2d, 0x8a, 0x4d, 0xd7, 0x55, 0x17, 0xcd, 0x7e, 0x9b, 0x30, 0x66, 0x55, 0xf6,
+        0x7f, 0x89, 0x46, 0x2f, 0xf1, 0x97, 0x09, 0x56, 0x9b, 0xe5, 0x36, 0x7f, 0x4d, 0x60, 0x94, 0x86,
+        0x1f, 0xc2, 0xe8, 0x63, 0x88, 0x1e, 0x61, 0x0c, 0xc7, 0x2e, 0x09, 0x02, 0x1e, 0x46, 0x09, 0xbf,
+        0x8c, 0xd2, 0xd0, 0x43, 0x06, 0x7e, 0x0c, 0x93, 0x15, 0x61, 0x31, 0xe5, 0x94, 0xb1, 0x88, 0x21,
+        0x13, 0x9f, 0x01, 0x8e, 0xa9, 0x9b, 0x32, 0x3f, 0xb9, 0xe1, 0xd7, 0x7e, 0x14, 0x90, 0xc4, 0x8f,
+        0x42, 0x74, 0x80, 0x8f, 0x01, 0xa2, 0x6b, 0xca, 0xf8, 0x55, 0x1a, 0x25, 0x04, 0x0d, 0xf0, 0x53,
+        0x38, 0x61, 0xf4, 0x2a, 0xa5, 0x71, 0xc2, 0x93, 0x28, 0xe2, 0x01, 0x61, 0xef, 0x29, 0x1a, 0xe2,
+        0x67, 0xf0, 0xc4, 0x25, 0x2b, 0xb2, 0xf4, 0x83, 0xa6, 0x80, 0xe7, 0xc7, 0x64, 0x19, 0x50, 0x0f,
+        0x1d, 0xe2, 0x53, 0x40, 0x97, 0x94, 0x24, 0x29, 0xa3, 0x7b, 0x77, 0xd4, 0xe0, 0x97, 0xc4, 0xe3,
+        0x5d, 0x25, 0x34, 0x6e, 0xf0, 0x8c, 0xc6, 0xab, 0x28, 0x8c, 0x69, 0xaf, 0xae, 0x85, 0x8f, 0xc0,
+        0x72, 0x49, 0xe8, 0xd2, 0xa0, 0xc9, 0x03, 0x8c, 0xc0, 0x66, 0x74, 0x15, 0x90, 0x9b, 0xae, 0xef,
+        0x49, 0xd3, 0x8f, 0x47, 0x89, 0x17, 0xf8, 0x21, 0xe5, 0xf4, 0x93, 0x4b, 0xa9, 0x47, 0x3d, 0x64,
+        0xcf, 0xfe, 0x18, 0x30, 0x66, 0x72, 0x57, 0xa9, 0x72, 0x27, 0xf1, 0x73, 0x18, 0xeb, 0x4e, 0x3b,
+        0xc6, 0xd4, 0x98, 0xdb, 0xec, 0x3e, 0xc6, 0xe7, 0x60, 0xc9, 0x1f, 0x99, 0xac, 0x9a, 0x75, 0xb5,
+        0x23, 0xb5, 0xd9, 0xde, 0xc0, 0x3e, 0x9c, 0x88, 0xfd, 0x3a, 0xb9, 0x6c, 0x06, 0xec, 0x1c, 0x4c,
+        0x8d, 0xf9, 0xe4, 0xcd, 0xf9, 0xa2, 0x77, 0x87, 0x0f, 0x77, 0xce, 0x90, 0x78, 0x78, 0x05, 0xaf,
+        0xe0, 0xf8, 0xab, 0xb8, 0x15, 0x7c, 0x4f, 0x1b, 0xb4, 0xb4, 0xa3, 0xc6, 0xa5, 0xf7, 0xc4, 0xd7,
+        0x60, 0xe9, 0x2a, 0xeb, 0x48, 0xc3, 0x96, 0x74, 0xda, 0x27, 0xdd, 0x1d, 0x07, 0x1b, 0xeb, 0x4e,
+        0x2d, 0xed, 0xcf, 0xbd, 0x07, 0xf0, 0x37, 0x00, 0x00, 0xff, 0xff, 0x38, 0xd1, 0x0f, 0x22, 0x4f,
+        0x03, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/appengine/internal/remote_api/remote_api.proto b/vendor/google.golang.org/appengine/internal/remote_api/remote_api.proto
new file mode 100644
index 0000000..f21763a
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/remote_api/remote_api.proto
@@ -0,0 +1,44 @@
+syntax = "proto2";
+option go_package = "remote_api";
+
+package remote_api;
+
+message Request {
+  required string service_name = 2;
+  required string method = 3;
+  required bytes request = 4;
+  optional string request_id = 5;
+}
+
+message ApplicationError {
+  required int32 code = 1;
+  required string detail = 2;
+}
+
+message RpcError {
+  enum ErrorCode {
+    UNKNOWN = 0;
+    CALL_NOT_FOUND = 1;
+    PARSE_ERROR = 2;
+    SECURITY_VIOLATION = 3;
+    OVER_QUOTA = 4;
+    REQUEST_TOO_LARGE = 5;
+    CAPABILITY_DISABLED = 6;
+    FEATURE_DISABLED = 7;
+    BAD_REQUEST = 8;
+    RESPONSE_TOO_LARGE = 9;
+    CANCELLED = 10;
+    REPLAY_ERROR = 11;
+    DEADLINE_EXCEEDED = 12;
+  }
+  required int32 code = 1;
+  optional string detail = 2;
+}
+
+message Response {
+  optional bytes response = 1;
+  optional bytes exception = 2;
+  optional ApplicationError application_error = 3;
+  optional bytes java_exception = 4;
+  optional RpcError rpc_error = 5;
+}
diff --git a/vendor/google.golang.org/appengine/internal/transaction.go b/vendor/google.golang.org/appengine/internal/transaction.go
new file mode 100644
index 0000000..9006ae6
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/transaction.go
@@ -0,0 +1,115 @@
+// Copyright 2014 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package internal
+
+// This file implements hooks for applying datastore transactions.
+
+import (
+        "errors"
+        "reflect"
+
+        "github.com/golang/protobuf/proto"
+        netcontext "golang.org/x/net/context"
+
+        basepb "google.golang.org/appengine/internal/base"
+        pb "google.golang.org/appengine/internal/datastore"
+)
+
+var transactionSetters = make(map[reflect.Type]reflect.Value)
+
+// RegisterTransactionSetter registers a function that sets transaction information
+// in a protocol buffer message. f should be a function with two arguments,
+// the first being a protocol buffer type, and the second being *datastore.Transaction.
+func RegisterTransactionSetter(f interface{}) {
+        v := reflect.ValueOf(f)
+        transactionSetters[v.Type().In(0)] = v
+}
+
+// applyTransaction applies the transaction t to message pb
+// by using the relevant setter passed to RegisterTransactionSetter.
+func applyTransaction(pb proto.Message, t *pb.Transaction) {
+        v := reflect.ValueOf(pb)
+        if f, ok := transactionSetters[v.Type()]; ok {
+                f.Call([]reflect.Value{v, reflect.ValueOf(t)})
+        }
+}
+
+var transactionKey = "used for *Transaction"
+
+func transactionFromContext(ctx netcontext.Context) *transaction {
+        t, _ := ctx.Value(&transactionKey).(*transaction)
+        return t
+}
+
+func withTransaction(ctx netcontext.Context, t *transaction) netcontext.Context {
+        return netcontext.WithValue(ctx, &transactionKey, t)
+}
+
+type transaction struct {
+        transaction pb.Transaction
+        finished    bool
+}
+
+var ErrConcurrentTransaction = errors.New("internal: concurrent transaction")
+
+func RunTransactionOnce(c netcontext.Context, f func(netcontext.Context) error, xg bool, readOnly bool, previousTransaction *pb.Transaction) (*pb.Transaction, error) {
+        if transactionFromContext(c) != nil {
+                return nil, errors.New("nested transactions are not supported")
+        }
+
+        // Begin the transaction.
+        t := &transaction{}
+        req := &pb.BeginTransactionRequest{
+                App: proto.String(FullyQualifiedAppID(c)),
+        }
+        if xg {
+                req.AllowMultipleEg = proto.Bool(true)
+        }
+        if previousTransaction != nil {
+                req.PreviousTransaction = previousTransaction
+        }
+        if readOnly {
+                req.Mode = pb.BeginTransactionRequest_READ_ONLY.Enum()
+        } else {
+                req.Mode = pb.BeginTransactionRequest_READ_WRITE.Enum()
+        }
+        if err := Call(c, "datastore_v3", "BeginTransaction", req, &t.transaction); err != nil {
+                return nil, err
+        }
+
+        // Call f, rolling back the transaction if f returns a non-nil error, or panics.
+        // The panic is not recovered.
+        defer func() {
+                if t.finished {
+                        return
+                }
+                t.finished = true
+                // Ignore the error return value, since we are already returning a non-nil
+                // error (or we're panicking).
+                Call(c, "datastore_v3", "Rollback", &t.transaction, &basepb.VoidProto{})
+        }()
+        if err := f(withTransaction(c, t)); err != nil {
+                return &t.transaction, err
+        }
+        t.finished = true
+
+        // Commit the transaction.
+        res := &pb.CommitResponse{}
+        err := Call(c, "datastore_v3", "Commit", &t.transaction, res)
+        if ae, ok := err.(*APIError); ok {
+                /* TODO: restore this conditional
+                if appengine.IsDevAppServer() {
+                */
+                // The Python Dev AppServer raises an ApplicationError with error code 2 (which is
+                // Error.CONCURRENT_TRANSACTION) and message "Concurrency exception.".
+                if ae.Code == int32(pb.Error_BAD_REQUEST) && ae.Detail == "ApplicationError: 2 Concurrency exception." {
+                        return &t.transaction, ErrConcurrentTransaction
+                }
+                if ae.Code == int32(pb.Error_CONCURRENT_TRANSACTION) {
+                        return &t.transaction, ErrConcurrentTransaction
+                }
+        }
+        return &t.transaction, err
+}
diff --git a/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.pb.go b/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.pb.go
new file mode 100644
index 0000000..5f72775
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.pb.go
@@ -0,0 +1,527 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto
+
+package urlfetch
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type URLFetchServiceError_ErrorCode int32
+
+const (
+        URLFetchServiceError_OK                       URLFetchServiceError_ErrorCode = 0
+        URLFetchServiceError_INVALID_URL              URLFetchServiceError_ErrorCode = 1
+        URLFetchServiceError_FETCH_ERROR              URLFetchServiceError_ErrorCode = 2
+        URLFetchServiceError_UNSPECIFIED_ERROR        URLFetchServiceError_ErrorCode = 3
+        URLFetchServiceError_RESPONSE_TOO_LARGE       URLFetchServiceError_ErrorCode = 4
+        URLFetchServiceError_DEADLINE_EXCEEDED        URLFetchServiceError_ErrorCode = 5
+        URLFetchServiceError_SSL_CERTIFICATE_ERROR    URLFetchServiceError_ErrorCode = 6
+        URLFetchServiceError_DNS_ERROR                URLFetchServiceError_ErrorCode = 7
+        URLFetchServiceError_CLOSED                   URLFetchServiceError_ErrorCode = 8
+        URLFetchServiceError_INTERNAL_TRANSIENT_ERROR URLFetchServiceError_ErrorCode = 9
+        URLFetchServiceError_TOO_MANY_REDIRECTS       URLFetchServiceError_ErrorCode = 10
+        URLFetchServiceError_MALFORMED_REPLY          URLFetchServiceError_ErrorCode = 11
+        URLFetchServiceError_CONNECTION_ERROR         URLFetchServiceError_ErrorCode = 12
+)
+
+var URLFetchServiceError_ErrorCode_name = map[int32]string{
+        0:  "OK",
+        1:  "INVALID_URL",
+        2:  "FETCH_ERROR",
+        3:  "UNSPECIFIED_ERROR",
+        4:  "RESPONSE_TOO_LARGE",
+        5:  "DEADLINE_EXCEEDED",
+        6:  "SSL_CERTIFICATE_ERROR",
+        7:  "DNS_ERROR",
+        8:  "CLOSED",
+        9:  "INTERNAL_TRANSIENT_ERROR",
+        10: "TOO_MANY_REDIRECTS",
+        11: "MALFORMED_REPLY",
+        12: "CONNECTION_ERROR",
+}
+var URLFetchServiceError_ErrorCode_value = map[string]int32{
+        "OK":                       0,
+        "INVALID_URL":              1,
+        "FETCH_ERROR":              2,
+        "UNSPECIFIED_ERROR":        3,
+        "RESPONSE_TOO_LARGE":       4,
+        "DEADLINE_EXCEEDED":        5,
+        "SSL_CERTIFICATE_ERROR":    6,
+        "DNS_ERROR":                7,
+        "CLOSED":                   8,
+        "INTERNAL_TRANSIENT_ERROR": 9,
+        "TOO_MANY_REDIRECTS":       10,
+        "MALFORMED_REPLY":          11,
+        "CONNECTION_ERROR":         12,
+}
+
+func (x URLFetchServiceError_ErrorCode) Enum() *URLFetchServiceError_ErrorCode {
+        p := new(URLFetchServiceError_ErrorCode)
+        *p = x
+        return p
+}
+func (x URLFetchServiceError_ErrorCode) String() string {
+        return proto.EnumName(URLFetchServiceError_ErrorCode_name, int32(x))
+}
+func (x *URLFetchServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(URLFetchServiceError_ErrorCode_value, data, "URLFetchServiceError_ErrorCode")
+        if err != nil {
+                return err
+        }
+        *x = URLFetchServiceError_ErrorCode(value)
+        return nil
+}
+func (URLFetchServiceError_ErrorCode) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{0, 0}
+}
+
+type URLFetchRequest_RequestMethod int32
+
+const (
+        URLFetchRequest_GET    URLFetchRequest_RequestMethod = 1
+        URLFetchRequest_POST   URLFetchRequest_RequestMethod = 2
+        URLFetchRequest_HEAD   URLFetchRequest_RequestMethod = 3
+        URLFetchRequest_PUT    URLFetchRequest_RequestMethod = 4
+        URLFetchRequest_DELETE URLFetchRequest_RequestMethod = 5
+        URLFetchRequest_PATCH  URLFetchRequest_RequestMethod = 6
+)
+
+var URLFetchRequest_RequestMethod_name = map[int32]string{
+        1: "GET",
+        2: "POST",
+        3: "HEAD",
+        4: "PUT",
+        5: "DELETE",
+        6: "PATCH",
+}
+var URLFetchRequest_RequestMethod_value = map[string]int32{
+        "GET":    1,
+        "POST":   2,
+        "HEAD":   3,
+        "PUT":    4,
+        "DELETE": 5,
+        "PATCH":  6,
+}
+
+func (x URLFetchRequest_RequestMethod) Enum() *URLFetchRequest_RequestMethod {
+        p := new(URLFetchRequest_RequestMethod)
+        *p = x
+        return p
+}
+func (x URLFetchRequest_RequestMethod) String() string {
+        return proto.EnumName(URLFetchRequest_RequestMethod_name, int32(x))
+}
+func (x *URLFetchRequest_RequestMethod) UnmarshalJSON(data []byte) error {
+        value, err := proto.UnmarshalJSONEnum(URLFetchRequest_RequestMethod_value, data, "URLFetchRequest_RequestMethod")
+        if err != nil {
+                return err
+        }
+        *x = URLFetchRequest_RequestMethod(value)
+        return nil
+}
+func (URLFetchRequest_RequestMethod) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{1, 0}
+}
+
+type URLFetchServiceError struct {
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *URLFetchServiceError) Reset()         { *m = URLFetchServiceError{} }
+func (m *URLFetchServiceError) String() string { return proto.CompactTextString(m) }
+func (*URLFetchServiceError) ProtoMessage()    {}
+func (*URLFetchServiceError) Descriptor() ([]byte, []int) {
+        return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{0}
+}
+func (m *URLFetchServiceError) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_URLFetchServiceError.Unmarshal(m, b)
+}
+func (m *URLFetchServiceError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_URLFetchServiceError.Marshal(b, m, deterministic)
+}
+func (dst *URLFetchServiceError) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_URLFetchServiceError.Merge(dst, src)
+}
+func (m *URLFetchServiceError) XXX_Size() int {
+        return xxx_messageInfo_URLFetchServiceError.Size(m)
+}
+func (m *URLFetchServiceError) XXX_DiscardUnknown() {
+        xxx_messageInfo_URLFetchServiceError.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_URLFetchServiceError proto.InternalMessageInfo
+
+type URLFetchRequest struct {
+        Method                        *URLFetchRequest_RequestMethod `protobuf:"varint,1,req,name=Method,enum=appengine.URLFetchRequest_RequestMethod" json:"Method,omitempty"`
+        Url                           *string                        `protobuf:"bytes,2,req,name=Url" json:"Url,omitempty"`
+        Header                        []*URLFetchRequest_Header      `protobuf:"group,3,rep,name=Header,json=header" json:"header,omitempty"`
+        Payload                       []byte                         `protobuf:"bytes,6,opt,name=Payload" json:"Payload,omitempty"`
+        FollowRedirects               *bool                          `protobuf:"varint,7,opt,name=FollowRedirects,def=1" json:"FollowRedirects,omitempty"`
+        Deadline                      *float64                       `protobuf:"fixed64,8,opt,name=Deadline" json:"Deadline,omitempty"`
+        MustValidateServerCertificate *bool                          `protobuf:"varint,9,opt,name=MustValidateServerCertificate,def=1" json:"MustValidateServerCertificate,omitempty"`
+        XXX_NoUnkeyedLiteral          struct{}                       `json:"-"`
+        XXX_unrecognized              []byte                         `json:"-"`
+        XXX_sizecache                 int32                          `json:"-"`
+}
+
+func (m *URLFetchRequest) Reset()         { *m = URLFetchRequest{} }
+func (m *URLFetchRequest) String() string { return proto.CompactTextString(m) }
+func (*URLFetchRequest) ProtoMessage()    {}
+func (*URLFetchRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{1}
+}
+func (m *URLFetchRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_URLFetchRequest.Unmarshal(m, b)
+}
+func (m *URLFetchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_URLFetchRequest.Marshal(b, m, deterministic)
+}
+func (dst *URLFetchRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_URLFetchRequest.Merge(dst, src)
+}
+func (m *URLFetchRequest) XXX_Size() int {
+        return xxx_messageInfo_URLFetchRequest.Size(m)
+}
+func (m *URLFetchRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_URLFetchRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_URLFetchRequest proto.InternalMessageInfo
+
+const Default_URLFetchRequest_FollowRedirects bool = true
+const Default_URLFetchRequest_MustValidateServerCertificate bool = true
+
+func (m *URLFetchRequest) GetMethod() URLFetchRequest_RequestMethod {
+        if m != nil && m.Method != nil {
+                return *m.Method
+        }
+        return URLFetchRequest_GET
+}
+
+func (m *URLFetchRequest) GetUrl() string {
+        if m != nil && m.Url != nil {
+                return *m.Url
+        }
+        return ""
+}
+
+func (m *URLFetchRequest) GetHeader() []*URLFetchRequest_Header {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *URLFetchRequest) GetPayload() []byte {
+        if m != nil {
+                return m.Payload
+        }
+        return nil
+}
+
+func (m *URLFetchRequest) GetFollowRedirects() bool {
+        if m != nil && m.FollowRedirects != nil {
+                return *m.FollowRedirects
+        }
+        return Default_URLFetchRequest_FollowRedirects
+}
+
+func (m *URLFetchRequest) GetDeadline() float64 {
+        if m != nil && m.Deadline != nil {
+                return *m.Deadline
+        }
+        return 0
+}
+
+func (m *URLFetchRequest) GetMustValidateServerCertificate() bool {
+        if m != nil && m.MustValidateServerCertificate != nil {
+                return *m.MustValidateServerCertificate
+        }
+        return Default_URLFetchRequest_MustValidateServerCertificate
+}
+
+type URLFetchRequest_Header struct {
+        Key                  *string  `protobuf:"bytes,4,req,name=Key" json:"Key,omitempty"`
+        Value                *string  `protobuf:"bytes,5,req,name=Value" json:"Value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *URLFetchRequest_Header) Reset()         { *m = URLFetchRequest_Header{} }
+func (m *URLFetchRequest_Header) String() string { return proto.CompactTextString(m) }
+func (*URLFetchRequest_Header) ProtoMessage()    {}
+func (*URLFetchRequest_Header) Descriptor() ([]byte, []int) {
+        return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{1, 0}
+}
+func (m *URLFetchRequest_Header) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_URLFetchRequest_Header.Unmarshal(m, b)
+}
+func (m *URLFetchRequest_Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_URLFetchRequest_Header.Marshal(b, m, deterministic)
+}
+func (dst *URLFetchRequest_Header) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_URLFetchRequest_Header.Merge(dst, src)
+}
+func (m *URLFetchRequest_Header) XXX_Size() int {
+        return xxx_messageInfo_URLFetchRequest_Header.Size(m)
+}
+func (m *URLFetchRequest_Header) XXX_DiscardUnknown() {
+        xxx_messageInfo_URLFetchRequest_Header.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_URLFetchRequest_Header proto.InternalMessageInfo
+
+func (m *URLFetchRequest_Header) GetKey() string {
+        if m != nil && m.Key != nil {
+                return *m.Key
+        }
+        return ""
+}
+
+func (m *URLFetchRequest_Header) GetValue() string {
+        if m != nil && m.Value != nil {
+                return *m.Value
+        }
+        return ""
+}
+
+type URLFetchResponse struct {
+        Content               []byte                     `protobuf:"bytes,1,opt,name=Content" json:"Content,omitempty"`
+        StatusCode            *int32                     `protobuf:"varint,2,req,name=StatusCode" json:"StatusCode,omitempty"`
+        Header                []*URLFetchResponse_Header `protobuf:"group,3,rep,name=Header,json=header" json:"header,omitempty"`
+        ContentWasTruncated   *bool                      `protobuf:"varint,6,opt,name=ContentWasTruncated,def=0" json:"ContentWasTruncated,omitempty"`
+        ExternalBytesSent     *int64                     `protobuf:"varint,7,opt,name=ExternalBytesSent" json:"ExternalBytesSent,omitempty"`
+        ExternalBytesReceived *int64                     `protobuf:"varint,8,opt,name=ExternalBytesReceived" json:"ExternalBytesReceived,omitempty"`
+        FinalUrl              *string                    `protobuf:"bytes,9,opt,name=FinalUrl" json:"FinalUrl,omitempty"`
+        ApiCpuMilliseconds    *int64                     `protobuf:"varint,10,opt,name=ApiCpuMilliseconds,def=0" json:"ApiCpuMilliseconds,omitempty"`
+        ApiBytesSent          *int64                     `protobuf:"varint,11,opt,name=ApiBytesSent,def=0" json:"ApiBytesSent,omitempty"`
+        ApiBytesReceived      *int64                     `protobuf:"varint,12,opt,name=ApiBytesReceived,def=0" json:"ApiBytesReceived,omitempty"`
+        XXX_NoUnkeyedLiteral  struct{}                   `json:"-"`
+        XXX_unrecognized      []byte                     `json:"-"`
+        XXX_sizecache         int32                      `json:"-"`
+}
+
+func (m *URLFetchResponse) Reset()         { *m = URLFetchResponse{} }
+func (m *URLFetchResponse) String() string { return proto.CompactTextString(m) }
+func (*URLFetchResponse) ProtoMessage()    {}
+func (*URLFetchResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{2}
+}
+func (m *URLFetchResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_URLFetchResponse.Unmarshal(m, b)
+}
+func (m *URLFetchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_URLFetchResponse.Marshal(b, m, deterministic)
+}
+func (dst *URLFetchResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_URLFetchResponse.Merge(dst, src)
+}
+func (m *URLFetchResponse) XXX_Size() int {
+        return xxx_messageInfo_URLFetchResponse.Size(m)
+}
+func (m *URLFetchResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_URLFetchResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_URLFetchResponse proto.InternalMessageInfo
+
+const Default_URLFetchResponse_ContentWasTruncated bool = false
+const Default_URLFetchResponse_ApiCpuMilliseconds int64 = 0
+const Default_URLFetchResponse_ApiBytesSent int64 = 0
+const Default_URLFetchResponse_ApiBytesReceived int64 = 0
+
+func (m *URLFetchResponse) GetContent() []byte {
+        if m != nil {
+                return m.Content
+        }
+        return nil
+}
+
+func (m *URLFetchResponse) GetStatusCode() int32 {
+        if m != nil && m.StatusCode != nil {
+                return *m.StatusCode
+        }
+        return 0
+}
+
+func (m *URLFetchResponse) GetHeader() []*URLFetchResponse_Header {
+        if m != nil {
+                return m.Header
+        }
+        return nil
+}
+
+func (m *URLFetchResponse) GetContentWasTruncated() bool {
+        if m != nil && m.ContentWasTruncated != nil {
+                return *m.ContentWasTruncated
+        }
+        return Default_URLFetchResponse_ContentWasTruncated
+}
+
+func (m *URLFetchResponse) GetExternalBytesSent() int64 {
+        if m != nil && m.ExternalBytesSent != nil {
+                return *m.ExternalBytesSent
+        }
+        return 0
+}
+
+func (m *URLFetchResponse) GetExternalBytesReceived() int64 {
+        if m != nil && m.ExternalBytesReceived != nil {
+                return *m.ExternalBytesReceived
+        }
+        return 0
+}
+
+func (m *URLFetchResponse) GetFinalUrl() string {
+        if m != nil && m.FinalUrl != nil {
+                return *m.FinalUrl
+        }
+        return ""
+}
+
+func (m *URLFetchResponse) GetApiCpuMilliseconds() int64 {
+        if m != nil && m.ApiCpuMilliseconds != nil {
+                return *m.ApiCpuMilliseconds
+        }
+        return Default_URLFetchResponse_ApiCpuMilliseconds
+}
+
+func (m *URLFetchResponse) GetApiBytesSent() int64 {
+        if m != nil && m.ApiBytesSent != nil {
+                return *m.ApiBytesSent
+        }
+        return Default_URLFetchResponse_ApiBytesSent
+}
+
+func (m *URLFetchResponse) GetApiBytesReceived() int64 {
+        if m != nil && m.ApiBytesReceived != nil {
+                return *m.ApiBytesReceived
+        }
+        return Default_URLFetchResponse_ApiBytesReceived
+}
+
+type URLFetchResponse_Header struct {
+        Key                  *string  `protobuf:"bytes,4,req,name=Key" json:"Key,omitempty"`
+        Value                *string  `protobuf:"bytes,5,req,name=Value" json:"Value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *URLFetchResponse_Header) Reset()         { *m = URLFetchResponse_Header{} }
+func (m *URLFetchResponse_Header) String() string { return proto.CompactTextString(m) }
+func (*URLFetchResponse_Header) ProtoMessage()    {}
+func (*URLFetchResponse_Header) Descriptor() ([]byte, []int) {
+        return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{2, 0}
+}
+func (m *URLFetchResponse_Header) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_URLFetchResponse_Header.Unmarshal(m, b)
+}
+func (m *URLFetchResponse_Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_URLFetchResponse_Header.Marshal(b, m, deterministic)
+}
+func (dst *URLFetchResponse_Header) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_URLFetchResponse_Header.Merge(dst, src)
+}
+func (m *URLFetchResponse_Header) XXX_Size() int {
+        return xxx_messageInfo_URLFetchResponse_Header.Size(m)
+}
+func (m *URLFetchResponse_Header) XXX_DiscardUnknown() {
+        xxx_messageInfo_URLFetchResponse_Header.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_URLFetchResponse_Header proto.InternalMessageInfo
+
+func (m *URLFetchResponse_Header) GetKey() string {
+        if m != nil && m.Key != nil {
+                return *m.Key
+        }
+        return ""
+}
+
+func (m *URLFetchResponse_Header) GetValue() string {
+        if m != nil && m.Value != nil {
+                return *m.Value
+        }
+        return ""
+}
+
+func init() {
+        proto.RegisterType((*URLFetchServiceError)(nil), "appengine.URLFetchServiceError")
+        proto.RegisterType((*URLFetchRequest)(nil), "appengine.URLFetchRequest")
+        proto.RegisterType((*URLFetchRequest_Header)(nil), "appengine.URLFetchRequest.Header")
+        proto.RegisterType((*URLFetchResponse)(nil), "appengine.URLFetchResponse")
+        proto.RegisterType((*URLFetchResponse_Header)(nil), "appengine.URLFetchResponse.Header")
+}
+
+func init() {
+        proto.RegisterFile("google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto", fileDescriptor_urlfetch_service_b245a7065f33bced)
+}
+
+var fileDescriptor_urlfetch_service_b245a7065f33bced = []byte{
+        // 770 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xdd, 0x6e, 0xe3, 0x54,
+        0x10, 0xc6, 0x76, 0x7e, 0xa7, 0x5d, 0x7a, 0x76, 0xb6, 0x45, 0x66, 0xb5, 0xa0, 0x10, 0x09, 0x29,
+        0x17, 0x90, 0x2e, 0x2b, 0x24, 0x44, 0xaf, 0x70, 0xed, 0x93, 0xad, 0xa9, 0x63, 0x47, 0xc7, 0x4e,
+        0x61, 0xb9, 0xb1, 0xac, 0x78, 0x9a, 0x5a, 0xb2, 0xec, 0x60, 0x9f, 0x2c, 0xf4, 0x35, 0x78, 0x0d,
+        0xde, 0x87, 0xa7, 0xe1, 0x02, 0x9d, 0xc4, 0xc9, 0x6e, 0xbb, 0xd1, 0x4a, 0x5c, 0x65, 0xe6, 0x9b,
+        0xef, 0xcc, 0x99, 0x7c, 0xdf, 0xf8, 0x80, 0xb3, 0x2c, 0xcb, 0x65, 0x4e, 0xe3, 0x65, 0x99, 0x27,
+        0xc5, 0x72, 0x5c, 0x56, 0xcb, 0xf3, 0x64, 0xb5, 0xa2, 0x62, 0x99, 0x15, 0x74, 0x9e, 0x15, 0x92,
+        0xaa, 0x22, 0xc9, 0xcf, 0xd7, 0x55, 0x7e, 0x4b, 0x72, 0x71, 0xb7, 0x0f, 0xe2, 0x9a, 0xaa, 0xb7,
+        0xd9, 0x82, 0xc6, 0xab, 0xaa, 0x94, 0x25, 0xf6, 0xf7, 0x67, 0x86, 0x7f, 0xeb, 0x70, 0x3a, 0x17,
+        0xde, 0x44, 0xb1, 0xc2, 0x2d, 0x89, 0x57, 0x55, 0x59, 0x0d, 0xff, 0xd2, 0xa1, 0xbf, 0x89, 0xec,
+        0x32, 0x25, 0xec, 0x80, 0x1e, 0x5c, 0xb3, 0x4f, 0xf0, 0x04, 0x8e, 0x5c, 0xff, 0xc6, 0xf2, 0x5c,
+        0x27, 0x9e, 0x0b, 0x8f, 0x69, 0x0a, 0x98, 0xf0, 0xc8, 0xbe, 0x8a, 0xb9, 0x10, 0x81, 0x60, 0x3a,
+        0x9e, 0xc1, 0xd3, 0xb9, 0x1f, 0xce, 0xb8, 0xed, 0x4e, 0x5c, 0xee, 0x34, 0xb0, 0x81, 0x9f, 0x01,
+        0x0a, 0x1e, 0xce, 0x02, 0x3f, 0xe4, 0x71, 0x14, 0x04, 0xb1, 0x67, 0x89, 0xd7, 0x9c, 0xb5, 0x14,
+        0xdd, 0xe1, 0x96, 0xe3, 0xb9, 0x3e, 0x8f, 0xf9, 0xaf, 0x36, 0xe7, 0x0e, 0x77, 0x58, 0x1b, 0x3f,
+        0x87, 0xb3, 0x30, 0xf4, 0x62, 0x9b, 0x8b, 0xc8, 0x9d, 0xb8, 0xb6, 0x15, 0xf1, 0xa6, 0x53, 0x07,
+        0x9f, 0x40, 0xdf, 0xf1, 0xc3, 0x26, 0xed, 0x22, 0x40, 0xc7, 0xf6, 0x82, 0x90, 0x3b, 0xac, 0x87,
+        0x2f, 0xc0, 0x74, 0xfd, 0x88, 0x0b, 0xdf, 0xf2, 0xe2, 0x48, 0x58, 0x7e, 0xe8, 0x72, 0x3f, 0x6a,
+        0x98, 0x7d, 0x35, 0x82, 0xba, 0x79, 0x6a, 0xf9, 0x6f, 0x62, 0xc1, 0x1d, 0x57, 0x70, 0x3b, 0x0a,
+        0x19, 0xe0, 0x33, 0x38, 0x99, 0x5a, 0xde, 0x24, 0x10, 0x53, 0xee, 0xc4, 0x82, 0xcf, 0xbc, 0x37,
+        0xec, 0x08, 0x4f, 0x81, 0xd9, 0x81, 0xef, 0x73, 0x3b, 0x72, 0x03, 0xbf, 0x69, 0x71, 0x3c, 0xfc,
+        0xc7, 0x80, 0x93, 0x9d, 0x5a, 0x82, 0x7e, 0x5f, 0x53, 0x2d, 0xf1, 0x27, 0xe8, 0x4c, 0x49, 0xde,
+        0x95, 0xa9, 0xa9, 0x0d, 0xf4, 0xd1, 0xa7, 0xaf, 0x46, 0xe3, 0xbd, 0xba, 0xe3, 0x47, 0xdc, 0x71,
+        0xf3, 0xbb, 0xe5, 0x8b, 0xe6, 0x1c, 0x32, 0x30, 0xe6, 0x55, 0x6e, 0xea, 0x03, 0x7d, 0xd4, 0x17,
+        0x2a, 0xc4, 0x1f, 0xa1, 0x73, 0x47, 0x49, 0x4a, 0x95, 0x69, 0x0c, 0x8c, 0x11, 0xbc, 0xfa, 0xea,
+        0x23, 0x3d, 0xaf, 0x36, 0x44, 0xd1, 0x1c, 0xc0, 0x17, 0xd0, 0x9d, 0x25, 0xf7, 0x79, 0x99, 0xa4,
+        0x66, 0x67, 0xa0, 0x8d, 0x8e, 0x2f, 0xf5, 0x9e, 0x26, 0x76, 0x10, 0x8e, 0xe1, 0x64, 0x52, 0xe6,
+        0x79, 0xf9, 0x87, 0xa0, 0x34, 0xab, 0x68, 0x21, 0x6b, 0xb3, 0x3b, 0xd0, 0x46, 0xbd, 0x8b, 0x96,
+        0xac, 0xd6, 0x24, 0x1e, 0x17, 0xf1, 0x39, 0xf4, 0x1c, 0x4a, 0xd2, 0x3c, 0x2b, 0xc8, 0xec, 0x0d,
+        0xb4, 0x91, 0x26, 0xf6, 0x39, 0xfe, 0x0c, 0x5f, 0x4c, 0xd7, 0xb5, 0xbc, 0x49, 0xf2, 0x2c, 0x4d,
+        0x24, 0xa9, 0xed, 0xa1, 0xca, 0xa6, 0x4a, 0x66, 0xb7, 0xd9, 0x22, 0x91, 0x64, 0xf6, 0xdf, 0xeb,
+        0xfc, 0x71, 0xea, 0xf3, 0x97, 0xd0, 0xd9, 0xfe, 0x0f, 0x25, 0xc6, 0x35, 0xdd, 0x9b, 0xad, 0xad,
+        0x18, 0xd7, 0x74, 0x8f, 0xa7, 0xd0, 0xbe, 0x49, 0xf2, 0x35, 0x99, 0xed, 0x0d, 0xb6, 0x4d, 0x86,
+        0x1e, 0x3c, 0x79, 0xa0, 0x26, 0x76, 0xc1, 0x78, 0xcd, 0x23, 0xa6, 0x61, 0x0f, 0x5a, 0xb3, 0x20,
+        0x8c, 0x98, 0xae, 0xa2, 0x2b, 0x6e, 0x39, 0xcc, 0x50, 0xc5, 0xd9, 0x3c, 0x62, 0x2d, 0xb5, 0x2e,
+        0x0e, 0xf7, 0x78, 0xc4, 0x59, 0x1b, 0xfb, 0xd0, 0x9e, 0x59, 0x91, 0x7d, 0xc5, 0x3a, 0xc3, 0x7f,
+        0x0d, 0x60, 0xef, 0x84, 0xad, 0x57, 0x65, 0x51, 0x13, 0x9a, 0xd0, 0xb5, 0xcb, 0x42, 0x52, 0x21,
+        0x4d, 0x4d, 0x49, 0x29, 0x76, 0x29, 0x7e, 0x09, 0x10, 0xca, 0x44, 0xae, 0x6b, 0xf5, 0x71, 0x6c,
+        0x8c, 0x6b, 0x8b, 0xf7, 0x10, 0xbc, 0x78, 0xe4, 0xdf, 0xf0, 0xa0, 0x7f, 0xdb, 0x6b, 0x1e, 0x1b,
+        0xf8, 0x03, 0x3c, 0x6b, 0xae, 0xf9, 0x25, 0xa9, 0xa3, 0x6a, 0x5d, 0x28, 0x81, 0xb6, 0x66, 0xf6,
+        0x2e, 0xda, 0xb7, 0x49, 0x5e, 0x93, 0x38, 0xc4, 0xc0, 0x6f, 0xe0, 0x29, 0xff, 0x73, 0xfb, 0x02,
+        0x5c, 0xde, 0x4b, 0xaa, 0x43, 0x35, 0xb8, 0x72, 0xd7, 0x10, 0x1f, 0x16, 0xf0, 0x7b, 0x38, 0x7b,
+        0x00, 0x0a, 0x5a, 0x50, 0xf6, 0x96, 0xd2, 0x8d, 0xcd, 0x86, 0x38, 0x5c, 0x54, 0xfb, 0x30, 0xc9,
+        0x8a, 0x24, 0x57, 0xfb, 0xaa, 0xec, 0xed, 0x8b, 0x7d, 0x8e, 0xdf, 0x01, 0x5a, 0xab, 0xcc, 0x5e,
+        0xad, 0xa7, 0x59, 0x9e, 0x67, 0x35, 0x2d, 0xca, 0x22, 0xad, 0x4d, 0x50, 0xed, 0x2e, 0xb4, 0x97,
+        0xe2, 0x40, 0x11, 0xbf, 0x86, 0x63, 0x6b, 0x95, 0xbd, 0x9b, 0xf6, 0x68, 0x47, 0x7e, 0x00, 0xe3,
+        0xb7, 0xc0, 0x76, 0xf9, 0x7e, 0xcc, 0xe3, 0x1d, 0xf5, 0x83, 0xd2, 0xff, 0x5f, 0xa6, 0x4b, 0xf8,
+        0xad, 0xb7, 0x7b, 0x2a, 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x1d, 0x9f, 0x6d, 0x24, 0x63, 0x05,
+        0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto b/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto
new file mode 100644
index 0000000..f695edf
--- /dev/null
+++ b/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto
@@ -0,0 +1,64 @@
+syntax = "proto2";
+option go_package = "urlfetch";
+
+package appengine;
+
+message URLFetchServiceError {
+  enum ErrorCode {
+    OK = 0;
+    INVALID_URL = 1;
+    FETCH_ERROR = 2;
+    UNSPECIFIED_ERROR = 3;
+    RESPONSE_TOO_LARGE = 4;
+    DEADLINE_EXCEEDED = 5;
+    SSL_CERTIFICATE_ERROR = 6;
+    DNS_ERROR = 7;
+    CLOSED = 8;
+    INTERNAL_TRANSIENT_ERROR = 9;
+    TOO_MANY_REDIRECTS = 10;
+    MALFORMED_REPLY = 11;
+    CONNECTION_ERROR = 12;
+  }
+}
+
+message URLFetchRequest {
+  enum RequestMethod {
+    GET = 1;
+    POST = 2;
+    HEAD = 3;
+    PUT = 4;
+    DELETE = 5;
+    PATCH = 6;
+  }
+  required RequestMethod Method = 1;
+  required string Url = 2;
+  repeated group Header = 3 {
+    required string Key = 4;
+    required string Value = 5;
+  }
+  optional bytes Payload = 6 [ctype=CORD];
+
+  optional bool FollowRedirects = 7 [default=true];
+
+  optional double Deadline = 8;
+
+  optional bool MustValidateServerCertificate = 9 [default=true];
+}
+
+message URLFetchResponse {
+  optional bytes Content = 1;
+  required int32 StatusCode = 2;
+  repeated group Header = 3 {
+    required string Key = 4;
+    required string Value = 5;
+  }
+  optional bool ContentWasTruncated = 6 [default=false];
+  optional int64 ExternalBytesSent = 7;
+  optional int64 ExternalBytesReceived = 8;
+
+  optional string FinalUrl = 9;
+
+  optional int64 ApiCpuMilliseconds = 10 [default=0];
+  optional int64 ApiBytesSent = 11 [default=0];
+  optional int64 ApiBytesReceived = 12 [default=0];
+}
diff --git a/vendor/google.golang.org/appengine/namespace.go b/vendor/google.golang.org/appengine/namespace.go
new file mode 100644
index 0000000..21860ca
--- /dev/null
+++ b/vendor/google.golang.org/appengine/namespace.go
@@ -0,0 +1,25 @@
+// Copyright 2012 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package appengine
+
+import (
+        "fmt"
+        "regexp"
+
+        "golang.org/x/net/context"
+
+        "google.golang.org/appengine/internal"
+)
+
+// Namespace returns a replacement context that operates within the given namespace.
+func Namespace(c context.Context, namespace string) (context.Context, error) {
+        if !validNamespace.MatchString(namespace) {
+                return nil, fmt.Errorf("appengine: namespace %q does not match /%s/", namespace, validNamespace)
+        }
+        return internal.NamespacedContext(c, namespace), nil
+}
+
+// validNamespace matches valid namespace names.
+var validNamespace = regexp.MustCompile(`^[0-9A-Za-z._-]{0,100}$`)
diff --git a/vendor/google.golang.org/appengine/timeout.go b/vendor/google.golang.org/appengine/timeout.go
new file mode 100644
index 0000000..05642a9
--- /dev/null
+++ b/vendor/google.golang.org/appengine/timeout.go
@@ -0,0 +1,20 @@
+// Copyright 2013 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package appengine
+
+import "golang.org/x/net/context"
+
+// IsTimeoutError reports whether err is a timeout error.
+func IsTimeoutError(err error) bool {
+        if err == context.DeadlineExceeded {
+                return true
+        }
+        if t, ok := err.(interface {
+                IsTimeout() bool
+        }); ok {
+                return t.IsTimeout()
+        }
+        return false
+}
diff --git a/vendor/google.golang.org/appengine/travis_install.sh b/vendor/google.golang.org/appengine/travis_install.sh
new file mode 100644
index 0000000..785b62f
--- /dev/null
+++ b/vendor/google.golang.org/appengine/travis_install.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+set -e
+
+if [[ $GO111MODULE == "on" ]]; then
+  go get .
+else
+  go get -u -v $(go list -f '{{join .Imports "\n"}}{{"\n"}}{{join .TestImports "\n"}}' ./... | sort | uniq | grep -v appengine)
+fi
+
+if [[ $GOAPP == "true" ]]; then
+  mkdir /tmp/sdk
+  curl -o /tmp/sdk.zip "https://storage.googleapis.com/appengine-sdks/featured/go_appengine_sdk_linux_amd64-1.9.68.zip"
+  unzip -q /tmp/sdk.zip -d /tmp/sdk
+  # NOTE: Set the following env vars in the test script:
+  # export PATH="$PATH:/tmp/sdk/go_appengine"
+  # export APPENGINE_DEV_APPSERVER=/tmp/sdk/go_appengine/dev_appserver.py
+fi
+
diff --git a/vendor/google.golang.org/appengine/travis_test.sh b/vendor/google.golang.org/appengine/travis_test.sh
new file mode 100644
index 0000000..d4390f0
--- /dev/null
+++ b/vendor/google.golang.org/appengine/travis_test.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+set -e
+
+go version
+go test -v google.golang.org/appengine/...
+go test -v -race google.golang.org/appengine/...
+if [[ $GOAPP == "true" ]]; then
+  export PATH="$PATH:/tmp/sdk/go_appengine"
+  export APPENGINE_DEV_APPSERVER=/tmp/sdk/go_appengine/dev_appserver.py
+  goapp version
+  goapp test -v google.golang.org/appengine/...
+fi
diff --git a/vendor/google.golang.org/appengine/urlfetch/urlfetch.go b/vendor/google.golang.org/appengine/urlfetch/urlfetch.go
new file mode 100644
index 0000000..6ffe1e6
--- /dev/null
+++ b/vendor/google.golang.org/appengine/urlfetch/urlfetch.go
@@ -0,0 +1,210 @@
+// Copyright 2011 Google Inc. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+// Package urlfetch provides an http.RoundTripper implementation
+// for fetching URLs via App Engine's urlfetch service.
+package urlfetch // import "google.golang.org/appengine/urlfetch"
+
+import (
+        "errors"
+        "fmt"
+        "io"
+        "io/ioutil"
+        "net/http"
+        "net/url"
+        "strconv"
+        "strings"
+        "time"
+
+        "github.com/golang/protobuf/proto"
+        "golang.org/x/net/context"
+
+        "google.golang.org/appengine/internal"
+        pb "google.golang.org/appengine/internal/urlfetch"
+)
+
+// Transport is an implementation of http.RoundTripper for
+// App Engine. Users should generally create an http.Client using
+// this transport and use the Client rather than using this transport
+// directly.
+type Transport struct {
+        Context context.Context
+
+        // Controls whether the application checks the validity of SSL certificates
+        // over HTTPS connections. A value of false (the default) instructs the
+        // application to send a request to the server only if the certificate is
+        // valid and signed by a trusted certificate authority (CA), and also
+        // includes a hostname that matches the certificate. A value of true
+        // instructs the application to perform no certificate validation.
+        AllowInvalidServerCertificate bool
+}
+
+// Verify statically that *Transport implements http.RoundTripper.
+var _ http.RoundTripper = (*Transport)(nil)
+
+// Client returns an *http.Client using a default urlfetch Transport. This
+// client will have the default deadline of 5 seconds, and will check the
+// validity of SSL certificates.
+//
+// Any deadline of the provided context will be used for requests through this client;
+// if the client does not have a deadline then a 5 second default is used.
+func Client(ctx context.Context) *http.Client {
+        return &http.Client{
+                Transport: &Transport{
+                        Context: ctx,
+                },
+        }
+}
+
+type bodyReader struct {
+        content   []byte
+        truncated bool
+        closed    bool
+}
+
+// ErrTruncatedBody is the error returned after the final Read() from a
+// response's Body if the body has been truncated by App Engine's proxy.
+var ErrTruncatedBody = errors.New("urlfetch: truncated body")
+
+func statusCodeToText(code int) string {
+        if t := http.StatusText(code); t != "" {
+                return t
+        }
+        return strconv.Itoa(code)
+}
+
+func (br *bodyReader) Read(p []byte) (n int, err error) {
+        if br.closed {
+                if br.truncated {
+                        return 0, ErrTruncatedBody
+                }
+                return 0, io.EOF
+        }
+        n = copy(p, br.content)
+        if n > 0 {
+                br.content = br.content[n:]
+                return
+        }
+        if br.truncated {
+                br.closed = true
+                return 0, ErrTruncatedBody
+        }
+        return 0, io.EOF
+}
+
+func (br *bodyReader) Close() error {
+        br.closed = true
+        br.content = nil
+        return nil
+}
+
+// A map of the URL Fetch-accepted methods that take a request body.
+var methodAcceptsRequestBody = map[string]bool{
+        "POST":  true,
+        "PUT":   true,
+        "PATCH": true,
+}
+
+// urlString returns a valid string given a URL. This function is necessary because
+// the String method of URL doesn't correctly handle URLs with non-empty Opaque values.
+// See http://code.google.com/p/go/issues/detail?id=4860.
+func urlString(u *url.URL) string {
+        if u.Opaque == "" || strings.HasPrefix(u.Opaque, "//") {
+                return u.String()
+        }
+        aux := *u
+        aux.Opaque = "//" + aux.Host + aux.Opaque
+        return aux.String()
+}
+
+// RoundTrip issues a single HTTP request and returns its response. Per the
+// http.RoundTripper interface, RoundTrip only returns an error if there
+// was an unsupported request or the URL Fetch proxy fails.
+// Note that HTTP response codes such as 5xx, 403, 404, etc are not
+// errors as far as the transport is concerned and will be returned
+// with err set to nil.
+func (t *Transport) RoundTrip(req *http.Request) (res *http.Response, err error) {
+        methNum, ok := pb.URLFetchRequest_RequestMethod_value[req.Method]
+        if !ok {
+                return nil, fmt.Errorf("urlfetch: unsupported HTTP method %q", req.Method)
+        }
+
+        method := pb.URLFetchRequest_RequestMethod(methNum)
+
+        freq := &pb.URLFetchRequest{
+                Method:                        &method,
+                Url:                           proto.String(urlString(req.URL)),
+                FollowRedirects:               proto.Bool(false), // http.Client's responsibility
+                MustValidateServerCertificate: proto.Bool(!t.AllowInvalidServerCertificate),
+        }
+        if deadline, ok := t.Context.Deadline(); ok {
+                freq.Deadline = proto.Float64(deadline.Sub(time.Now()).Seconds())
+        }
+
+        for k, vals := range req.Header {
+                for _, val := range vals {
+                        freq.Header = append(freq.Header, &pb.URLFetchRequest_Header{
+                                Key:   proto.String(k),
+                                Value: proto.String(val),
+                        })
+                }
+        }
+        if methodAcceptsRequestBody[req.Method] && req.Body != nil {
+                // Avoid a []byte copy if req.Body has a Bytes method.
+                switch b := req.Body.(type) {
+                case interface {
+                        Bytes() []byte
+                }:
+                        freq.Payload = b.Bytes()
+                default:
+                        freq.Payload, err = ioutil.ReadAll(req.Body)
+                        if err != nil {
+                                return nil, err
+                        }
+                }
+        }
+
+        fres := &pb.URLFetchResponse{}
+        if err := internal.Call(t.Context, "urlfetch", "Fetch", freq, fres); err != nil {
+                return nil, err
+        }
+
+        res = &http.Response{}
+        res.StatusCode = int(*fres.StatusCode)
+        res.Status = fmt.Sprintf("%d %s", res.StatusCode, statusCodeToText(res.StatusCode))
+        res.Header = make(http.Header)
+        res.Request = req
+
+        // Faked:
+        res.ProtoMajor = 1
+        res.ProtoMinor = 1
+        res.Proto = "HTTP/1.1"
+        res.Close = true
+
+        for _, h := range fres.Header {
+                hkey := http.CanonicalHeaderKey(*h.Key)
+                hval := *h.Value
+                if hkey == "Content-Length" {
+                        // Will get filled in below for all but HEAD requests.
+                        if req.Method == "HEAD" {
+                                res.ContentLength, _ = strconv.ParseInt(hval, 10, 64)
+                        }
+                        continue
+                }
+                res.Header.Add(hkey, hval)
+        }
+
+        if req.Method != "HEAD" {
+                res.ContentLength = int64(len(fres.Content))
+        }
+
+        truncated := fres.GetContentWasTruncated()
+        res.Body = &bodyReader{content: fres.Content, truncated: truncated}
+        return
+}
+
+func init() {
+        internal.RegisterErrorCodeMap("urlfetch", pb.URLFetchServiceError_ErrorCode_name)
+        internal.RegisterTimeoutErrorCode("urlfetch", int32(pb.URLFetchServiceError_DEADLINE_EXCEEDED))
+}
diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/annotations.pb.go b/vendor/google.golang.org/genproto/googleapis/api/annotations/annotations.pb.go
new file mode 100644
index 0000000..9521b50
--- /dev/null
+++ b/vendor/google.golang.org/genproto/googleapis/api/annotations/annotations.pb.go
@@ -0,0 +1,54 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/api/annotations.proto
+
+package annotations // import "google.golang.org/genproto/googleapis/api/annotations"
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+var E_Http = &proto.ExtensionDesc{
+        ExtendedType:  (*descriptor.MethodOptions)(nil),
+        ExtensionType: (*HttpRule)(nil),
+        Field:         72295728,
+        Name:          "google.api.http",
+        Tag:           "bytes,72295728,opt,name=http",
+        Filename:      "google/api/annotations.proto",
+}
+
+func init() {
+        proto.RegisterExtension(E_Http)
+}
+
+func init() {
+        proto.RegisterFile("google/api/annotations.proto", fileDescriptor_annotations_55609bb51d80951d)
+}
+
+var fileDescriptor_annotations_55609bb51d80951d = []byte{
+        // 208 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x49, 0xcf, 0xcf, 0x4f,
+        0xcf, 0x49, 0xd5, 0x4f, 0x2c, 0xc8, 0xd4, 0x4f, 0xcc, 0xcb, 0xcb, 0x2f, 0x49, 0x2c, 0xc9, 0xcc,
+        0xcf, 0x2b, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x82, 0xc8, 0xea, 0x25, 0x16, 0x64,
+        0x4a, 0x89, 0x22, 0xa9, 0xcc, 0x28, 0x29, 0x29, 0x80, 0x28, 0x91, 0x52, 0x80, 0x0a, 0x83, 0x79,
+        0x49, 0xa5, 0x69, 0xfa, 0x29, 0xa9, 0xc5, 0xc9, 0x45, 0x99, 0x05, 0x25, 0xf9, 0x45, 0x10, 0x15,
+        0x56, 0xde, 0x5c, 0x2c, 0x20, 0xf5, 0x42, 0x72, 0x7a, 0x50, 0xd3, 0x60, 0x4a, 0xf5, 0x7c, 0x53,
+        0x4b, 0x32, 0xf2, 0x53, 0xfc, 0x0b, 0xc0, 0x56, 0x4a, 0x6c, 0x38, 0xb5, 0x47, 0x49, 0x81, 0x51,
+        0x83, 0xdb, 0x48, 0x44, 0x0f, 0x61, 0xad, 0x9e, 0x47, 0x49, 0x49, 0x41, 0x50, 0x69, 0x4e, 0x6a,
+        0x10, 0xd8, 0x10, 0xa7, 0x3c, 0x2e, 0xbe, 0xe4, 0xfc, 0x5c, 0x24, 0x05, 0x4e, 0x02, 0x8e, 0x08,
+        0x67, 0x07, 0x80, 0x4c, 0x0e, 0x60, 0x8c, 0x72, 0x84, 0xca, 0xa7, 0xe7, 0xe7, 0x24, 0xe6, 0xa5,
+        0xeb, 0xe5, 0x17, 0xa5, 0xeb, 0xa7, 0xa7, 0xe6, 0x81, 0xed, 0xd5, 0x87, 0x48, 0x25, 0x16, 0x64,
+        0x16, 0xa3, 0x7b, 0xda, 0x1a, 0x89, 0xbd, 0x88, 0x89, 0xc5, 0xdd, 0x31, 0xc0, 0x33, 0x89, 0x0d,
+        0xac, 0xc9, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0xe3, 0x29, 0x19, 0x62, 0x28, 0x01, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/http.pb.go b/vendor/google.golang.org/genproto/googleapis/api/annotations/http.pb.go
new file mode 100644
index 0000000..1a8a27b
--- /dev/null
+++ b/vendor/google.golang.org/genproto/googleapis/api/annotations/http.pb.go
@@ -0,0 +1,688 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/api/http.proto
+
+package annotations // import "google.golang.org/genproto/googleapis/api/annotations"
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// Defines the HTTP configuration for an API service. It contains a list of
+// [HttpRule][google.api.HttpRule], each specifying the mapping of an RPC method
+// to one or more HTTP REST API methods.
+type Http struct {
+        // A list of HTTP configuration rules that apply to individual API methods.
+        //
+        // **NOTE:** All service configuration rules follow "last one wins" order.
+        Rules []*HttpRule `protobuf:"bytes,1,rep,name=rules,proto3" json:"rules,omitempty"`
+        // When set to true, URL path parmeters will be fully URI-decoded except in
+        // cases of single segment matches in reserved expansion, where "%2F" will be
+        // left encoded.
+        //
+        // The default behavior is to not decode RFC 6570 reserved characters in multi
+        // segment matches.
+        FullyDecodeReservedExpansion bool     `protobuf:"varint,2,opt,name=fully_decode_reserved_expansion,json=fullyDecodeReservedExpansion,proto3" json:"fully_decode_reserved_expansion,omitempty"`
+        XXX_NoUnkeyedLiteral         struct{} `json:"-"`
+        XXX_unrecognized             []byte   `json:"-"`
+        XXX_sizecache                int32    `json:"-"`
+}
+
+func (m *Http) Reset()         { *m = Http{} }
+func (m *Http) String() string { return proto.CompactTextString(m) }
+func (*Http) ProtoMessage()    {}
+func (*Http) Descriptor() ([]byte, []int) {
+        return fileDescriptor_http_e457621dddd7365b, []int{0}
+}
+func (m *Http) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Http.Unmarshal(m, b)
+}
+func (m *Http) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Http.Marshal(b, m, deterministic)
+}
+func (dst *Http) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Http.Merge(dst, src)
+}
+func (m *Http) XXX_Size() int {
+        return xxx_messageInfo_Http.Size(m)
+}
+func (m *Http) XXX_DiscardUnknown() {
+        xxx_messageInfo_Http.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Http proto.InternalMessageInfo
+
+func (m *Http) GetRules() []*HttpRule {
+        if m != nil {
+                return m.Rules
+        }
+        return nil
+}
+
+func (m *Http) GetFullyDecodeReservedExpansion() bool {
+        if m != nil {
+                return m.FullyDecodeReservedExpansion
+        }
+        return false
+}
+
+// `HttpRule` defines the mapping of an RPC method to one or more HTTP
+// REST API methods. The mapping specifies how different portions of the RPC
+// request message are mapped to URL path, URL query parameters, and
+// HTTP request body. The mapping is typically specified as an
+// `google.api.http` annotation on the RPC method,
+// see "google/api/annotations.proto" for details.
+//
+// The mapping consists of a field specifying the path template and
+// method kind.  The path template can refer to fields in the request
+// message, as in the example below which describes a REST GET
+// operation on a resource collection of messages:
+//
+//
+//     service Messaging {
+//       rpc GetMessage(GetMessageRequest) returns (Message) {
+//         option (google.api.http).get = "/v1/messages/{message_id}/{sub.subfield}";
+//       }
+//     }
+//     message GetMessageRequest {
+//       message SubMessage {
+//         string subfield = 1;
+//       }
+//       string message_id = 1; // mapped to the URL
+//       SubMessage sub = 2;    // `sub.subfield` is url-mapped
+//     }
+//     message Message {
+//       string text = 1; // content of the resource
+//     }
+//
+// The same http annotation can alternatively be expressed inside the
+// `GRPC API Configuration` YAML file.
+//
+//     http:
+//       rules:
+//         - selector: <proto_package_name>.Messaging.GetMessage
+//           get: /v1/messages/{message_id}/{sub.subfield}
+//
+// This definition enables an automatic, bidrectional mapping of HTTP
+// JSON to RPC. Example:
+//
+// HTTP | RPC
+// -----|-----
+// `GET /v1/messages/123456/foo`  | `GetMessage(message_id: "123456" sub: SubMessage(subfield: "foo"))`
+//
+// In general, not only fields but also field paths can be referenced
+// from a path pattern. Fields mapped to the path pattern cannot be
+// repeated and must have a primitive (non-message) type.
+//
+// Any fields in the request message which are not bound by the path
+// pattern automatically become (optional) HTTP query
+// parameters. Assume the following definition of the request message:
+//
+//
+//     service Messaging {
+//       rpc GetMessage(GetMessageRequest) returns (Message) {
+//         option (google.api.http).get = "/v1/messages/{message_id}";
+//       }
+//     }
+//     message GetMessageRequest {
+//       message SubMessage {
+//         string subfield = 1;
+//       }
+//       string message_id = 1; // mapped to the URL
+//       int64 revision = 2;    // becomes a parameter
+//       SubMessage sub = 3;    // `sub.subfield` becomes a parameter
+//     }
+//
+//
+// This enables a HTTP JSON to RPC mapping as below:
+//
+// HTTP | RPC
+// -----|-----
+// `GET /v1/messages/123456?revision=2&sub.subfield=foo` | `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield: "foo"))`
+//
+// Note that fields which are mapped to HTTP parameters must have a
+// primitive type or a repeated primitive type. Message types are not
+// allowed. In the case of a repeated type, the parameter can be
+// repeated in the URL, as in `...?param=A&param=B`.
+//
+// For HTTP method kinds which allow a request body, the `body` field
+// specifies the mapping. Consider a REST update method on the
+// message resource collection:
+//
+//
+//     service Messaging {
+//       rpc UpdateMessage(UpdateMessageRequest) returns (Message) {
+//         option (google.api.http) = {
+//           put: "/v1/messages/{message_id}"
+//           body: "message"
+//         };
+//       }
+//     }
+//     message UpdateMessageRequest {
+//       string message_id = 1; // mapped to the URL
+//       Message message = 2;   // mapped to the body
+//     }
+//
+//
+// The following HTTP JSON to RPC mapping is enabled, where the
+// representation of the JSON in the request body is determined by
+// protos JSON encoding:
+//
+// HTTP | RPC
+// -----|-----
+// `PUT /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: "123456" message { text: "Hi!" })`
+//
+// The special name `*` can be used in the body mapping to define that
+// every field not bound by the path template should be mapped to the
+// request body.  This enables the following alternative definition of
+// the update method:
+//
+//     service Messaging {
+//       rpc UpdateMessage(Message) returns (Message) {
+//         option (google.api.http) = {
+//           put: "/v1/messages/{message_id}"
+//           body: "*"
+//         };
+//       }
+//     }
+//     message Message {
+//       string message_id = 1;
+//       string text = 2;
+//     }
+//
+//
+// The following HTTP JSON to RPC mapping is enabled:
+//
+// HTTP | RPC
+// -----|-----
+// `PUT /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: "123456" text: "Hi!")`
+//
+// Note that when using `*` in the body mapping, it is not possible to
+// have HTTP parameters, as all fields not bound by the path end in
+// the body. This makes this option more rarely used in practice of
+// defining REST APIs. The common usage of `*` is in custom methods
+// which don't use the URL at all for transferring data.
+//
+// It is possible to define multiple HTTP methods for one RPC by using
+// the `additional_bindings` option. Example:
+//
+//     service Messaging {
+//       rpc GetMessage(GetMessageRequest) returns (Message) {
+//         option (google.api.http) = {
+//           get: "/v1/messages/{message_id}"
+//           additional_bindings {
+//             get: "/v1/users/{user_id}/messages/{message_id}"
+//           }
+//         };
+//       }
+//     }
+//     message GetMessageRequest {
+//       string message_id = 1;
+//       string user_id = 2;
+//     }
+//
+//
+// This enables the following two alternative HTTP JSON to RPC
+// mappings:
+//
+// HTTP | RPC
+// -----|-----
+// `GET /v1/messages/123456` | `GetMessage(message_id: "123456")`
+// `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id: "123456")`
+//
+// # Rules for HTTP mapping
+//
+// The rules for mapping HTTP path, query parameters, and body fields
+// to the request message are as follows:
+//
+// 1. The `body` field specifies either `*` or a field path, or is
+//    omitted. If omitted, it indicates there is no HTTP request body.
+// 2. Leaf fields (recursive expansion of nested messages in the
+//    request) can be classified into three types:
+//     (a) Matched in the URL template.
+//     (b) Covered by body (if body is `*`, everything except (a) fields;
+//         else everything under the body field)
+//     (c) All other fields.
+// 3. URL query parameters found in the HTTP request are mapped to (c) fields.
+// 4. Any body sent with an HTTP request can contain only (b) fields.
+//
+// The syntax of the path template is as follows:
+//
+//     Template = "/" Segments [ Verb ] ;
+//     Segments = Segment { "/" Segment } ;
+//     Segment  = "*" | "**" | LITERAL | Variable ;
+//     Variable = "{" FieldPath [ "=" Segments ] "}" ;
+//     FieldPath = IDENT { "." IDENT } ;
+//     Verb     = ":" LITERAL ;
+//
+// The syntax `*` matches a single path segment. The syntax `**` matches zero
+// or more path segments, which must be the last part of the path except the
+// `Verb`. The syntax `LITERAL` matches literal text in the path.
+//
+// The syntax `Variable` matches part of the URL path as specified by its
+// template. A variable template must not contain other variables. If a variable
+// matches a single path segment, its template may be omitted, e.g. `{var}`
+// is equivalent to `{var=*}`.
+//
+// If a variable contains exactly one path segment, such as `"{var}"` or
+// `"{var=*}"`, when such a variable is expanded into a URL path, all characters
+// except `[-_.~0-9a-zA-Z]` are percent-encoded. Such variables show up in the
+// Discovery Document as `{var}`.
+//
+// If a variable contains one or more path segments, such as `"{var=foo/*}"`
+// or `"{var=**}"`, when such a variable is expanded into a URL path, all
+// characters except `[-_.~/0-9a-zA-Z]` are percent-encoded. Such variables
+// show up in the Discovery Document as `{+var}`.
+//
+// NOTE: While the single segment variable matches the semantics of
+// [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2
+// Simple String Expansion, the multi segment variable **does not** match
+// RFC 6570 Reserved Expansion. The reason is that the Reserved Expansion
+// does not expand special characters like `?` and `#`, which would lead
+// to invalid URLs.
+//
+// NOTE: the field paths in variables and in the `body` must not refer to
+// repeated fields or map fields.
+type HttpRule struct {
+        // Selects methods to which this rule applies.
+        //
+        // Refer to [selector][google.api.DocumentationRule.selector] for syntax details.
+        Selector string `protobuf:"bytes,1,opt,name=selector,proto3" json:"selector,omitempty"`
+        // Determines the URL pattern is matched by this rules. This pattern can be
+        // used with any of the {get|put|post|delete|patch} methods. A custom method
+        // can be defined using the 'custom' field.
+        //
+        // Types that are valid to be assigned to Pattern:
+        //      *HttpRule_Get
+        //      *HttpRule_Put
+        //      *HttpRule_Post
+        //      *HttpRule_Delete
+        //      *HttpRule_Patch
+        //      *HttpRule_Custom
+        Pattern isHttpRule_Pattern `protobuf_oneof:"pattern"`
+        // The name of the request field whose value is mapped to the HTTP body, or
+        // `*` for mapping all fields not captured by the path pattern to the HTTP
+        // body. NOTE: the referred field must not be a repeated field and must be
+        // present at the top-level of request message type.
+        Body string `protobuf:"bytes,7,opt,name=body,proto3" json:"body,omitempty"`
+        // Optional. The name of the response field whose value is mapped to the HTTP
+        // body of response. Other response fields are ignored. When
+        // not set, the response message will be used as HTTP body of response.
+        ResponseBody string `protobuf:"bytes,12,opt,name=response_body,json=responseBody,proto3" json:"response_body,omitempty"`
+        // Additional HTTP bindings for the selector. Nested bindings must
+        // not contain an `additional_bindings` field themselves (that is,
+        // the nesting may only be one level deep).
+        AdditionalBindings   []*HttpRule `protobuf:"bytes,11,rep,name=additional_bindings,json=additionalBindings,proto3" json:"additional_bindings,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+        XXX_unrecognized     []byte      `json:"-"`
+        XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *HttpRule) Reset()         { *m = HttpRule{} }
+func (m *HttpRule) String() string { return proto.CompactTextString(m) }
+func (*HttpRule) ProtoMessage()    {}
+func (*HttpRule) Descriptor() ([]byte, []int) {
+        return fileDescriptor_http_e457621dddd7365b, []int{1}
+}
+func (m *HttpRule) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_HttpRule.Unmarshal(m, b)
+}
+func (m *HttpRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_HttpRule.Marshal(b, m, deterministic)
+}
+func (dst *HttpRule) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_HttpRule.Merge(dst, src)
+}
+func (m *HttpRule) XXX_Size() int {
+        return xxx_messageInfo_HttpRule.Size(m)
+}
+func (m *HttpRule) XXX_DiscardUnknown() {
+        xxx_messageInfo_HttpRule.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_HttpRule proto.InternalMessageInfo
+
+func (m *HttpRule) GetSelector() string {
+        if m != nil {
+                return m.Selector
+        }
+        return ""
+}
+
+type isHttpRule_Pattern interface {
+        isHttpRule_Pattern()
+}
+
+type HttpRule_Get struct {
+        Get string `protobuf:"bytes,2,opt,name=get,proto3,oneof"`
+}
+
+type HttpRule_Put struct {
+        Put string `protobuf:"bytes,3,opt,name=put,proto3,oneof"`
+}
+
+type HttpRule_Post struct {
+        Post string `protobuf:"bytes,4,opt,name=post,proto3,oneof"`
+}
+
+type HttpRule_Delete struct {
+        Delete string `protobuf:"bytes,5,opt,name=delete,proto3,oneof"`
+}
+
+type HttpRule_Patch struct {
+        Patch string `protobuf:"bytes,6,opt,name=patch,proto3,oneof"`
+}
+
+type HttpRule_Custom struct {
+        Custom *CustomHttpPattern `protobuf:"bytes,8,opt,name=custom,proto3,oneof"`
+}
+
+func (*HttpRule_Get) isHttpRule_Pattern() {}
+
+func (*HttpRule_Put) isHttpRule_Pattern() {}
+
+func (*HttpRule_Post) isHttpRule_Pattern() {}
+
+func (*HttpRule_Delete) isHttpRule_Pattern() {}
+
+func (*HttpRule_Patch) isHttpRule_Pattern() {}
+
+func (*HttpRule_Custom) isHttpRule_Pattern() {}
+
+func (m *HttpRule) GetPattern() isHttpRule_Pattern {
+        if m != nil {
+                return m.Pattern
+        }
+        return nil
+}
+
+func (m *HttpRule) GetGet() string {
+        if x, ok := m.GetPattern().(*HttpRule_Get); ok {
+                return x.Get
+        }
+        return ""
+}
+
+func (m *HttpRule) GetPut() string {
+        if x, ok := m.GetPattern().(*HttpRule_Put); ok {
+                return x.Put
+        }
+        return ""
+}
+
+func (m *HttpRule) GetPost() string {
+        if x, ok := m.GetPattern().(*HttpRule_Post); ok {
+                return x.Post
+        }
+        return ""
+}
+
+func (m *HttpRule) GetDelete() string {
+        if x, ok := m.GetPattern().(*HttpRule_Delete); ok {
+                return x.Delete
+        }
+        return ""
+}
+
+func (m *HttpRule) GetPatch() string {
+        if x, ok := m.GetPattern().(*HttpRule_Patch); ok {
+                return x.Patch
+        }
+        return ""
+}
+
+func (m *HttpRule) GetCustom() *CustomHttpPattern {
+        if x, ok := m.GetPattern().(*HttpRule_Custom); ok {
+                return x.Custom
+        }
+        return nil
+}
+
+func (m *HttpRule) GetBody() string {
+        if m != nil {
+                return m.Body
+        }
+        return ""
+}
+
+func (m *HttpRule) GetResponseBody() string {
+        if m != nil {
+                return m.ResponseBody
+        }
+        return ""
+}
+
+func (m *HttpRule) GetAdditionalBindings() []*HttpRule {
+        if m != nil {
+                return m.AdditionalBindings
+        }
+        return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*HttpRule) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+        return _HttpRule_OneofMarshaler, _HttpRule_OneofUnmarshaler, _HttpRule_OneofSizer, []interface{}{
+                (*HttpRule_Get)(nil),
+                (*HttpRule_Put)(nil),
+                (*HttpRule_Post)(nil),
+                (*HttpRule_Delete)(nil),
+                (*HttpRule_Patch)(nil),
+                (*HttpRule_Custom)(nil),
+        }
+}
+
+func _HttpRule_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+        m := msg.(*HttpRule)
+        // pattern
+        switch x := m.Pattern.(type) {
+        case *HttpRule_Get:
+                b.EncodeVarint(2<<3 | proto.WireBytes)
+                b.EncodeStringBytes(x.Get)
+        case *HttpRule_Put:
+                b.EncodeVarint(3<<3 | proto.WireBytes)
+                b.EncodeStringBytes(x.Put)
+        case *HttpRule_Post:
+                b.EncodeVarint(4<<3 | proto.WireBytes)
+                b.EncodeStringBytes(x.Post)
+        case *HttpRule_Delete:
+                b.EncodeVarint(5<<3 | proto.WireBytes)
+                b.EncodeStringBytes(x.Delete)
+        case *HttpRule_Patch:
+                b.EncodeVarint(6<<3 | proto.WireBytes)
+                b.EncodeStringBytes(x.Patch)
+        case *HttpRule_Custom:
+                b.EncodeVarint(8<<3 | proto.WireBytes)
+                if err := b.EncodeMessage(x.Custom); err != nil {
+                        return err
+                }
+        case nil:
+        default:
+                return fmt.Errorf("HttpRule.Pattern has unexpected type %T", x)
+        }
+        return nil
+}
+
+func _HttpRule_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+        m := msg.(*HttpRule)
+        switch tag {
+        case 2: // pattern.get
+                if wire != proto.WireBytes {
+                        return true, proto.ErrInternalBadWireType
+                }
+                x, err := b.DecodeStringBytes()
+                m.Pattern = &HttpRule_Get{x}
+                return true, err
+        case 3: // pattern.put
+                if wire != proto.WireBytes {
+                        return true, proto.ErrInternalBadWireType
+                }
+                x, err := b.DecodeStringBytes()
+                m.Pattern = &HttpRule_Put{x}
+                return true, err
+        case 4: // pattern.post
+                if wire != proto.WireBytes {
+                        return true, proto.ErrInternalBadWireType
+                }
+                x, err := b.DecodeStringBytes()
+                m.Pattern = &HttpRule_Post{x}
+                return true, err
+        case 5: // pattern.delete
+                if wire != proto.WireBytes {
+                        return true, proto.ErrInternalBadWireType
+                }
+                x, err := b.DecodeStringBytes()
+                m.Pattern = &HttpRule_Delete{x}
+                return true, err
+        case 6: // pattern.patch
+                if wire != proto.WireBytes {
+                        return true, proto.ErrInternalBadWireType
+                }
+                x, err := b.DecodeStringBytes()
+                m.Pattern = &HttpRule_Patch{x}
+                return true, err
+        case 8: // pattern.custom
+                if wire != proto.WireBytes {
+                        return true, proto.ErrInternalBadWireType
+                }
+                msg := new(CustomHttpPattern)
+                err := b.DecodeMessage(msg)
+                m.Pattern = &HttpRule_Custom{msg}
+                return true, err
+        default:
+                return false, nil
+        }
+}
+
+func _HttpRule_OneofSizer(msg proto.Message) (n int) {
+        m := msg.(*HttpRule)
+        // pattern
+        switch x := m.Pattern.(type) {
+        case *HttpRule_Get:
+                n += 1 // tag and wire
+                n += proto.SizeVarint(uint64(len(x.Get)))
+                n += len(x.Get)
+        case *HttpRule_Put:
+                n += 1 // tag and wire
+                n += proto.SizeVarint(uint64(len(x.Put)))
+                n += len(x.Put)
+        case *HttpRule_Post:
+                n += 1 // tag and wire
+                n += proto.SizeVarint(uint64(len(x.Post)))
+                n += len(x.Post)
+        case *HttpRule_Delete:
+                n += 1 // tag and wire
+                n += proto.SizeVarint(uint64(len(x.Delete)))
+                n += len(x.Delete)
+        case *HttpRule_Patch:
+                n += 1 // tag and wire
+                n += proto.SizeVarint(uint64(len(x.Patch)))
+                n += len(x.Patch)
+        case *HttpRule_Custom:
+                s := proto.Size(x.Custom)
+                n += 1 // tag and wire
+                n += proto.SizeVarint(uint64(s))
+                n += s
+        case nil:
+        default:
+                panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+        }
+        return n
+}
+
+// A custom pattern is used for defining custom HTTP verb.
+type CustomHttpPattern struct {
+        // The name of this custom HTTP verb.
+        Kind string `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind,omitempty"`
+        // The path matched by this custom verb.
+        Path                 string   `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *CustomHttpPattern) Reset()         { *m = CustomHttpPattern{} }
+func (m *CustomHttpPattern) String() string { return proto.CompactTextString(m) }
+func (*CustomHttpPattern) ProtoMessage()    {}
+func (*CustomHttpPattern) Descriptor() ([]byte, []int) {
+        return fileDescriptor_http_e457621dddd7365b, []int{2}
+}
+func (m *CustomHttpPattern) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_CustomHttpPattern.Unmarshal(m, b)
+}
+func (m *CustomHttpPattern) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_CustomHttpPattern.Marshal(b, m, deterministic)
+}
+func (dst *CustomHttpPattern) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_CustomHttpPattern.Merge(dst, src)
+}
+func (m *CustomHttpPattern) XXX_Size() int {
+        return xxx_messageInfo_CustomHttpPattern.Size(m)
+}
+func (m *CustomHttpPattern) XXX_DiscardUnknown() {
+        xxx_messageInfo_CustomHttpPattern.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CustomHttpPattern proto.InternalMessageInfo
+
+func (m *CustomHttpPattern) GetKind() string {
+        if m != nil {
+                return m.Kind
+        }
+        return ""
+}
+
+func (m *CustomHttpPattern) GetPath() string {
+        if m != nil {
+                return m.Path
+        }
+        return ""
+}
+
+func init() {
+        proto.RegisterType((*Http)(nil), "google.api.Http")
+        proto.RegisterType((*HttpRule)(nil), "google.api.HttpRule")
+        proto.RegisterType((*CustomHttpPattern)(nil), "google.api.CustomHttpPattern")
+}
+
+func init() { proto.RegisterFile("google/api/http.proto", fileDescriptor_http_e457621dddd7365b) }
+
+var fileDescriptor_http_e457621dddd7365b = []byte{
+        // 419 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x92, 0xc1, 0x8e, 0xd3, 0x30,
+        0x10, 0x86, 0x49, 0x9b, 0x76, 0xdb, 0xe9, 0x82, 0x84, 0x59, 0x90, 0x85, 0x40, 0x54, 0xe5, 0x52,
+        0x71, 0x48, 0xa5, 0xe5, 0xc0, 0x61, 0x4f, 0x1b, 0xa8, 0x58, 0x6e, 0x55, 0x8e, 0x5c, 0x22, 0x37,
+        0x1e, 0x52, 0x83, 0xd7, 0xb6, 0xe2, 0x09, 0xa2, 0xaf, 0xc3, 0x63, 0xf1, 0x24, 0x1c, 0x91, 0x9d,
+        0x84, 0x56, 0x42, 0xe2, 0x36, 0xf3, 0xff, 0x9f, 0xa7, 0x7f, 0x27, 0x03, 0x4f, 0x6b, 0x6b, 0x6b,
+        0x8d, 0x1b, 0xe1, 0xd4, 0xe6, 0x40, 0xe4, 0x32, 0xd7, 0x58, 0xb2, 0x0c, 0x3a, 0x39, 0x13, 0x4e,
+        0xad, 0x8e, 0x90, 0xde, 0x11, 0x39, 0xf6, 0x06, 0x26, 0x4d, 0xab, 0xd1, 0xf3, 0x64, 0x39, 0x5e,
+        0x2f, 0xae, 0xaf, 0xb2, 0x13, 0x93, 0x05, 0xa0, 0x68, 0x35, 0x16, 0x1d, 0xc2, 0xb6, 0xf0, 0xea,
+        0x4b, 0xab, 0xf5, 0xb1, 0x94, 0x58, 0x59, 0x89, 0x65, 0x83, 0x1e, 0x9b, 0xef, 0x28, 0x4b, 0xfc,
+        0xe1, 0x84, 0xf1, 0xca, 0x1a, 0x3e, 0x5a, 0x26, 0xeb, 0x59, 0xf1, 0x22, 0x62, 0x1f, 0x22, 0x55,
+        0xf4, 0xd0, 0x76, 0x60, 0x56, 0xbf, 0x46, 0x30, 0x1b, 0x46, 0xb3, 0xe7, 0x30, 0xf3, 0xa8, 0xb1,
+        0x22, 0xdb, 0xf0, 0x64, 0x99, 0xac, 0xe7, 0xc5, 0xdf, 0x9e, 0x31, 0x18, 0xd7, 0x48, 0x71, 0xe6,
+        0xfc, 0xee, 0x41, 0x11, 0x9a, 0xa0, 0xb9, 0x96, 0xf8, 0x78, 0xd0, 0x5c, 0x4b, 0xec, 0x0a, 0x52,
+        0x67, 0x3d, 0xf1, 0xb4, 0x17, 0x63, 0xc7, 0x38, 0x4c, 0x25, 0x6a, 0x24, 0xe4, 0x93, 0x5e, 0xef,
+        0x7b, 0xf6, 0x0c, 0x26, 0x4e, 0x50, 0x75, 0xe0, 0xd3, 0xde, 0xe8, 0x5a, 0xf6, 0x0e, 0xa6, 0x55,
+        0xeb, 0xc9, 0xde, 0xf3, 0xd9, 0x32, 0x59, 0x2f, 0xae, 0x5f, 0x9e, 0x2f, 0xe3, 0x7d, 0x74, 0x42,
+        0xee, 0x9d, 0x20, 0xc2, 0xc6, 0x84, 0x81, 0x1d, 0xce, 0x18, 0xa4, 0x7b, 0x2b, 0x8f, 0xfc, 0x22,
+        0xfe, 0x81, 0x58, 0xb3, 0xd7, 0xf0, 0xb0, 0x41, 0xef, 0xac, 0xf1, 0x58, 0x46, 0xf3, 0x32, 0x9a,
+        0x97, 0x83, 0x98, 0x07, 0x68, 0x0b, 0x4f, 0x84, 0x94, 0x8a, 0x94, 0x35, 0x42, 0x97, 0x7b, 0x65,
+        0xa4, 0x32, 0xb5, 0xe7, 0x8b, 0xff, 0x7c, 0x0b, 0x76, 0x7a, 0x90, 0xf7, 0x7c, 0x3e, 0x87, 0x0b,
+        0xd7, 0x85, 0x5a, 0xdd, 0xc0, 0xe3, 0x7f, 0x92, 0x86, 0x7c, 0xdf, 0x94, 0x91, 0xfd, 0x82, 0x63,
+        0x1d, 0x34, 0x27, 0xe8, 0xd0, 0x6d, 0xb7, 0x88, 0x75, 0xfe, 0x15, 0x1e, 0x55, 0xf6, 0xfe, 0xec,
+        0x67, 0xf3, 0x79, 0x1c, 0x13, 0xae, 0x67, 0x97, 0x7c, 0xbe, 0xed, 0x8d, 0xda, 0x6a, 0x61, 0xea,
+        0xcc, 0x36, 0xf5, 0xa6, 0x46, 0x13, 0x6f, 0x6b, 0xd3, 0x59, 0xc2, 0x29, 0x1f, 0xaf, 0x4e, 0x18,
+        0x63, 0x49, 0x84, 0x98, 0xfe, 0xe6, 0xac, 0xfe, 0x9d, 0x24, 0x3f, 0x47, 0xe9, 0xc7, 0xdb, 0xdd,
+        0xa7, 0xfd, 0x34, 0xbe, 0x7b, 0xfb, 0x27, 0x00, 0x00, 0xff, 0xff, 0xae, 0xde, 0xa1, 0xd0, 0xac,
+        0x02, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/genproto/googleapis/iam/v1/iam_policy.pb.go b/vendor/google.golang.org/genproto/googleapis/iam/v1/iam_policy.pb.go
new file mode 100644
index 0000000..dfc8796
--- /dev/null
+++ b/vendor/google.golang.org/genproto/googleapis/iam/v1/iam_policy.pb.go
@@ -0,0 +1,411 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/iam/v1/iam_policy.proto
+
+package iam // import "google.golang.org/genproto/googleapis/iam/v1"
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import _ "google.golang.org/genproto/googleapis/api/annotations"
+
+import (
+        context "golang.org/x/net/context"
+        grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// Request message for `SetIamPolicy` method.
+type SetIamPolicyRequest struct {
+        // REQUIRED: The resource for which the policy is being specified.
+        // `resource` is usually specified as a path. For example, a Project
+        // resource is specified as `projects/{project}`.
+        Resource string `protobuf:"bytes,1,opt,name=resource,proto3" json:"resource,omitempty"`
+        // REQUIRED: The complete policy to be applied to the `resource`. The size of
+        // the policy is limited to a few 10s of KB. An empty policy is a
+        // valid policy but certain Cloud Platform services (such as Projects)
+        // might reject them.
+        Policy               *Policy  `protobuf:"bytes,2,opt,name=policy,proto3" json:"policy,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SetIamPolicyRequest) Reset()         { *m = SetIamPolicyRequest{} }
+func (m *SetIamPolicyRequest) String() string { return proto.CompactTextString(m) }
+func (*SetIamPolicyRequest) ProtoMessage()    {}
+func (*SetIamPolicyRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_iam_policy_58547b5cf2e9d67a, []int{0}
+}
+func (m *SetIamPolicyRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_SetIamPolicyRequest.Unmarshal(m, b)
+}
+func (m *SetIamPolicyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_SetIamPolicyRequest.Marshal(b, m, deterministic)
+}
+func (dst *SetIamPolicyRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_SetIamPolicyRequest.Merge(dst, src)
+}
+func (m *SetIamPolicyRequest) XXX_Size() int {
+        return xxx_messageInfo_SetIamPolicyRequest.Size(m)
+}
+func (m *SetIamPolicyRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_SetIamPolicyRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetIamPolicyRequest proto.InternalMessageInfo
+
+func (m *SetIamPolicyRequest) GetResource() string {
+        if m != nil {
+                return m.Resource
+        }
+        return ""
+}
+
+func (m *SetIamPolicyRequest) GetPolicy() *Policy {
+        if m != nil {
+                return m.Policy
+        }
+        return nil
+}
+
+// Request message for `GetIamPolicy` method.
+type GetIamPolicyRequest struct {
+        // REQUIRED: The resource for which the policy is being requested.
+        // `resource` is usually specified as a path. For example, a Project
+        // resource is specified as `projects/{project}`.
+        Resource             string   `protobuf:"bytes,1,opt,name=resource,proto3" json:"resource,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetIamPolicyRequest) Reset()         { *m = GetIamPolicyRequest{} }
+func (m *GetIamPolicyRequest) String() string { return proto.CompactTextString(m) }
+func (*GetIamPolicyRequest) ProtoMessage()    {}
+func (*GetIamPolicyRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_iam_policy_58547b5cf2e9d67a, []int{1}
+}
+func (m *GetIamPolicyRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GetIamPolicyRequest.Unmarshal(m, b)
+}
+func (m *GetIamPolicyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GetIamPolicyRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetIamPolicyRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GetIamPolicyRequest.Merge(dst, src)
+}
+func (m *GetIamPolicyRequest) XXX_Size() int {
+        return xxx_messageInfo_GetIamPolicyRequest.Size(m)
+}
+func (m *GetIamPolicyRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_GetIamPolicyRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetIamPolicyRequest proto.InternalMessageInfo
+
+func (m *GetIamPolicyRequest) GetResource() string {
+        if m != nil {
+                return m.Resource
+        }
+        return ""
+}
+
+// Request message for `TestIamPermissions` method.
+type TestIamPermissionsRequest struct {
+        // REQUIRED: The resource for which the policy detail is being requested.
+        // `resource` is usually specified as a path. For example, a Project
+        // resource is specified as `projects/{project}`.
+        Resource string `protobuf:"bytes,1,opt,name=resource,proto3" json:"resource,omitempty"`
+        // The set of permissions to check for the `resource`. Permissions with
+        // wildcards (such as '*' or 'storage.*') are not allowed. For more
+        // information see
+        // [IAM Overview](https://cloud.google.com/iam/docs/overview#permissions).
+        Permissions          []string `protobuf:"bytes,2,rep,name=permissions,proto3" json:"permissions,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *TestIamPermissionsRequest) Reset()         { *m = TestIamPermissionsRequest{} }
+func (m *TestIamPermissionsRequest) String() string { return proto.CompactTextString(m) }
+func (*TestIamPermissionsRequest) ProtoMessage()    {}
+func (*TestIamPermissionsRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_iam_policy_58547b5cf2e9d67a, []int{2}
+}
+func (m *TestIamPermissionsRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_TestIamPermissionsRequest.Unmarshal(m, b)
+}
+func (m *TestIamPermissionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_TestIamPermissionsRequest.Marshal(b, m, deterministic)
+}
+func (dst *TestIamPermissionsRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_TestIamPermissionsRequest.Merge(dst, src)
+}
+func (m *TestIamPermissionsRequest) XXX_Size() int {
+        return xxx_messageInfo_TestIamPermissionsRequest.Size(m)
+}
+func (m *TestIamPermissionsRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_TestIamPermissionsRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TestIamPermissionsRequest proto.InternalMessageInfo
+
+func (m *TestIamPermissionsRequest) GetResource() string {
+        if m != nil {
+                return m.Resource
+        }
+        return ""
+}
+
+func (m *TestIamPermissionsRequest) GetPermissions() []string {
+        if m != nil {
+                return m.Permissions
+        }
+        return nil
+}
+
+// Response message for `TestIamPermissions` method.
+type TestIamPermissionsResponse struct {
+        // A subset of `TestPermissionsRequest.permissions` that the caller is
+        // allowed.
+        Permissions          []string `protobuf:"bytes,1,rep,name=permissions,proto3" json:"permissions,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *TestIamPermissionsResponse) Reset()         { *m = TestIamPermissionsResponse{} }
+func (m *TestIamPermissionsResponse) String() string { return proto.CompactTextString(m) }
+func (*TestIamPermissionsResponse) ProtoMessage()    {}
+func (*TestIamPermissionsResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_iam_policy_58547b5cf2e9d67a, []int{3}
+}
+func (m *TestIamPermissionsResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_TestIamPermissionsResponse.Unmarshal(m, b)
+}
+func (m *TestIamPermissionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_TestIamPermissionsResponse.Marshal(b, m, deterministic)
+}
+func (dst *TestIamPermissionsResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_TestIamPermissionsResponse.Merge(dst, src)
+}
+func (m *TestIamPermissionsResponse) XXX_Size() int {
+        return xxx_messageInfo_TestIamPermissionsResponse.Size(m)
+}
+func (m *TestIamPermissionsResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_TestIamPermissionsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TestIamPermissionsResponse proto.InternalMessageInfo
+
+func (m *TestIamPermissionsResponse) GetPermissions() []string {
+        if m != nil {
+                return m.Permissions
+        }
+        return nil
+}
+
+func init() {
+        proto.RegisterType((*SetIamPolicyRequest)(nil), "google.iam.v1.SetIamPolicyRequest")
+        proto.RegisterType((*GetIamPolicyRequest)(nil), "google.iam.v1.GetIamPolicyRequest")
+        proto.RegisterType((*TestIamPermissionsRequest)(nil), "google.iam.v1.TestIamPermissionsRequest")
+        proto.RegisterType((*TestIamPermissionsResponse)(nil), "google.iam.v1.TestIamPermissionsResponse")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// IAMPolicyClient is the client API for IAMPolicy service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type IAMPolicyClient interface {
+        // Sets the access control policy on the specified resource. Replaces any
+        // existing policy.
+        SetIamPolicy(ctx context.Context, in *SetIamPolicyRequest, opts ...grpc.CallOption) (*Policy, error)
+        // Gets the access control policy for a resource.
+        // Returns an empty policy if the resource exists and does not have a policy
+        // set.
+        GetIamPolicy(ctx context.Context, in *GetIamPolicyRequest, opts ...grpc.CallOption) (*Policy, error)
+        // Returns permissions that a caller has on the specified resource.
+        // If the resource does not exist, this will return an empty set of
+        // permissions, not a NOT_FOUND error.
+        TestIamPermissions(ctx context.Context, in *TestIamPermissionsRequest, opts ...grpc.CallOption) (*TestIamPermissionsResponse, error)
+}
+
+type iAMPolicyClient struct {
+        cc *grpc.ClientConn
+}
+
+func NewIAMPolicyClient(cc *grpc.ClientConn) IAMPolicyClient {
+        return &iAMPolicyClient{cc}
+}
+
+func (c *iAMPolicyClient) SetIamPolicy(ctx context.Context, in *SetIamPolicyRequest, opts ...grpc.CallOption) (*Policy, error) {
+        out := new(Policy)
+        err := c.cc.Invoke(ctx, "/google.iam.v1.IAMPolicy/SetIamPolicy", in, out, opts...)
+        if err != nil {
+                return nil, err
+        }
+        return out, nil
+}
+
+func (c *iAMPolicyClient) GetIamPolicy(ctx context.Context, in *GetIamPolicyRequest, opts ...grpc.CallOption) (*Policy, error) {
+        out := new(Policy)
+        err := c.cc.Invoke(ctx, "/google.iam.v1.IAMPolicy/GetIamPolicy", in, out, opts...)
+        if err != nil {
+                return nil, err
+        }
+        return out, nil
+}
+
+func (c *iAMPolicyClient) TestIamPermissions(ctx context.Context, in *TestIamPermissionsRequest, opts ...grpc.CallOption) (*TestIamPermissionsResponse, error) {
+        out := new(TestIamPermissionsResponse)
+        err := c.cc.Invoke(ctx, "/google.iam.v1.IAMPolicy/TestIamPermissions", in, out, opts...)
+        if err != nil {
+                return nil, err
+        }
+        return out, nil
+}
+
+// IAMPolicyServer is the server API for IAMPolicy service.
+type IAMPolicyServer interface {
+        // Sets the access control policy on the specified resource. Replaces any
+        // existing policy.
+        SetIamPolicy(context.Context, *SetIamPolicyRequest) (*Policy, error)
+        // Gets the access control policy for a resource.
+        // Returns an empty policy if the resource exists and does not have a policy
+        // set.
+        GetIamPolicy(context.Context, *GetIamPolicyRequest) (*Policy, error)
+        // Returns permissions that a caller has on the specified resource.
+        // If the resource does not exist, this will return an empty set of
+        // permissions, not a NOT_FOUND error.
+        TestIamPermissions(context.Context, *TestIamPermissionsRequest) (*TestIamPermissionsResponse, error)
+}
+
+func RegisterIAMPolicyServer(s *grpc.Server, srv IAMPolicyServer) {
+        s.RegisterService(&_IAMPolicy_serviceDesc, srv)
+}
+
+func _IAMPolicy_SetIamPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+        in := new(SetIamPolicyRequest)
+        if err := dec(in); err != nil {
+                return nil, err
+        }
+        if interceptor == nil {
+                return srv.(IAMPolicyServer).SetIamPolicy(ctx, in)
+        }
+        info := &grpc.UnaryServerInfo{
+                Server:     srv,
+                FullMethod: "/google.iam.v1.IAMPolicy/SetIamPolicy",
+        }
+        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+                return srv.(IAMPolicyServer).SetIamPolicy(ctx, req.(*SetIamPolicyRequest))
+        }
+        return interceptor(ctx, in, info, handler)
+}
+
+func _IAMPolicy_GetIamPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+        in := new(GetIamPolicyRequest)
+        if err := dec(in); err != nil {
+                return nil, err
+        }
+        if interceptor == nil {
+                return srv.(IAMPolicyServer).GetIamPolicy(ctx, in)
+        }
+        info := &grpc.UnaryServerInfo{
+                Server:     srv,
+                FullMethod: "/google.iam.v1.IAMPolicy/GetIamPolicy",
+        }
+        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+                return srv.(IAMPolicyServer).GetIamPolicy(ctx, req.(*GetIamPolicyRequest))
+        }
+        return interceptor(ctx, in, info, handler)
+}
+
+func _IAMPolicy_TestIamPermissions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+        in := new(TestIamPermissionsRequest)
+        if err := dec(in); err != nil {
+                return nil, err
+        }
+        if interceptor == nil {
+                return srv.(IAMPolicyServer).TestIamPermissions(ctx, in)
+        }
+        info := &grpc.UnaryServerInfo{
+                Server:     srv,
+                FullMethod: "/google.iam.v1.IAMPolicy/TestIamPermissions",
+        }
+        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+                return srv.(IAMPolicyServer).TestIamPermissions(ctx, req.(*TestIamPermissionsRequest))
+        }
+        return interceptor(ctx, in, info, handler)
+}
+
+var _IAMPolicy_serviceDesc = grpc.ServiceDesc{
+        ServiceName: "google.iam.v1.IAMPolicy",
+        HandlerType: (*IAMPolicyServer)(nil),
+        Methods: []grpc.MethodDesc{
+                {
+                        MethodName: "SetIamPolicy",
+                        Handler:    _IAMPolicy_SetIamPolicy_Handler,
+                },
+                {
+                        MethodName: "GetIamPolicy",
+                        Handler:    _IAMPolicy_GetIamPolicy_Handler,
+                },
+                {
+                        MethodName: "TestIamPermissions",
+                        Handler:    _IAMPolicy_TestIamPermissions_Handler,
+                },
+        },
+        Streams:  []grpc.StreamDesc{},
+        Metadata: "google/iam/v1/iam_policy.proto",
+}
+
+func init() {
+        proto.RegisterFile("google/iam/v1/iam_policy.proto", fileDescriptor_iam_policy_58547b5cf2e9d67a)
+}
+
+var fileDescriptor_iam_policy_58547b5cf2e9d67a = []byte{
+        // 411 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f,
+        0xcf, 0x49, 0xd5, 0xcf, 0x4c, 0xcc, 0xd5, 0x2f, 0x33, 0x04, 0x51, 0xf1, 0x05, 0xf9, 0x39, 0x99,
+        0xc9, 0x95, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0xbc, 0x10, 0x79, 0xbd, 0xcc, 0xc4, 0x5c,
+        0xbd, 0x32, 0x43, 0x29, 0x19, 0xa8, 0xf2, 0xc4, 0x82, 0x4c, 0xfd, 0xc4, 0xbc, 0xbc, 0xfc, 0x92,
+        0xc4, 0x92, 0xcc, 0xfc, 0xbc, 0x62, 0x88, 0x62, 0x29, 0x29, 0x54, 0xc3, 0x90, 0x0d, 0x52, 0x4a,
+        0xe0, 0x12, 0x0e, 0x4e, 0x2d, 0xf1, 0x4c, 0xcc, 0x0d, 0x00, 0x8b, 0x06, 0xa5, 0x16, 0x96, 0xa6,
+        0x16, 0x97, 0x08, 0x49, 0x71, 0x71, 0x14, 0xa5, 0x16, 0xe7, 0x97, 0x16, 0x25, 0xa7, 0x4a, 0x30,
+        0x2a, 0x30, 0x6a, 0x70, 0x06, 0xc1, 0xf9, 0x42, 0xba, 0x5c, 0x6c, 0x10, 0x23, 0x24, 0x98, 0x14,
+        0x18, 0x35, 0xb8, 0x8d, 0x44, 0xf5, 0x50, 0x1c, 0xa3, 0x07, 0x35, 0x09, 0xaa, 0x48, 0xc9, 0x90,
+        0x4b, 0xd8, 0x9d, 0x34, 0x1b, 0x94, 0x22, 0xb9, 0x24, 0x43, 0x52, 0x8b, 0xc1, 0x7a, 0x52, 0x8b,
+        0x72, 0x33, 0x8b, 0x8b, 0x41, 0x9e, 0x21, 0xc6, 0x69, 0x0a, 0x5c, 0xdc, 0x05, 0x08, 0x1d, 0x12,
+        0x4c, 0x0a, 0xcc, 0x1a, 0x9c, 0x41, 0xc8, 0x42, 0x4a, 0x76, 0x5c, 0x52, 0xd8, 0x8c, 0x2e, 0x2e,
+        0xc8, 0xcf, 0x2b, 0xc6, 0xd0, 0xcf, 0x88, 0xa1, 0xdf, 0x68, 0x0a, 0x33, 0x17, 0xa7, 0xa7, 0xa3,
+        0x2f, 0xc4, 0x2f, 0x42, 0x25, 0x5c, 0x3c, 0xc8, 0xa1, 0x27, 0xa4, 0x84, 0x16, 0x14, 0x58, 0x82,
+        0x56, 0x0a, 0x7b, 0x70, 0x29, 0x69, 0x36, 0x5d, 0x7e, 0x32, 0x99, 0x49, 0x59, 0x49, 0x0e, 0x14,
+        0x45, 0xd5, 0x30, 0x1f, 0xd9, 0x6a, 0x69, 0xd5, 0x5a, 0x15, 0x23, 0x99, 0x62, 0xc5, 0xa8, 0x05,
+        0xb2, 0xd5, 0x1d, 0x9f, 0xad, 0xee, 0x54, 0xb1, 0x35, 0x1d, 0xcd, 0xd6, 0x59, 0x8c, 0x5c, 0x42,
+        0x98, 0x41, 0x27, 0xa4, 0x81, 0x66, 0x30, 0xce, 0x88, 0x93, 0xd2, 0x24, 0x42, 0x25, 0x24, 0x1e,
+        0x94, 0xf4, 0xc1, 0xce, 0xd2, 0x54, 0x52, 0xc1, 0x74, 0x56, 0x09, 0x86, 0x2e, 0x2b, 0x46, 0x2d,
+        0xa7, 0x36, 0x46, 0x2e, 0xc1, 0xe4, 0xfc, 0x5c, 0x54, 0x1b, 0x9c, 0xf8, 0xe0, 0x1e, 0x08, 0x00,
+        0x25, 0xf6, 0x00, 0xc6, 0x28, 0x03, 0xa8, 0x82, 0xf4, 0xfc, 0x9c, 0xc4, 0xbc, 0x74, 0xbd, 0xfc,
+        0xa2, 0x74, 0xfd, 0xf4, 0xd4, 0x3c, 0x70, 0x56, 0xd0, 0x87, 0x48, 0x25, 0x16, 0x64, 0x16, 0x43,
+        0x73, 0x8a, 0x75, 0x66, 0x62, 0xee, 0x0f, 0x46, 0xc6, 0x55, 0x4c, 0xc2, 0xee, 0x10, 0x5d, 0xce,
+        0x39, 0xf9, 0xa5, 0x29, 0x7a, 0x9e, 0x89, 0xb9, 0x7a, 0x61, 0x86, 0xa7, 0x60, 0xa2, 0x31, 0x60,
+        0xd1, 0x18, 0xcf, 0xc4, 0xdc, 0x98, 0x30, 0xc3, 0x24, 0x36, 0xb0, 0x59, 0xc6, 0x80, 0x00, 0x00,
+        0x00, 0xff, 0xff, 0xea, 0x62, 0x8f, 0x22, 0xc1, 0x03, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/genproto/googleapis/iam/v1/policy.pb.go b/vendor/google.golang.org/genproto/googleapis/iam/v1/policy.pb.go
new file mode 100644
index 0000000..99dd75f
--- /dev/null
+++ b/vendor/google.golang.org/genproto/googleapis/iam/v1/policy.pb.go
@@ -0,0 +1,366 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/iam/v1/policy.proto
+
+package iam // import "google.golang.org/genproto/googleapis/iam/v1"
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import _ "google.golang.org/genproto/googleapis/api/annotations"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// The type of action performed on a Binding in a policy.
+type BindingDelta_Action int32
+
+const (
+        // Unspecified.
+        BindingDelta_ACTION_UNSPECIFIED BindingDelta_Action = 0
+        // Addition of a Binding.
+        BindingDelta_ADD BindingDelta_Action = 1
+        // Removal of a Binding.
+        BindingDelta_REMOVE BindingDelta_Action = 2
+)
+
+var BindingDelta_Action_name = map[int32]string{
+        0: "ACTION_UNSPECIFIED",
+        1: "ADD",
+        2: "REMOVE",
+}
+var BindingDelta_Action_value = map[string]int32{
+        "ACTION_UNSPECIFIED": 0,
+        "ADD":                1,
+        "REMOVE":             2,
+}
+
+func (x BindingDelta_Action) String() string {
+        return proto.EnumName(BindingDelta_Action_name, int32(x))
+}
+func (BindingDelta_Action) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_policy_6ba2a3dcbcdd909c, []int{3, 0}
+}
+
+// Defines an Identity and Access Management (IAM) policy. It is used to
+// specify access control policies for Cloud Platform resources.
+//
+//
+// A `Policy` consists of a list of `bindings`. A `Binding` binds a list of
+// `members` to a `role`, where the members can be user accounts, Google groups,
+// Google domains, and service accounts. A `role` is a named list of permissions
+// defined by IAM.
+//
+// **Example**
+//
+//     {
+//       "bindings": [
+//         {
+//           "role": "roles/owner",
+//           "members": [
+//             "user:mike@example.com",
+//             "group:admins@example.com",
+//             "domain:google.com",
+//             "serviceAccount:my-other-app@appspot.gserviceaccount.com",
+//           ]
+//         },
+//         {
+//           "role": "roles/viewer",
+//           "members": ["user:sean@example.com"]
+//         }
+//       ]
+//     }
+//
+// For a description of IAM and its features, see the
+// [IAM developer's guide](https://cloud.google.com/iam).
+type Policy struct {
+        // Version of the `Policy`. The default version is 0.
+        Version int32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
+        // Associates a list of `members` to a `role`.
+        // Multiple `bindings` must not be specified for the same `role`.
+        // `bindings` with no members will result in an error.
+        Bindings []*Binding `protobuf:"bytes,4,rep,name=bindings,proto3" json:"bindings,omitempty"`
+        // `etag` is used for optimistic concurrency control as a way to help
+        // prevent simultaneous updates of a policy from overwriting each other.
+        // It is strongly suggested that systems make use of the `etag` in the
+        // read-modify-write cycle to perform policy updates in order to avoid race
+        // conditions: An `etag` is returned in the response to `getIamPolicy`, and
+        // systems are expected to put that etag in the request to `setIamPolicy` to
+        // ensure that their change will be applied to the same version of the policy.
+        //
+        // If no `etag` is provided in the call to `setIamPolicy`, then the existing
+        // policy is overwritten blindly.
+        Etag                 []byte   `protobuf:"bytes,3,opt,name=etag,proto3" json:"etag,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Policy) Reset()         { *m = Policy{} }
+func (m *Policy) String() string { return proto.CompactTextString(m) }
+func (*Policy) ProtoMessage()    {}
+func (*Policy) Descriptor() ([]byte, []int) {
+        return fileDescriptor_policy_6ba2a3dcbcdd909c, []int{0}
+}
+func (m *Policy) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Policy.Unmarshal(m, b)
+}
+func (m *Policy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Policy.Marshal(b, m, deterministic)
+}
+func (dst *Policy) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Policy.Merge(dst, src)
+}
+func (m *Policy) XXX_Size() int {
+        return xxx_messageInfo_Policy.Size(m)
+}
+func (m *Policy) XXX_DiscardUnknown() {
+        xxx_messageInfo_Policy.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Policy proto.InternalMessageInfo
+
+func (m *Policy) GetVersion() int32 {
+        if m != nil {
+                return m.Version
+        }
+        return 0
+}
+
+func (m *Policy) GetBindings() []*Binding {
+        if m != nil {
+                return m.Bindings
+        }
+        return nil
+}
+
+func (m *Policy) GetEtag() []byte {
+        if m != nil {
+                return m.Etag
+        }
+        return nil
+}
+
+// Associates `members` with a `role`.
+type Binding struct {
+        // Role that is assigned to `members`.
+        // For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
+        // Required
+        Role string `protobuf:"bytes,1,opt,name=role,proto3" json:"role,omitempty"`
+        // Specifies the identities requesting access for a Cloud Platform resource.
+        // `members` can have the following values:
+        //
+        // * `allUsers`: A special identifier that represents anyone who is
+        //    on the internet; with or without a Google account.
+        //
+        // * `allAuthenticatedUsers`: A special identifier that represents anyone
+        //    who is authenticated with a Google account or a service account.
+        //
+        // * `user:{emailid}`: An email address that represents a specific Google
+        //    account. For example, `alice@gmail.com` or `joe@example.com`.
+        //
+        //
+        // * `serviceAccount:{emailid}`: An email address that represents a service
+        //    account. For example, `my-other-app@appspot.gserviceaccount.com`.
+        //
+        // * `group:{emailid}`: An email address that represents a Google group.
+        //    For example, `admins@example.com`.
+        //
+        // * `domain:{domain}`: A Google Apps domain name that represents all the
+        //    users of that domain. For example, `google.com` or `example.com`.
+        //
+        //
+        Members              []string `protobuf:"bytes,2,rep,name=members,proto3" json:"members,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Binding) Reset()         { *m = Binding{} }
+func (m *Binding) String() string { return proto.CompactTextString(m) }
+func (*Binding) ProtoMessage()    {}
+func (*Binding) Descriptor() ([]byte, []int) {
+        return fileDescriptor_policy_6ba2a3dcbcdd909c, []int{1}
+}
+func (m *Binding) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Binding.Unmarshal(m, b)
+}
+func (m *Binding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Binding.Marshal(b, m, deterministic)
+}
+func (dst *Binding) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Binding.Merge(dst, src)
+}
+func (m *Binding) XXX_Size() int {
+        return xxx_messageInfo_Binding.Size(m)
+}
+func (m *Binding) XXX_DiscardUnknown() {
+        xxx_messageInfo_Binding.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Binding proto.InternalMessageInfo
+
+func (m *Binding) GetRole() string {
+        if m != nil {
+                return m.Role
+        }
+        return ""
+}
+
+func (m *Binding) GetMembers() []string {
+        if m != nil {
+                return m.Members
+        }
+        return nil
+}
+
+// The difference delta between two policies.
+type PolicyDelta struct {
+        // The delta for Bindings between two policies.
+        BindingDeltas        []*BindingDelta `protobuf:"bytes,1,rep,name=binding_deltas,json=bindingDeltas,proto3" json:"binding_deltas,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+        XXX_unrecognized     []byte          `json:"-"`
+        XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *PolicyDelta) Reset()         { *m = PolicyDelta{} }
+func (m *PolicyDelta) String() string { return proto.CompactTextString(m) }
+func (*PolicyDelta) ProtoMessage()    {}
+func (*PolicyDelta) Descriptor() ([]byte, []int) {
+        return fileDescriptor_policy_6ba2a3dcbcdd909c, []int{2}
+}
+func (m *PolicyDelta) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_PolicyDelta.Unmarshal(m, b)
+}
+func (m *PolicyDelta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_PolicyDelta.Marshal(b, m, deterministic)
+}
+func (dst *PolicyDelta) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_PolicyDelta.Merge(dst, src)
+}
+func (m *PolicyDelta) XXX_Size() int {
+        return xxx_messageInfo_PolicyDelta.Size(m)
+}
+func (m *PolicyDelta) XXX_DiscardUnknown() {
+        xxx_messageInfo_PolicyDelta.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PolicyDelta proto.InternalMessageInfo
+
+func (m *PolicyDelta) GetBindingDeltas() []*BindingDelta {
+        if m != nil {
+                return m.BindingDeltas
+        }
+        return nil
+}
+
+// One delta entry for Binding. Each individual change (only one member in each
+// entry) to a binding will be a separate entry.
+type BindingDelta struct {
+        // The action that was performed on a Binding.
+        // Required
+        Action BindingDelta_Action `protobuf:"varint,1,opt,name=action,proto3,enum=google.iam.v1.BindingDelta_Action" json:"action,omitempty"`
+        // Role that is assigned to `members`.
+        // For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
+        // Required
+        Role string `protobuf:"bytes,2,opt,name=role,proto3" json:"role,omitempty"`
+        // A single identity requesting access for a Cloud Platform resource.
+        // Follows the same format of Binding.members.
+        // Required
+        Member               string   `protobuf:"bytes,3,opt,name=member,proto3" json:"member,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *BindingDelta) Reset()         { *m = BindingDelta{} }
+func (m *BindingDelta) String() string { return proto.CompactTextString(m) }
+func (*BindingDelta) ProtoMessage()    {}
+func (*BindingDelta) Descriptor() ([]byte, []int) {
+        return fileDescriptor_policy_6ba2a3dcbcdd909c, []int{3}
+}
+func (m *BindingDelta) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_BindingDelta.Unmarshal(m, b)
+}
+func (m *BindingDelta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_BindingDelta.Marshal(b, m, deterministic)
+}
+func (dst *BindingDelta) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_BindingDelta.Merge(dst, src)
+}
+func (m *BindingDelta) XXX_Size() int {
+        return xxx_messageInfo_BindingDelta.Size(m)
+}
+func (m *BindingDelta) XXX_DiscardUnknown() {
+        xxx_messageInfo_BindingDelta.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BindingDelta proto.InternalMessageInfo
+
+func (m *BindingDelta) GetAction() BindingDelta_Action {
+        if m != nil {
+                return m.Action
+        }
+        return BindingDelta_ACTION_UNSPECIFIED
+}
+
+func (m *BindingDelta) GetRole() string {
+        if m != nil {
+                return m.Role
+        }
+        return ""
+}
+
+func (m *BindingDelta) GetMember() string {
+        if m != nil {
+                return m.Member
+        }
+        return ""
+}
+
+func init() {
+        proto.RegisterType((*Policy)(nil), "google.iam.v1.Policy")
+        proto.RegisterType((*Binding)(nil), "google.iam.v1.Binding")
+        proto.RegisterType((*PolicyDelta)(nil), "google.iam.v1.PolicyDelta")
+        proto.RegisterType((*BindingDelta)(nil), "google.iam.v1.BindingDelta")
+        proto.RegisterEnum("google.iam.v1.BindingDelta_Action", BindingDelta_Action_name, BindingDelta_Action_value)
+}
+
+func init() { proto.RegisterFile("google/iam/v1/policy.proto", fileDescriptor_policy_6ba2a3dcbcdd909c) }
+
+var fileDescriptor_policy_6ba2a3dcbcdd909c = []byte{
+        // 403 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x52, 0x4d, 0xab, 0x13, 0x31,
+        0x14, 0x35, 0xed, 0x73, 0x6a, 0xef, 0xfb, 0xa0, 0x46, 0x28, 0xc3, 0xd3, 0x45, 0x99, 0x55, 0x57,
+        0x19, 0x5b, 0x11, 0x41, 0x57, 0xfd, 0x18, 0x65, 0x16, 0xbe, 0x37, 0x46, 0xed, 0x42, 0x0a, 0x8f,
+        0x4c, 0x1b, 0x42, 0x64, 0x92, 0x0c, 0x33, 0x63, 0xc1, 0xb5, 0xff, 0x46, 0xf0, 0x8f, 0xf8, 0x8b,
+        0x5c, 0xca, 0x24, 0x99, 0x47, 0x0b, 0xe2, 0x2e, 0xe7, 0x9e, 0x73, 0x72, 0xcf, 0xcd, 0x0d, 0x5c,
+        0x0b, 0x63, 0x44, 0xc1, 0x63, 0xc9, 0x54, 0x7c, 0x98, 0xc5, 0xa5, 0x29, 0xe4, 0xee, 0x3b, 0x29,
+        0x2b, 0xd3, 0x18, 0x7c, 0xe9, 0x38, 0x22, 0x99, 0x22, 0x87, 0xd9, 0xf5, 0x33, 0x2f, 0x65, 0xa5,
+        0x8c, 0x99, 0xd6, 0xa6, 0x61, 0x8d, 0x34, 0xba, 0x76, 0xe2, 0xe8, 0x2b, 0x04, 0x99, 0x35, 0xe3,
+        0x10, 0x06, 0x07, 0x5e, 0xd5, 0xd2, 0xe8, 0x10, 0x4d, 0xd0, 0xf4, 0x21, 0xed, 0x20, 0x9e, 0xc3,
+        0xa3, 0x5c, 0xea, 0xbd, 0xd4, 0xa2, 0x0e, 0xcf, 0x26, 0xfd, 0xe9, 0xf9, 0x7c, 0x4c, 0x4e, 0x7a,
+        0x90, 0xa5, 0xa3, 0xe9, 0xbd, 0x0e, 0x63, 0x38, 0xe3, 0x0d, 0x13, 0x61, 0x7f, 0x82, 0xa6, 0x17,
+        0xd4, 0x9e, 0xa3, 0x57, 0x30, 0xf0, 0xc2, 0x96, 0xae, 0x4c, 0xc1, 0x6d, 0xa7, 0x21, 0xb5, 0xe7,
+        0x36, 0x80, 0xe2, 0x2a, 0xe7, 0x55, 0x1d, 0xf6, 0x26, 0xfd, 0xe9, 0x90, 0x76, 0x30, 0xfa, 0x00,
+        0xe7, 0x2e, 0xe4, 0x9a, 0x17, 0x0d, 0xc3, 0x4b, 0xb8, 0xf2, 0x7d, 0xee, 0xf6, 0x6d, 0xa1, 0x0e,
+        0x91, 0x4d, 0xf5, 0xf4, 0xdf, 0xa9, 0xac, 0x89, 0x5e, 0xe6, 0x47, 0xa8, 0x8e, 0x7e, 0x21, 0xb8,
+        0x38, 0xe6, 0xf1, 0x6b, 0x08, 0xd8, 0xae, 0xe9, 0xa6, 0xbf, 0x9a, 0x47, 0xff, 0xb9, 0x8c, 0x2c,
+        0xac, 0x92, 0x7a, 0xc7, 0xfd, 0x34, 0xbd, 0xa3, 0x69, 0xc6, 0x10, 0xb8, 0xf8, 0xf6, 0x09, 0x86,
+        0xd4, 0xa3, 0xe8, 0x25, 0x04, 0xce, 0x8d, 0xc7, 0x80, 0x17, 0xab, 0x4f, 0xe9, 0xed, 0xcd, 0xdd,
+        0xe7, 0x9b, 0x8f, 0x59, 0xb2, 0x4a, 0xdf, 0xa6, 0xc9, 0x7a, 0xf4, 0x00, 0x0f, 0xa0, 0xbf, 0x58,
+        0xaf, 0x47, 0x08, 0x03, 0x04, 0x34, 0x79, 0x7f, 0xbb, 0x49, 0x46, 0xbd, 0xe5, 0x0f, 0x04, 0x8f,
+        0x77, 0x46, 0x9d, 0x86, 0x5a, 0xfa, 0x67, 0xc9, 0xda, 0x55, 0x66, 0xe8, 0xcb, 0x73, 0xcf, 0x0a,
+        0x53, 0x30, 0x2d, 0x88, 0xa9, 0x44, 0x2c, 0xb8, 0xb6, 0x8b, 0x8e, 0x1d, 0xc5, 0x4a, 0x59, 0xfb,
+        0x4f, 0xf3, 0x46, 0x32, 0xf5, 0x07, 0xa1, 0x9f, 0xbd, 0x27, 0xef, 0x9c, 0x6b, 0x55, 0x98, 0x6f,
+        0x7b, 0x92, 0x32, 0x45, 0x36, 0xb3, 0xdf, 0x5d, 0x75, 0x6b, 0xab, 0xdb, 0x94, 0xa9, 0xed, 0x66,
+        0x96, 0x07, 0xf6, 0xae, 0x17, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xfc, 0x18, 0xca, 0xaa, 0x7f,
+        0x02, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/genproto/googleapis/rpc/code/code.pb.go b/vendor/google.golang.org/genproto/googleapis/rpc/code/code.pb.go
new file mode 100644
index 0000000..410e374
--- /dev/null
+++ b/vendor/google.golang.org/genproto/googleapis/rpc/code/code.pb.go
@@ -0,0 +1,246 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/rpc/code.proto
+
+package code // import "google.golang.org/genproto/googleapis/rpc/code"
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// The canonical error codes for Google APIs.
+//
+//
+// Sometimes multiple error codes may apply.  Services should return
+// the most specific error code that applies.  For example, prefer
+// `OUT_OF_RANGE` over `FAILED_PRECONDITION` if both codes apply.
+// Similarly prefer `NOT_FOUND` or `ALREADY_EXISTS` over `FAILED_PRECONDITION`.
+type Code int32
+
+const (
+        // Not an error; returned on success
+        //
+        // HTTP Mapping: 200 OK
+        Code_OK Code = 0
+        // The operation was cancelled, typically by the caller.
+        //
+        // HTTP Mapping: 499 Client Closed Request
+        Code_CANCELLED Code = 1
+        // Unknown error.  For example, this error may be returned when
+        // a `Status` value received from another address space belongs to
+        // an error space that is not known in this address space.  Also
+        // errors raised by APIs that do not return enough error information
+        // may be converted to this error.
+        //
+        // HTTP Mapping: 500 Internal Server Error
+        Code_UNKNOWN Code = 2
+        // The client specified an invalid argument.  Note that this differs
+        // from `FAILED_PRECONDITION`.  `INVALID_ARGUMENT` indicates arguments
+        // that are problematic regardless of the state of the system
+        // (e.g., a malformed file name).
+        //
+        // HTTP Mapping: 400 Bad Request
+        Code_INVALID_ARGUMENT Code = 3
+        // The deadline expired before the operation could complete. For operations
+        // that change the state of the system, this error may be returned
+        // even if the operation has completed successfully.  For example, a
+        // successful response from a server could have been delayed long
+        // enough for the deadline to expire.
+        //
+        // HTTP Mapping: 504 Gateway Timeout
+        Code_DEADLINE_EXCEEDED Code = 4
+        // Some requested entity (e.g., file or directory) was not found.
+        //
+        // Note to server developers: if a request is denied for an entire class
+        // of users, such as gradual feature rollout or undocumented whitelist,
+        // `NOT_FOUND` may be used. If a request is denied for some users within
+        // a class of users, such as user-based access control, `PERMISSION_DENIED`
+        // must be used.
+        //
+        // HTTP Mapping: 404 Not Found
+        Code_NOT_FOUND Code = 5
+        // The entity that a client attempted to create (e.g., file or directory)
+        // already exists.
+        //
+        // HTTP Mapping: 409 Conflict
+        Code_ALREADY_EXISTS Code = 6
+        // The caller does not have permission to execute the specified
+        // operation. `PERMISSION_DENIED` must not be used for rejections
+        // caused by exhausting some resource (use `RESOURCE_EXHAUSTED`
+        // instead for those errors). `PERMISSION_DENIED` must not be
+        // used if the caller can not be identified (use `UNAUTHENTICATED`
+        // instead for those errors). This error code does not imply the
+        // request is valid or the requested entity exists or satisfies
+        // other pre-conditions.
+        //
+        // HTTP Mapping: 403 Forbidden
+        Code_PERMISSION_DENIED Code = 7
+        // The request does not have valid authentication credentials for the
+        // operation.
+        //
+        // HTTP Mapping: 401 Unauthorized
+        Code_UNAUTHENTICATED Code = 16
+        // Some resource has been exhausted, perhaps a per-user quota, or
+        // perhaps the entire file system is out of space.
+        //
+        // HTTP Mapping: 429 Too Many Requests
+        Code_RESOURCE_EXHAUSTED Code = 8
+        // The operation was rejected because the system is not in a state
+        // required for the operation's execution.  For example, the directory
+        // to be deleted is non-empty, an rmdir operation is applied to
+        // a non-directory, etc.
+        //
+        // Service implementors can use the following guidelines to decide
+        // between `FAILED_PRECONDITION`, `ABORTED`, and `UNAVAILABLE`:
+        //  (a) Use `UNAVAILABLE` if the client can retry just the failing call.
+        //  (b) Use `ABORTED` if the client should retry at a higher level
+        //      (e.g., when a client-specified test-and-set fails, indicating the
+        //      client should restart a read-modify-write sequence).
+        //  (c) Use `FAILED_PRECONDITION` if the client should not retry until
+        //      the system state has been explicitly fixed.  E.g., if an "rmdir"
+        //      fails because the directory is non-empty, `FAILED_PRECONDITION`
+        //      should be returned since the client should not retry unless
+        //      the files are deleted from the directory.
+        //
+        // HTTP Mapping: 400 Bad Request
+        Code_FAILED_PRECONDITION Code = 9
+        // The operation was aborted, typically due to a concurrency issue such as
+        // a sequencer check failure or transaction abort.
+        //
+        // See the guidelines above for deciding between `FAILED_PRECONDITION`,
+        // `ABORTED`, and `UNAVAILABLE`.
+        //
+        // HTTP Mapping: 409 Conflict
+        Code_ABORTED Code = 10
+        // The operation was attempted past the valid range.  E.g., seeking or
+        // reading past end-of-file.
+        //
+        // Unlike `INVALID_ARGUMENT`, this error indicates a problem that may
+        // be fixed if the system state changes. For example, a 32-bit file
+        // system will generate `INVALID_ARGUMENT` if asked to read at an
+        // offset that is not in the range [0,2^32-1], but it will generate
+        // `OUT_OF_RANGE` if asked to read from an offset past the current
+        // file size.
+        //
+        // There is a fair bit of overlap between `FAILED_PRECONDITION` and
+        // `OUT_OF_RANGE`.  We recommend using `OUT_OF_RANGE` (the more specific
+        // error) when it applies so that callers who are iterating through
+        // a space can easily look for an `OUT_OF_RANGE` error to detect when
+        // they are done.
+        //
+        // HTTP Mapping: 400 Bad Request
+        Code_OUT_OF_RANGE Code = 11
+        // The operation is not implemented or is not supported/enabled in this
+        // service.
+        //
+        // HTTP Mapping: 501 Not Implemented
+        Code_UNIMPLEMENTED Code = 12
+        // Internal errors.  This means that some invariants expected by the
+        // underlying system have been broken.  This error code is reserved
+        // for serious errors.
+        //
+        // HTTP Mapping: 500 Internal Server Error
+        Code_INTERNAL Code = 13
+        // The service is currently unavailable.  This is most likely a
+        // transient condition, which can be corrected by retrying with
+        // a backoff.
+        //
+        // See the guidelines above for deciding between `FAILED_PRECONDITION`,
+        // `ABORTED`, and `UNAVAILABLE`.
+        //
+        // HTTP Mapping: 503 Service Unavailable
+        Code_UNAVAILABLE Code = 14
+        // Unrecoverable data loss or corruption.
+        //
+        // HTTP Mapping: 500 Internal Server Error
+        Code_DATA_LOSS Code = 15
+)
+
+var Code_name = map[int32]string{
+        0:  "OK",
+        1:  "CANCELLED",
+        2:  "UNKNOWN",
+        3:  "INVALID_ARGUMENT",
+        4:  "DEADLINE_EXCEEDED",
+        5:  "NOT_FOUND",
+        6:  "ALREADY_EXISTS",
+        7:  "PERMISSION_DENIED",
+        16: "UNAUTHENTICATED",
+        8:  "RESOURCE_EXHAUSTED",
+        9:  "FAILED_PRECONDITION",
+        10: "ABORTED",
+        11: "OUT_OF_RANGE",
+        12: "UNIMPLEMENTED",
+        13: "INTERNAL",
+        14: "UNAVAILABLE",
+        15: "DATA_LOSS",
+}
+var Code_value = map[string]int32{
+        "OK":                  0,
+        "CANCELLED":           1,
+        "UNKNOWN":             2,
+        "INVALID_ARGUMENT":    3,
+        "DEADLINE_EXCEEDED":   4,
+        "NOT_FOUND":           5,
+        "ALREADY_EXISTS":      6,
+        "PERMISSION_DENIED":   7,
+        "UNAUTHENTICATED":     16,
+        "RESOURCE_EXHAUSTED":  8,
+        "FAILED_PRECONDITION": 9,
+        "ABORTED":             10,
+        "OUT_OF_RANGE":        11,
+        "UNIMPLEMENTED":       12,
+        "INTERNAL":            13,
+        "UNAVAILABLE":         14,
+        "DATA_LOSS":           15,
+}
+
+func (x Code) String() string {
+        return proto.EnumName(Code_name, int32(x))
+}
+func (Code) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_code_932ba152e0df0902, []int{0}
+}
+
+func init() {
+        proto.RegisterEnum("google.rpc.Code", Code_name, Code_value)
+}
+
+func init() { proto.RegisterFile("google/rpc/code.proto", fileDescriptor_code_932ba152e0df0902) }
+
+var fileDescriptor_code_932ba152e0df0902 = []byte{
+        // 362 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x44, 0x51, 0xcd, 0x6e, 0x93, 0x31,
+        0x10, 0xa4, 0x69, 0x49, 0x9b, 0xcd, 0xdf, 0xd6, 0xa5, 0xf0, 0x0e, 0x1c, 0x92, 0x43, 0x8f, 0x9c,
+        0x36, 0x9f, 0x37, 0xad, 0x55, 0x67, 0xfd, 0xc9, 0x3f, 0x25, 0x70, 0xb1, 0x4a, 0x1a, 0x7d, 0x42,
+        0x2a, 0x75, 0xf4, 0xc1, 0x13, 0xf1, 0x12, 0xbc, 0x1e, 0x72, 0x8b, 0xe8, 0xc5, 0x87, 0x99, 0xf1,
+        0xee, 0xce, 0x0c, 0x5c, 0x76, 0xa5, 0x74, 0x8f, 0xfb, 0x65, 0x7f, 0xd8, 0x2d, 0x77, 0xe5, 0x61,
+        0xbf, 0x38, 0xf4, 0xe5, 0x57, 0x51, 0xf0, 0x02, 0x2f, 0xfa, 0xc3, 0xee, 0xe3, 0x9f, 0x01, 0x9c,
+        0x34, 0xe5, 0x61, 0xaf, 0x86, 0x30, 0x70, 0xb7, 0xf8, 0x46, 0x4d, 0x61, 0xd4, 0x90, 0x34, 0x6c,
+        0x2d, 0x6b, 0x3c, 0x52, 0x63, 0x38, 0x4d, 0x72, 0x2b, 0xee, 0xb3, 0xe0, 0x40, 0xbd, 0x03, 0x34,
+        0x72, 0x47, 0xd6, 0xe8, 0x4c, 0xfe, 0x3a, 0x6d, 0x58, 0x22, 0x1e, 0xab, 0x4b, 0x38, 0xd7, 0x4c,
+        0xda, 0x1a, 0xe1, 0xcc, 0xdb, 0x86, 0x59, 0xb3, 0xc6, 0x93, 0x3a, 0x48, 0x5c, 0xcc, 0x6b, 0x97,
+        0x44, 0xe3, 0x5b, 0xa5, 0x60, 0x46, 0xd6, 0x33, 0xe9, 0x2f, 0x99, 0xb7, 0x26, 0xc4, 0x80, 0xc3,
+        0xfa, 0xb3, 0x65, 0xbf, 0x31, 0x21, 0x18, 0x27, 0x59, 0xb3, 0x18, 0xd6, 0x78, 0xaa, 0x2e, 0x60,
+        0x9e, 0x84, 0x52, 0xbc, 0x61, 0x89, 0xa6, 0xa1, 0xc8, 0x1a, 0x51, 0xbd, 0x07, 0xe5, 0x39, 0xb8,
+        0xe4, 0x9b, 0xba, 0xe5, 0x86, 0x52, 0xa8, 0xf8, 0x99, 0xfa, 0x00, 0x17, 0x6b, 0x32, 0x96, 0x75,
+        0x6e, 0x3d, 0x37, 0x4e, 0xb4, 0x89, 0xc6, 0x09, 0x8e, 0xea, 0xe5, 0xb4, 0x72, 0xbe, 0xaa, 0x40,
+        0x21, 0x4c, 0x5c, 0x8a, 0xd9, 0xad, 0xb3, 0x27, 0xb9, 0x66, 0x1c, 0xab, 0x73, 0x98, 0x26, 0x31,
+        0x9b, 0xd6, 0x72, 0xb5, 0xc1, 0x1a, 0x27, 0x6a, 0x02, 0x67, 0x46, 0x22, 0x7b, 0x21, 0x8b, 0x53,
+        0x35, 0x87, 0x71, 0x12, 0xba, 0x23, 0x63, 0x69, 0x65, 0x19, 0x67, 0xd5, 0x90, 0xa6, 0x48, 0xd9,
+        0xba, 0x10, 0x70, 0xbe, 0xda, 0xc2, 0x6c, 0x57, 0x7e, 0x2c, 0x5e, 0xb3, 0x5c, 0x8d, 0x6a, 0x90,
+        0x6d, 0x8d, 0xb8, 0x3d, 0xfa, 0x7a, 0xf5, 0x8f, 0xe8, 0xca, 0xe3, 0xfd, 0x53, 0xb7, 0x28, 0x7d,
+        0xb7, 0xec, 0xf6, 0x4f, 0xcf, 0x05, 0x2c, 0x5f, 0xa8, 0xfb, 0xc3, 0xf7, 0x9f, 0xff, 0xab, 0xf9,
+        0x54, 0x9f, 0xdf, 0x83, 0x63, 0xdf, 0x36, 0xdf, 0x86, 0xcf, 0xaa, 0xab, 0xbf, 0x01, 0x00, 0x00,
+        0xff, 0xff, 0x8e, 0x97, 0x77, 0xc2, 0xbf, 0x01, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/genproto/googleapis/rpc/status/status.pb.go b/vendor/google.golang.org/genproto/googleapis/rpc/status/status.pb.go
index 8867ae7..7bfe37a 100644
--- a/vendor/google.golang.org/genproto/googleapis/rpc/status/status.pb.go
+++ b/vendor/google.golang.org/genproto/googleapis/rpc/status/status.pb.go
@@ -1,21 +1,12 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: google/rpc/status.proto
 
-/*
-Package status is a generated protocol buffer package.
-
-It is generated from these files:
-        google/rpc/status.proto
-
-It has these top-level messages:
-        Status
-*/
-package status
+package status // import "google.golang.org/genproto/googleapis/rpc/status"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
 import math "math"
-import google_protobuf "github.com/golang/protobuf/ptypes/any"
+import any "github.com/golang/protobuf/ptypes/any"
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
@@ -82,20 +73,42 @@ const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 //     be used directly after any stripping needed for security/privacy reasons.
 type Status struct {
         // The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code].
-        Code int32 `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
+        Code int32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
         // A developer-facing error message, which should be in English. Any
         // user-facing error message should be localized and sent in the
         // [google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client.
-        Message string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
+        Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
         // A list of messages that carry the error details.  There is a common set of
         // message types for APIs to use.
-        Details []*google_protobuf.Any `protobuf:"bytes,3,rep,name=details" json:"details,omitempty"`
+        Details              []*any.Any `protobuf:"bytes,3,rep,name=details,proto3" json:"details,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}   `json:"-"`
+        XXX_unrecognized     []byte     `json:"-"`
+        XXX_sizecache        int32      `json:"-"`
+}
+
+func (m *Status) Reset()         { *m = Status{} }
+func (m *Status) String() string { return proto.CompactTextString(m) }
+func (*Status) ProtoMessage()    {}
+func (*Status) Descriptor() ([]byte, []int) {
+        return fileDescriptor_status_c6e4de62dcdf2edf, []int{0}
+}
+func (m *Status) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Status.Unmarshal(m, b)
+}
+func (m *Status) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Status.Marshal(b, m, deterministic)
+}
+func (dst *Status) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Status.Merge(dst, src)
+}
+func (m *Status) XXX_Size() int {
+        return xxx_messageInfo_Status.Size(m)
+}
+func (m *Status) XXX_DiscardUnknown() {
+        xxx_messageInfo_Status.DiscardUnknown(m)
 }
 
-func (m *Status) Reset()                    { *m = Status{} }
-func (m *Status) String() string            { return proto.CompactTextString(m) }
-func (*Status) ProtoMessage()               {}
-func (*Status) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+var xxx_messageInfo_Status proto.InternalMessageInfo
 
 func (m *Status) GetCode() int32 {
         if m != nil {
@@ -111,7 +124,7 @@ func (m *Status) GetMessage() string {
         return ""
 }
 
-func (m *Status) GetDetails() []*google_protobuf.Any {
+func (m *Status) GetDetails() []*any.Any {
         if m != nil {
                 return m.Details
         }
@@ -122,9 +135,9 @@ func init() {
         proto.RegisterType((*Status)(nil), "google.rpc.Status")
 }
 
-func init() { proto.RegisterFile("google/rpc/status.proto", fileDescriptor0) }
+func init() { proto.RegisterFile("google/rpc/status.proto", fileDescriptor_status_c6e4de62dcdf2edf) }
 
-var fileDescriptor0 = []byte{
+var fileDescriptor_status_c6e4de62dcdf2edf = []byte{
         // 209 bytes of a gzipped FileDescriptorProto
         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x4f, 0xcf, 0xcf, 0x4f,
         0xcf, 0x49, 0xd5, 0x2f, 0x2a, 0x48, 0xd6, 0x2f, 0x2e, 0x49, 0x2c, 0x29, 0x2d, 0xd6, 0x2b, 0x28,
diff --git a/vendor/google.golang.org/grpc/.travis.yml b/vendor/google.golang.org/grpc/.travis.yml
index 88a785d..f443eec 100644
--- a/vendor/google.golang.org/grpc/.travis.yml
+++ b/vendor/google.golang.org/grpc/.travis.yml
@@ -1,21 +1,37 @@
 language: go
 
-go:
-  - 1.6.x
-  - 1.7.x
-  - 1.8.x
+matrix:
+  include:
+  - go: 1.11.x
+    env: VET=1 GO111MODULE=on
+  - go: 1.11.x
+    env: RACE=1 GO111MODULE=on
+  - go: 1.11.x
+    env: RUN386=1
+  - go: 1.11.x
+    env: GRPC_GO_RETRY=on
+  - go: 1.10.x
+  - go: 1.9.x
+  - go: 1.9.x
+    env: GAE=1
 
 go_import_path: google.golang.org/grpc
 
 before_install:
-  - if [[ $TRAVIS_GO_VERSION = 1.8* ]]; then go get -u github.com/golang/lint/golint honnef.co/go/tools/cmd/staticcheck; fi
-  - go get -u golang.org/x/tools/cmd/goimports github.com/axw/gocov/gocov github.com/mattn/goveralls golang.org/x/tools/cmd/cover
+  - if [[ "${GO111MODULE}" = "on" ]]; then mkdir "${HOME}/go"; export GOPATH="${HOME}/go"; fi
+  - if [[ -n "${RUN386}" ]]; then export GOARCH=386; fi
+  - if [[ "${TRAVIS_EVENT_TYPE}" = "cron" && -z "${RUN386}" ]]; then RACE=1; fi
+  - if [[ "${TRAVIS_EVENT_TYPE}" != "cron" ]]; then VET_SKIP_PROTO=1; fi
+
+install:
+  - try3() { eval "$*" || eval "$*" || eval "$*"; }
+  - try3 'if [[ "${GO111MODULE}" = "on" ]]; then go mod download; else make testdeps; fi'
+  - if [[ "${GAE}" = 1 ]]; then source ./install_gae.sh; make testappenginedeps; fi
+  - if [[ "${VET}" = 1 ]]; then ./vet.sh -install; fi
 
 script:
-  - 'set -o pipefail && git ls-files "*.go" | xargs grep -L "\(Copyright [0-9]\{4,\} gRPC authors\)\|DO NOT EDIT" 2>&1 | tee /dev/stderr | (! read)'
-  - 'set -o pipefail && gofmt -s -d -l . 2>&1 | tee /dev/stderr | (! read)'
-  - 'set -o pipefail && goimports -l . 2>&1 | tee /dev/stderr | (! read)'
-  - 'if [[ $TRAVIS_GO_VERSION = 1.8* ]]; then ! golint ./... | grep -vE "(_mock|_string|\.pb)\.go:"; fi'
-  - 'if [[ $TRAVIS_GO_VERSION = 1.8* ]]; then ! go tool vet -all . 2>&1 | grep -vF .pb.go:; fi' # https://github.com/golang/protobuf/issues/214
-  - make test testrace
-  - 'if [[ $TRAVIS_GO_VERSION = 1.8* ]]; then staticcheck -ignore google.golang.org/grpc/transport/transport_test.go:SA2002 ./...; fi' # TODO(menghanl): fix these
+  - set -e
+  - if [[ "${VET}" = 1 ]]; then ./vet.sh; fi
+  - if [[ "${GAE}" = 1 ]]; then make testappengine; exit 0; fi
+  - if [[ "${RACE}" = 1 ]]; then make testrace; exit 0; fi
+  - make test
diff --git a/vendor/google.golang.org/grpc/CONTRIBUTING.md b/vendor/google.golang.org/grpc/CONTRIBUTING.md
index a5c6e06..0863eb2 100644
--- a/vendor/google.golang.org/grpc/CONTRIBUTING.md
+++ b/vendor/google.golang.org/grpc/CONTRIBUTING.md
@@ -7,7 +7,7 @@ If you are new to github, please start by reading [Pull Request howto](https://h
 ## Legal requirements
 
 In order to protect both you and ourselves, you will need to sign the
-[Contributor License Agreement](https://cla.developers.google.com/clas).
+[Contributor License Agreement](https://identity.linuxfoundation.org/projects/cncf).
 
 ## Guidelines for Pull Requests
 How to get your contributions merged smoothly and quickly.
@@ -27,6 +27,10 @@ How to get your contributions merged smoothly and quickly.
 - Keep your PR up to date with upstream/master (if there are merge conflicts, we can't really merge your change).
  
 - **All tests need to be passing** before your change can be merged. We recommend you **run tests locally** before creating your PR to catch breakages early on.
+  - `make all` to test everything, OR
+  - `make vet` to catch vet errors
+  - `make test` to run the tests
+  - `make testrace` to run tests in race mode
 
 - Exceptions to the rules can be made if there's a compelling reason for doing so.
  
diff --git a/vendor/google.golang.org/grpc/Makefile b/vendor/google.golang.org/grpc/Makefile
index 03bb01f..41a754f 100644
--- a/vendor/google.golang.org/grpc/Makefile
+++ b/vendor/google.golang.org/grpc/Makefile
@@ -1,52 +1,60 @@
-all: test testrace
-
-deps:
-        go get -d -v google.golang.org/grpc/...
-
-updatedeps:
-        go get -d -v -u -f google.golang.org/grpc/...
-
-testdeps:
-        go get -d -v -t google.golang.org/grpc/...
-
-updatetestdeps:
-        go get -d -v -t -u -f google.golang.org/grpc/...
+all: vet test testrace testappengine
 
 build: deps
         go build google.golang.org/grpc/...
 
+clean:
+        go clean -i google.golang.org/grpc/...
+
+deps:
+        go get -d -v google.golang.org/grpc/...
+
 proto:
         @ if ! which protoc > /dev/null; then \
                 echo "error: protoc not installed" >&2; \
                 exit 1; \
         fi
-        go get -u -v github.com/golang/protobuf/protoc-gen-go
-        # use $$dir as the root for all proto files in the same directory
-        for dir in $$(git ls-files '*.proto' | xargs -n1 dirname | uniq); do \
-                protoc -I $$dir --go_out=plugins=grpc:$$dir $$dir/*.proto; \
-        done
+        go generate google.golang.org/grpc/...
 
 test: testdeps
-        go test -v -cpu 1,4 google.golang.org/grpc/...
+        go test -cpu 1,4 -timeout 7m google.golang.org/grpc/...
+
+testappengine: testappenginedeps
+        goapp test -cpu 1,4 -timeout 7m google.golang.org/grpc/...
+
+testappenginedeps:
+        goapp get -d -v -t -tags 'appengine appenginevm' google.golang.org/grpc/...
+
+testdeps:
+        go get -d -v -t google.golang.org/grpc/...
 
 testrace: testdeps
-        go test -v -race -cpu 1,4 google.golang.org/grpc/...
+        go test -race -cpu 1,4 -timeout 7m google.golang.org/grpc/...
 
-clean:
-        go clean -i google.golang.org/grpc/...
+updatedeps:
+        go get -d -v -u -f google.golang.org/grpc/...
+
+updatetestdeps:
+        go get -d -v -t -u -f google.golang.org/grpc/...
+
+vet: vetdeps
+        ./vet.sh
 
-coverage: testdeps
-        ./coverage.sh --coveralls
+vetdeps:
+        ./vet.sh -install
 
 .PHONY: \
         all \
-        deps \
-        updatedeps \
-        testdeps \
-        updatetestdeps \
         build \
+        clean \
+        deps \
         proto \
         test \
+        testappengine \
+        testappenginedeps \
+        testdeps \
         testrace \
-        clean \
-        coverage
+        updatedeps \
+        updatetestdeps \
+        vet \
+        vetdeps
diff --git a/vendor/google.golang.org/grpc/README.md b/vendor/google.golang.org/grpc/README.md
index 72c7325..e3fb3c7 100644
--- a/vendor/google.golang.org/grpc/README.md
+++ b/vendor/google.golang.org/grpc/README.md
@@ -1,6 +1,6 @@
 # gRPC-Go
 
-[![Build Status](https://travis-ci.org/grpc/grpc-go.svg)](https://travis-ci.org/grpc/grpc-go) [![GoDoc](https://godoc.org/google.golang.org/grpc?status.svg)](https://godoc.org/google.golang.org/grpc)
+[![Build Status](https://travis-ci.org/grpc/grpc-go.svg)](https://travis-ci.org/grpc/grpc-go) [![GoDoc](https://godoc.org/google.golang.org/grpc?status.svg)](https://godoc.org/google.golang.org/grpc) [![GoReportCard](https://goreportcard.com/badge/grpc/grpc-go)](https://goreportcard.com/report/github.com/grpc/grpc-go)
 
 The Go implementation of [gRPC](https://grpc.io/): A high performance, open source, general RPC framework that puts mobile and HTTP/2 first. For more information see the [gRPC Quick Start: Go](https://grpc.io/docs/quickstart/go.html) guide.
 
@@ -10,13 +10,13 @@ Installation
 To install this package, you need to install Go and setup your Go workspace on your computer. The simplest way to install the library is to run:
 
 ```
-$ go get google.golang.org/grpc
+$ go get -u google.golang.org/grpc
 ```
 
 Prerequisites
 -------------
 
-This requires Go 1.6 or later.
+gRPC-Go requires Go 1.9 or later.
 
 Constraints
 -----------
@@ -43,3 +43,25 @@ Please update proto package, gRPC package and rebuild the proto files:
  - `go get -u github.com/golang/protobuf/{proto,protoc-gen-go}`
  - `go get -u google.golang.org/grpc`
  - `protoc --go_out=plugins=grpc:. *.proto`
+
+#### How to turn on logging
+
+The default logger is controlled by the environment variables. Turn everything
+on by setting:
+
+```
+GRPC_GO_LOG_VERBOSITY_LEVEL=99 GRPC_GO_LOG_SEVERITY_LEVEL=info
+```
+
+#### The RPC failed with error `"code = Unavailable desc = transport is closing"`
+
+This error means the connection the RPC is using was closed, and there are many
+possible reasons, including:
+ 1. mis-configured transport credentials, connection failed on handshaking
+ 1. bytes disrupted, possibly by a proxy in between
+ 1. server shutdown
+
+It can be tricky to debug this because the error happens on the client side but
+the root cause of the connection being closed is on the server side. Turn on
+logging on __both client and server__, and see if there are any transport
+errors.
diff --git a/vendor/google.golang.org/grpc/backoff.go b/vendor/google.golang.org/grpc/backoff.go
index 090fbe8..fa31565 100644
--- a/vendor/google.golang.org/grpc/backoff.go
+++ b/vendor/google.golang.org/grpc/backoff.go
@@ -16,83 +16,23 @@
  *
  */
 
+// See internal/backoff package for the backoff implementation. This file is
+// kept for the exported types and API backward compatility.
+
 package grpc
 
 import (
-        "math/rand"
         "time"
 )
 
 // DefaultBackoffConfig uses values specified for backoff in
 // https://github.com/grpc/grpc/blob/master/doc/connection-backoff.md.
-var (
-        DefaultBackoffConfig = BackoffConfig{
-                MaxDelay:  120 * time.Second,
-                baseDelay: 1.0 * time.Second,
-                factor:    1.6,
-                jitter:    0.2,
-        }
-)
-
-// backoffStrategy defines the methodology for backing off after a grpc
-// connection failure.
-//
-// This is unexported until the gRPC project decides whether or not to allow
-// alternative backoff strategies. Once a decision is made, this type and its
-// method may be exported.
-type backoffStrategy interface {
-        // backoff returns the amount of time to wait before the next retry given
-        // the number of consecutive failures.
-        backoff(retries int) time.Duration
+var DefaultBackoffConfig = BackoffConfig{
+        MaxDelay: 120 * time.Second,
 }
 
 // BackoffConfig defines the parameters for the default gRPC backoff strategy.
 type BackoffConfig struct {
         // MaxDelay is the upper bound of backoff delay.
         MaxDelay time.Duration
-
-        // TODO(stevvooe): The following fields are not exported, as allowing
-        // changes would violate the current gRPC specification for backoff. If
-        // gRPC decides to allow more interesting backoff strategies, these fields
-        // may be opened up in the future.
-
-        // baseDelay is the amount of time to wait before retrying after the first
-        // failure.
-        baseDelay time.Duration
-
-        // factor is applied to the backoff after each retry.
-        factor float64
-
-        // jitter provides a range to randomize backoff delays.
-        jitter float64
-}
-
-func setDefaults(bc *BackoffConfig) {
-        md := bc.MaxDelay
-        *bc = DefaultBackoffConfig
-
-        if md > 0 {
-                bc.MaxDelay = md
-        }
-}
-
-func (bc BackoffConfig) backoff(retries int) time.Duration {
-        if retries == 0 {
-                return bc.baseDelay
-        }
-        backoff, max := float64(bc.baseDelay), float64(bc.MaxDelay)
-        for backoff < max && retries > 0 {
-                backoff *= bc.factor
-                retries--
-        }
-        if backoff > max {
-                backoff = max
-        }
-        // Randomize backoff delays so that if a cluster of requests start at
-        // the same time, they won't operate in lockstep.
-        backoff *= 1 + bc.jitter*(rand.Float64()*2-1)
-        if backoff < 0 {
-                return 0
-        }
-        return time.Duration(backoff)
 }
diff --git a/vendor/google.golang.org/grpc/balancer.go b/vendor/google.golang.org/grpc/balancer.go
index cde472c..a78e702 100644
--- a/vendor/google.golang.org/grpc/balancer.go
+++ b/vendor/google.golang.org/grpc/balancer.go
@@ -19,19 +19,20 @@
 package grpc
 
 import (
-        "fmt"
+        "context"
         "net"
         "sync"
 
-        "golang.org/x/net/context"
         "google.golang.org/grpc/codes"
         "google.golang.org/grpc/credentials"
         "google.golang.org/grpc/grpclog"
         "google.golang.org/grpc/naming"
+        "google.golang.org/grpc/status"
 )
 
 // Address represents a server the client connects to.
-// This is the EXPERIMENTAL API and may be changed or extended in the future.
+//
+// Deprecated: please use package balancer.
 type Address struct {
         // Addr is the server address on which a connection will be established.
         Addr string
@@ -41,6 +42,8 @@ type Address struct {
 }
 
 // BalancerConfig specifies the configurations for Balancer.
+//
+// Deprecated: please use package balancer.
 type BalancerConfig struct {
         // DialCreds is the transport credential the Balancer implementation can
         // use to dial to a remote load balancer server. The Balancer implementations
@@ -53,7 +56,8 @@ type BalancerConfig struct {
 }
 
 // BalancerGetOptions configures a Get call.
-// This is the EXPERIMENTAL API and may be changed or extended in the future.
+//
+// Deprecated: please use package balancer.
 type BalancerGetOptions struct {
         // BlockingWait specifies whether Get should block when there is no
         // connected address.
@@ -61,7 +65,8 @@ type BalancerGetOptions struct {
 }
 
 // Balancer chooses network addresses for RPCs.
-// This is the EXPERIMENTAL API and may be changed or extended in the future.
+//
+// Deprecated: please use package balancer.
 type Balancer interface {
         // Start does the initialization work to bootstrap a Balancer. For example,
         // this function may start the name resolution and watch the updates. It will
@@ -112,28 +117,10 @@ type Balancer interface {
         Close() error
 }
 
-// downErr implements net.Error. It is constructed by gRPC internals and passed to the down
-// call of Balancer.
-type downErr struct {
-        timeout   bool
-        temporary bool
-        desc      string
-}
-
-func (e downErr) Error() string   { return e.desc }
-func (e downErr) Timeout() bool   { return e.timeout }
-func (e downErr) Temporary() bool { return e.temporary }
-
-func downErrorf(timeout, temporary bool, format string, a ...interface{}) downErr {
-        return downErr{
-                timeout:   timeout,
-                temporary: temporary,
-                desc:      fmt.Sprintf(format, a...),
-        }
-}
-
 // RoundRobin returns a Balancer that selects addresses round-robin. It uses r to watch
 // the name resolution updates and updates the addresses available correspondingly.
+//
+// Deprecated: please use package balancer/roundrobin.
 func RoundRobin(r naming.Resolver) Balancer {
         return &roundRobin{r: r}
 }
@@ -310,7 +297,7 @@ func (rr *roundRobin) Get(ctx context.Context, opts BalancerGetOptions) (addr Ad
         if !opts.BlockingWait {
                 if len(rr.addrs) == 0 {
                         rr.mu.Unlock()
-                        err = Errorf(codes.Unavailable, "there is no address available")
+                        err = status.Errorf(codes.Unavailable, "there is no address available")
                         return
                 }
                 // Returns the next addr on rr.addrs for failfast RPCs.
@@ -395,3 +382,10 @@ func (rr *roundRobin) Close() error {
         }
         return nil
 }
+
+// pickFirst is used to test multi-addresses in one addrConn in which all addresses share the same addrConn.
+// It is a wrapper around roundRobin balancer. The logic of all methods works fine because balancer.Get()
+// returns the only address Up by resetTransport().
+type pickFirst struct {
+        *roundRobin
+}
diff --git a/vendor/google.golang.org/grpc/balancer/balancer.go b/vendor/google.golang.org/grpc/balancer/balancer.go
new file mode 100644
index 0000000..317c2e7
--- /dev/null
+++ b/vendor/google.golang.org/grpc/balancer/balancer.go
@@ -0,0 +1,303 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package balancer defines APIs for load balancing in gRPC.
+// All APIs in this package are experimental.
+package balancer
+
+import (
+        "context"
+        "errors"
+        "net"
+        "strings"
+
+        "google.golang.org/grpc/connectivity"
+        "google.golang.org/grpc/credentials"
+        "google.golang.org/grpc/internal"
+        "google.golang.org/grpc/metadata"
+        "google.golang.org/grpc/resolver"
+)
+
+var (
+        // m is a map from name to balancer builder.
+        m = make(map[string]Builder)
+)
+
+// Register registers the balancer builder to the balancer map. b.Name
+// (lowercased) will be used as the name registered with this builder.
+//
+// NOTE: this function must only be called during initialization time (i.e. in
+// an init() function), and is not thread-safe. If multiple Balancers are
+// registered with the same name, the one registered last will take effect.
+func Register(b Builder) {
+        m[strings.ToLower(b.Name())] = b
+}
+
+// unregisterForTesting deletes the balancer with the given name from the
+// balancer map.
+//
+// This function is not thread-safe.
+func unregisterForTesting(name string) {
+        delete(m, name)
+}
+
+func init() {
+        internal.BalancerUnregister = unregisterForTesting
+}
+
+// Get returns the resolver builder registered with the given name.
+// Note that the compare is done in a case-insenstive fashion.
+// If no builder is register with the name, nil will be returned.
+func Get(name string) Builder {
+        if b, ok := m[strings.ToLower(name)]; ok {
+                return b
+        }
+        return nil
+}
+
+// SubConn represents a gRPC sub connection.
+// Each sub connection contains a list of addresses. gRPC will
+// try to connect to them (in sequence), and stop trying the
+// remainder once one connection is successful.
+//
+// The reconnect backoff will be applied on the list, not a single address.
+// For example, try_on_all_addresses -> backoff -> try_on_all_addresses.
+//
+// All SubConns start in IDLE, and will not try to connect. To trigger
+// the connecting, Balancers must call Connect.
+// When the connection encounters an error, it will reconnect immediately.
+// When the connection becomes IDLE, it will not reconnect unless Connect is
+// called.
+//
+// This interface is to be implemented by gRPC. Users should not need a
+// brand new implementation of this interface. For the situations like
+// testing, the new implementation should embed this interface. This allows
+// gRPC to add new methods to this interface.
+type SubConn interface {
+        // UpdateAddresses updates the addresses used in this SubConn.
+        // gRPC checks if currently-connected address is still in the new list.
+        // If it's in the list, the connection will be kept.
+        // If it's not in the list, the connection will gracefully closed, and
+        // a new connection will be created.
+        //
+        // This will trigger a state transition for the SubConn.
+        UpdateAddresses([]resolver.Address)
+        // Connect starts the connecting for this SubConn.
+        Connect()
+}
+
+// NewSubConnOptions contains options to create new SubConn.
+type NewSubConnOptions struct {
+        // CredsBundle is the credentials bundle that will be used in the created
+        // SubConn. If it's nil, the original creds from grpc DialOptions will be
+        // used.
+        CredsBundle credentials.Bundle
+        // HealthCheckEnabled indicates whether health check service should be
+        // enabled on this SubConn
+        HealthCheckEnabled bool
+}
+
+// ClientConn represents a gRPC ClientConn.
+//
+// This interface is to be implemented by gRPC. Users should not need a
+// brand new implementation of this interface. For the situations like
+// testing, the new implementation should embed this interface. This allows
+// gRPC to add new methods to this interface.
+type ClientConn interface {
+        // NewSubConn is called by balancer to create a new SubConn.
+        // It doesn't block and wait for the connections to be established.
+        // Behaviors of the SubConn can be controlled by options.
+        NewSubConn([]resolver.Address, NewSubConnOptions) (SubConn, error)
+        // RemoveSubConn removes the SubConn from ClientConn.
+        // The SubConn will be shutdown.
+        RemoveSubConn(SubConn)
+
+        // UpdateBalancerState is called by balancer to nofity gRPC that some internal
+        // state in balancer has changed.
+        //
+        // gRPC will update the connectivity state of the ClientConn, and will call pick
+        // on the new picker to pick new SubConn.
+        UpdateBalancerState(s connectivity.State, p Picker)
+
+        // ResolveNow is called by balancer to notify gRPC to do a name resolving.
+        ResolveNow(resolver.ResolveNowOption)
+
+        // Target returns the dial target for this ClientConn.
+        Target() string
+}
+
+// BuildOptions contains additional information for Build.
+type BuildOptions struct {
+        // DialCreds is the transport credential the Balancer implementation can
+        // use to dial to a remote load balancer server. The Balancer implementations
+        // can ignore this if it does not need to talk to another party securely.
+        DialCreds credentials.TransportCredentials
+        // CredsBundle is the credentials bundle that the Balancer can use.
+        CredsBundle credentials.Bundle
+        // Dialer is the custom dialer the Balancer implementation can use to dial
+        // to a remote load balancer server. The Balancer implementations
+        // can ignore this if it doesn't need to talk to remote balancer.
+        Dialer func(context.Context, string) (net.Conn, error)
+        // ChannelzParentID is the entity parent's channelz unique identification number.
+        ChannelzParentID int64
+}
+
+// Builder creates a balancer.
+type Builder interface {
+        // Build creates a new balancer with the ClientConn.
+        Build(cc ClientConn, opts BuildOptions) Balancer
+        // Name returns the name of balancers built by this builder.
+        // It will be used to pick balancers (for example in service config).
+        Name() string
+}
+
+// PickOptions contains addition information for the Pick operation.
+type PickOptions struct {
+        // FullMethodName is the method name that NewClientStream() is called
+        // with. The canonical format is /service/Method.
+        FullMethodName string
+        // Header contains the metadata from the RPC's client header.  The metadata
+        // should not be modified; make a copy first if needed.
+        Header metadata.MD
+}
+
+// DoneInfo contains additional information for done.
+type DoneInfo struct {
+        // Err is the rpc error the RPC finished with. It could be nil.
+        Err error
+        // Trailer contains the metadata from the RPC's trailer, if present.
+        Trailer metadata.MD
+        // BytesSent indicates if any bytes have been sent to the server.
+        BytesSent bool
+        // BytesReceived indicates if any byte has been received from the server.
+        BytesReceived bool
+}
+
+var (
+        // ErrNoSubConnAvailable indicates no SubConn is available for pick().
+        // gRPC will block the RPC until a new picker is available via UpdateBalancerState().
+        ErrNoSubConnAvailable = errors.New("no SubConn is available")
+        // ErrTransientFailure indicates all SubConns are in TransientFailure.
+        // WaitForReady RPCs will block, non-WaitForReady RPCs will fail.
+        ErrTransientFailure = errors.New("all SubConns are in TransientFailure")
+)
+
+// Picker is used by gRPC to pick a SubConn to send an RPC.
+// Balancer is expected to generate a new picker from its snapshot every time its
+// internal state has changed.
+//
+// The pickers used by gRPC can be updated by ClientConn.UpdateBalancerState().
+type Picker interface {
+        // Pick returns the SubConn to be used to send the RPC.
+        // The returned SubConn must be one returned by NewSubConn().
+        //
+        // This functions is expected to return:
+        // - a SubConn that is known to be READY;
+        // - ErrNoSubConnAvailable if no SubConn is available, but progress is being
+        //   made (for example, some SubConn is in CONNECTING mode);
+        // - other errors if no active connecting is happening (for example, all SubConn
+        //   are in TRANSIENT_FAILURE mode).
+        //
+        // If a SubConn is returned:
+        // - If it is READY, gRPC will send the RPC on it;
+        // - If it is not ready, or becomes not ready after it's returned, gRPC will block
+        //   until UpdateBalancerState() is called and will call pick on the new picker.
+        //
+        // If the returned error is not nil:
+        // - If the error is ErrNoSubConnAvailable, gRPC will block until UpdateBalancerState()
+        // - If the error is ErrTransientFailure:
+        //   - If the RPC is wait-for-ready, gRPC will block until UpdateBalancerState()
+        //     is called to pick again;
+        //   - Otherwise, RPC will fail with unavailable error.
+        // - Else (error is other non-nil error):
+        //   - The RPC will fail with unavailable error.
+        //
+        // The returned done() function will be called once the rpc has finished, with the
+        // final status of that RPC.
+        // done may be nil if balancer doesn't care about the RPC status.
+        Pick(ctx context.Context, opts PickOptions) (conn SubConn, done func(DoneInfo), err error)
+}
+
+// Balancer takes input from gRPC, manages SubConns, and collects and aggregates
+// the connectivity states.
+//
+// It also generates and updates the Picker used by gRPC to pick SubConns for RPCs.
+//
+// HandleSubConnectionStateChange, HandleResolvedAddrs and Close are guaranteed
+// to be called synchronously from the same goroutine.
+// There's no guarantee on picker.Pick, it may be called anytime.
+type Balancer interface {
+        // HandleSubConnStateChange is called by gRPC when the connectivity state
+        // of sc has changed.
+        // Balancer is expected to aggregate all the state of SubConn and report
+        // that back to gRPC.
+        // Balancer should also generate and update Pickers when its internal state has
+        // been changed by the new state.
+        HandleSubConnStateChange(sc SubConn, state connectivity.State)
+        // HandleResolvedAddrs is called by gRPC to send updated resolved addresses to
+        // balancers.
+        // Balancer can create new SubConn or remove SubConn with the addresses.
+        // An empty address slice and a non-nil error will be passed if the resolver returns
+        // non-nil error to gRPC.
+        HandleResolvedAddrs([]resolver.Address, error)
+        // Close closes the balancer. The balancer is not required to call
+        // ClientConn.RemoveSubConn for its existing SubConns.
+        Close()
+}
+
+// ConnectivityStateEvaluator takes the connectivity states of multiple SubConns
+// and returns one aggregated connectivity state.
+//
+// It's not thread safe.
+type ConnectivityStateEvaluator struct {
+        numReady            uint64 // Number of addrConns in ready state.
+        numConnecting       uint64 // Number of addrConns in connecting state.
+        numTransientFailure uint64 // Number of addrConns in transientFailure.
+}
+
+// RecordTransition records state change happening in subConn and based on that
+// it evaluates what aggregated state should be.
+//
+//  - If at least one SubConn in Ready, the aggregated state is Ready;
+//  - Else if at least one SubConn in Connecting, the aggregated state is Connecting;
+//  - Else the aggregated state is TransientFailure.
+//
+// Idle and Shutdown are not considered.
+func (cse *ConnectivityStateEvaluator) RecordTransition(oldState, newState connectivity.State) connectivity.State {
+        // Update counters.
+        for idx, state := range []connectivity.State{oldState, newState} {
+                updateVal := 2*uint64(idx) - 1 // -1 for oldState and +1 for new.
+                switch state {
+                case connectivity.Ready:
+                        cse.numReady += updateVal
+                case connectivity.Connecting:
+                        cse.numConnecting += updateVal
+                case connectivity.TransientFailure:
+                        cse.numTransientFailure += updateVal
+                }
+        }
+
+        // Evaluate.
+        if cse.numReady > 0 {
+                return connectivity.Ready
+        }
+        if cse.numConnecting > 0 {
+                return connectivity.Connecting
+        }
+        return connectivity.TransientFailure
+}
diff --git a/vendor/google.golang.org/grpc/balancer/base/balancer.go b/vendor/google.golang.org/grpc/balancer/base/balancer.go
new file mode 100644
index 0000000..245785e
--- /dev/null
+++ b/vendor/google.golang.org/grpc/balancer/base/balancer.go
@@ -0,0 +1,171 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package base
+
+import (
+        "context"
+
+        "google.golang.org/grpc/balancer"
+        "google.golang.org/grpc/connectivity"
+        "google.golang.org/grpc/grpclog"
+        "google.golang.org/grpc/resolver"
+)
+
+type baseBuilder struct {
+        name          string
+        pickerBuilder PickerBuilder
+        config        Config
+}
+
+func (bb *baseBuilder) Build(cc balancer.ClientConn, opt balancer.BuildOptions) balancer.Balancer {
+        return &baseBalancer{
+                cc:            cc,
+                pickerBuilder: bb.pickerBuilder,
+
+                subConns: make(map[resolver.Address]balancer.SubConn),
+                scStates: make(map[balancer.SubConn]connectivity.State),
+                csEvltr:  &balancer.ConnectivityStateEvaluator{},
+                // Initialize picker to a picker that always return
+                // ErrNoSubConnAvailable, because when state of a SubConn changes, we
+                // may call UpdateBalancerState with this picker.
+                picker: NewErrPicker(balancer.ErrNoSubConnAvailable),
+                config: bb.config,
+        }
+}
+
+func (bb *baseBuilder) Name() string {
+        return bb.name
+}
+
+type baseBalancer struct {
+        cc            balancer.ClientConn
+        pickerBuilder PickerBuilder
+
+        csEvltr *balancer.ConnectivityStateEvaluator
+        state   connectivity.State
+
+        subConns map[resolver.Address]balancer.SubConn
+        scStates map[balancer.SubConn]connectivity.State
+        picker   balancer.Picker
+        config   Config
+}
+
+func (b *baseBalancer) HandleResolvedAddrs(addrs []resolver.Address, err error) {
+        if err != nil {
+                grpclog.Infof("base.baseBalancer: HandleResolvedAddrs called with error %v", err)
+                return
+        }
+        grpclog.Infoln("base.baseBalancer: got new resolved addresses: ", addrs)
+        // addrsSet is the set converted from addrs, it's used for quick lookup of an address.
+        addrsSet := make(map[resolver.Address]struct{})
+        for _, a := range addrs {
+                addrsSet[a] = struct{}{}
+                if _, ok := b.subConns[a]; !ok {
+                        // a is a new address (not existing in b.subConns).
+                        sc, err := b.cc.NewSubConn([]resolver.Address{a}, balancer.NewSubConnOptions{HealthCheckEnabled: b.config.HealthCheck})
+                        if err != nil {
+                                grpclog.Warningf("base.baseBalancer: failed to create new SubConn: %v", err)
+                                continue
+                        }
+                        b.subConns[a] = sc
+                        b.scStates[sc] = connectivity.Idle
+                        sc.Connect()
+                }
+        }
+        for a, sc := range b.subConns {
+                // a was removed by resolver.
+                if _, ok := addrsSet[a]; !ok {
+                        b.cc.RemoveSubConn(sc)
+                        delete(b.subConns, a)
+                        // Keep the state of this sc in b.scStates until sc's state becomes Shutdown.
+                        // The entry will be deleted in HandleSubConnStateChange.
+                }
+        }
+}
+
+// regeneratePicker takes a snapshot of the balancer, and generates a picker
+// from it. The picker is
+//  - errPicker with ErrTransientFailure if the balancer is in TransientFailure,
+//  - built by the pickerBuilder with all READY SubConns otherwise.
+func (b *baseBalancer) regeneratePicker() {
+        if b.state == connectivity.TransientFailure {
+                b.picker = NewErrPicker(balancer.ErrTransientFailure)
+                return
+        }
+        readySCs := make(map[resolver.Address]balancer.SubConn)
+
+        // Filter out all ready SCs from full subConn map.
+        for addr, sc := range b.subConns {
+                if st, ok := b.scStates[sc]; ok && st == connectivity.Ready {
+                        readySCs[addr] = sc
+                }
+        }
+        b.picker = b.pickerBuilder.Build(readySCs)
+}
+
+func (b *baseBalancer) HandleSubConnStateChange(sc balancer.SubConn, s connectivity.State) {
+        grpclog.Infof("base.baseBalancer: handle SubConn state change: %p, %v", sc, s)
+        oldS, ok := b.scStates[sc]
+        if !ok {
+                grpclog.Infof("base.baseBalancer: got state changes for an unknown SubConn: %p, %v", sc, s)
+                return
+        }
+        b.scStates[sc] = s
+        switch s {
+        case connectivity.Idle:
+                sc.Connect()
+        case connectivity.Shutdown:
+                // When an address was removed by resolver, b called RemoveSubConn but
+                // kept the sc's state in scStates. Remove state for this sc here.
+                delete(b.scStates, sc)
+        }
+
+        oldAggrState := b.state
+        b.state = b.csEvltr.RecordTransition(oldS, s)
+
+        // Regenerate picker when one of the following happens:
+        //  - this sc became ready from not-ready
+        //  - this sc became not-ready from ready
+        //  - the aggregated state of balancer became TransientFailure from non-TransientFailure
+        //  - the aggregated state of balancer became non-TransientFailure from TransientFailure
+        if (s == connectivity.Ready) != (oldS == connectivity.Ready) ||
+                (b.state == connectivity.TransientFailure) != (oldAggrState == connectivity.TransientFailure) {
+                b.regeneratePicker()
+        }
+
+        b.cc.UpdateBalancerState(b.state, b.picker)
+}
+
+// Close is a nop because base balancer doesn't have internal state to clean up,
+// and it doesn't need to call RemoveSubConn for the SubConns.
+func (b *baseBalancer) Close() {
+}
+
+// NewErrPicker returns a picker that always returns err on Pick().
+func NewErrPicker(err error) balancer.Picker {
+        return &errPicker{err: err}
+}
+
+type errPicker struct {
+        err error // Pick() always returns this err.
+}
+
+func (p *errPicker) Pick(ctx context.Context, opts balancer.PickOptions) (balancer.SubConn, func(balancer.DoneInfo), error) {
+        return nil, nil, p.err
+}
diff --git a/vendor/google.golang.org/grpc/balancer/base/base.go b/vendor/google.golang.org/grpc/balancer/base/base.go
new file mode 100644
index 0000000..34b1f29
--- /dev/null
+++ b/vendor/google.golang.org/grpc/balancer/base/base.go
@@ -0,0 +1,64 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package base defines a balancer base that can be used to build balancers with
+// different picking algorithms.
+//
+// The base balancer creates a new SubConn for each resolved address. The
+// provided picker will only be notified about READY SubConns.
+//
+// This package is the base of round_robin balancer, its purpose is to be used
+// to build round_robin like balancers with complex picking algorithms.
+// Balancers with more complicated logic should try to implement a balancer
+// builder from scratch.
+//
+// All APIs in this package are experimental.
+package base
+
+import (
+        "google.golang.org/grpc/balancer"
+        "google.golang.org/grpc/resolver"
+)
+
+// PickerBuilder creates balancer.Picker.
+type PickerBuilder interface {
+        // Build takes a slice of ready SubConns, and returns a picker that will be
+        // used by gRPC to pick a SubConn.
+        Build(readySCs map[resolver.Address]balancer.SubConn) balancer.Picker
+}
+
+// NewBalancerBuilder returns a balancer builder. The balancers
+// built by this builder will use the picker builder to build pickers.
+func NewBalancerBuilder(name string, pb PickerBuilder) balancer.Builder {
+        return NewBalancerBuilderWithConfig(name, pb, Config{})
+}
+
+// Config contains the config info about the base balancer builder.
+type Config struct {
+        // HealthCheck indicates whether health checking should be enabled for this specific balancer.
+        HealthCheck bool
+}
+
+// NewBalancerBuilderWithConfig returns a base balancer builder configured by the provided config.
+func NewBalancerBuilderWithConfig(name string, pb PickerBuilder, config Config) balancer.Builder {
+        return &baseBuilder{
+                name:          name,
+                pickerBuilder: pb,
+                config:        config,
+        }
+}
diff --git a/vendor/google.golang.org/grpc/balancer/roundrobin/roundrobin.go b/vendor/google.golang.org/grpc/balancer/roundrobin/roundrobin.go
new file mode 100644
index 0000000..57aea9f
--- /dev/null
+++ b/vendor/google.golang.org/grpc/balancer/roundrobin/roundrobin.go
@@ -0,0 +1,79 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package roundrobin defines a roundrobin balancer. Roundrobin balancer is
+// installed as one of the default balancers in gRPC, users don't need to
+// explicitly install this balancer.
+package roundrobin
+
+import (
+        "context"
+        "sync"
+
+        "google.golang.org/grpc/balancer"
+        "google.golang.org/grpc/balancer/base"
+        "google.golang.org/grpc/grpclog"
+        "google.golang.org/grpc/resolver"
+)
+
+// Name is the name of round_robin balancer.
+const Name = "round_robin"
+
+// newBuilder creates a new roundrobin balancer builder.
+func newBuilder() balancer.Builder {
+        return base.NewBalancerBuilderWithConfig(Name, &rrPickerBuilder{}, base.Config{HealthCheck: true})
+}
+
+func init() {
+        balancer.Register(newBuilder())
+}
+
+type rrPickerBuilder struct{}
+
+func (*rrPickerBuilder) Build(readySCs map[resolver.Address]balancer.SubConn) balancer.Picker {
+        grpclog.Infof("roundrobinPicker: newPicker called with readySCs: %v", readySCs)
+        var scs []balancer.SubConn
+        for _, sc := range readySCs {
+                scs = append(scs, sc)
+        }
+        return &rrPicker{
+                subConns: scs,
+        }
+}
+
+type rrPicker struct {
+        // subConns is the snapshot of the roundrobin balancer when this picker was
+        // created. The slice is immutable. Each Get() will do a round robin
+        // selection from it and return the selected SubConn.
+        subConns []balancer.SubConn
+
+        mu   sync.Mutex
+        next int
+}
+
+func (p *rrPicker) Pick(ctx context.Context, opts balancer.PickOptions) (balancer.SubConn, func(balancer.DoneInfo), error) {
+        if len(p.subConns) <= 0 {
+                return nil, nil, balancer.ErrNoSubConnAvailable
+        }
+
+        p.mu.Lock()
+        sc := p.subConns[p.next]
+        p.next = (p.next + 1) % len(p.subConns)
+        p.mu.Unlock()
+        return sc, nil, nil
+}
diff --git a/vendor/google.golang.org/grpc/balancer_conn_wrappers.go b/vendor/google.golang.org/grpc/balancer_conn_wrappers.go
new file mode 100644
index 0000000..7233ade
--- /dev/null
+++ b/vendor/google.golang.org/grpc/balancer_conn_wrappers.go
@@ -0,0 +1,328 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package grpc
+
+import (
+        "fmt"
+        "sync"
+
+        "google.golang.org/grpc/balancer"
+        "google.golang.org/grpc/connectivity"
+        "google.golang.org/grpc/grpclog"
+        "google.golang.org/grpc/resolver"
+)
+
+// scStateUpdate contains the subConn and the new state it changed to.
+type scStateUpdate struct {
+        sc    balancer.SubConn
+        state connectivity.State
+}
+
+// scStateUpdateBuffer is an unbounded channel for scStateChangeTuple.
+// TODO make a general purpose buffer that uses interface{}.
+type scStateUpdateBuffer struct {
+        c       chan *scStateUpdate
+        mu      sync.Mutex
+        backlog []*scStateUpdate
+}
+
+func newSCStateUpdateBuffer() *scStateUpdateBuffer {
+        return &scStateUpdateBuffer{
+                c: make(chan *scStateUpdate, 1),
+        }
+}
+
+func (b *scStateUpdateBuffer) put(t *scStateUpdate) {
+        b.mu.Lock()
+        defer b.mu.Unlock()
+        if len(b.backlog) == 0 {
+                select {
+                case b.c <- t:
+                        return
+                default:
+                }
+        }
+        b.backlog = append(b.backlog, t)
+}
+
+func (b *scStateUpdateBuffer) load() {
+        b.mu.Lock()
+        defer b.mu.Unlock()
+        if len(b.backlog) > 0 {
+                select {
+                case b.c <- b.backlog[0]:
+                        b.backlog[0] = nil
+                        b.backlog = b.backlog[1:]
+                default:
+                }
+        }
+}
+
+// get returns the channel that the scStateUpdate will be sent to.
+//
+// Upon receiving, the caller should call load to send another
+// scStateChangeTuple onto the channel if there is any.
+func (b *scStateUpdateBuffer) get() <-chan *scStateUpdate {
+        return b.c
+}
+
+// resolverUpdate contains the new resolved addresses or error if there's
+// any.
+type resolverUpdate struct {
+        addrs []resolver.Address
+        err   error
+}
+
+// ccBalancerWrapper is a wrapper on top of cc for balancers.
+// It implements balancer.ClientConn interface.
+type ccBalancerWrapper struct {
+        cc               *ClientConn
+        balancer         balancer.Balancer
+        stateChangeQueue *scStateUpdateBuffer
+        resolverUpdateCh chan *resolverUpdate
+        done             chan struct{}
+
+        mu       sync.Mutex
+        subConns map[*acBalancerWrapper]struct{}
+}
+
+func newCCBalancerWrapper(cc *ClientConn, b balancer.Builder, bopts balancer.BuildOptions) *ccBalancerWrapper {
+        ccb := &ccBalancerWrapper{
+                cc:               cc,
+                stateChangeQueue: newSCStateUpdateBuffer(),
+                resolverUpdateCh: make(chan *resolverUpdate, 1),
+                done:             make(chan struct{}),
+                subConns:         make(map[*acBalancerWrapper]struct{}),
+        }
+        go ccb.watcher()
+        ccb.balancer = b.Build(ccb, bopts)
+        return ccb
+}
+
+// watcher balancer functions sequentially, so the balancer can be implemented
+// lock-free.
+func (ccb *ccBalancerWrapper) watcher() {
+        for {
+                select {
+                case t := <-ccb.stateChangeQueue.get():
+                        ccb.stateChangeQueue.load()
+                        select {
+                        case <-ccb.done:
+                                ccb.balancer.Close()
+                                return
+                        default:
+                        }
+                        ccb.balancer.HandleSubConnStateChange(t.sc, t.state)
+                case t := <-ccb.resolverUpdateCh:
+                        select {
+                        case <-ccb.done:
+                                ccb.balancer.Close()
+                                return
+                        default:
+                        }
+                        ccb.balancer.HandleResolvedAddrs(t.addrs, t.err)
+                case <-ccb.done:
+                }
+
+                select {
+                case <-ccb.done:
+                        ccb.balancer.Close()
+                        ccb.mu.Lock()
+                        scs := ccb.subConns
+                        ccb.subConns = nil
+                        ccb.mu.Unlock()
+                        for acbw := range scs {
+                                ccb.cc.removeAddrConn(acbw.getAddrConn(), errConnDrain)
+                        }
+                        return
+                default:
+                }
+        }
+}
+
+func (ccb *ccBalancerWrapper) close() {
+        close(ccb.done)
+}
+
+func (ccb *ccBalancerWrapper) handleSubConnStateChange(sc balancer.SubConn, s connectivity.State) {
+        // When updating addresses for a SubConn, if the address in use is not in
+        // the new addresses, the old ac will be tearDown() and a new ac will be
+        // created. tearDown() generates a state change with Shutdown state, we
+        // don't want the balancer to receive this state change. So before
+        // tearDown() on the old ac, ac.acbw (acWrapper) will be set to nil, and
+        // this function will be called with (nil, Shutdown). We don't need to call
+        // balancer method in this case.
+        if sc == nil {
+                return
+        }
+        ccb.stateChangeQueue.put(&scStateUpdate{
+                sc:    sc,
+                state: s,
+        })
+}
+
+func (ccb *ccBalancerWrapper) handleResolvedAddrs(addrs []resolver.Address, err error) {
+        if ccb.cc.curBalancerName != grpclbName {
+                var containsGRPCLB bool
+                for _, a := range addrs {
+                        if a.Type == resolver.GRPCLB {
+                                containsGRPCLB = true
+                                break
+                        }
+                }
+                if containsGRPCLB {
+                        // The current balancer is not grpclb, but addresses contain grpclb
+                        // address. This means we failed to switch to grpclb, most likely
+                        // because grpclb is not registered. Filter out all grpclb addresses
+                        // from addrs before sending to balancer.
+                        tempAddrs := make([]resolver.Address, 0, len(addrs))
+                        for _, a := range addrs {
+                                if a.Type != resolver.GRPCLB {
+                                        tempAddrs = append(tempAddrs, a)
+                                }
+                        }
+                        addrs = tempAddrs
+                }
+        }
+        select {
+        case <-ccb.resolverUpdateCh:
+        default:
+        }
+        ccb.resolverUpdateCh <- &resolverUpdate{
+                addrs: addrs,
+                err:   err,
+        }
+}
+
+func (ccb *ccBalancerWrapper) NewSubConn(addrs []resolver.Address, opts balancer.NewSubConnOptions) (balancer.SubConn, error) {
+        if len(addrs) <= 0 {
+                return nil, fmt.Errorf("grpc: cannot create SubConn with empty address list")
+        }
+        ccb.mu.Lock()
+        defer ccb.mu.Unlock()
+        if ccb.subConns == nil {
+                return nil, fmt.Errorf("grpc: ClientConn balancer wrapper was closed")
+        }
+        ac, err := ccb.cc.newAddrConn(addrs, opts)
+        if err != nil {
+                return nil, err
+        }
+        acbw := &acBalancerWrapper{ac: ac}
+        acbw.ac.mu.Lock()
+        ac.acbw = acbw
+        acbw.ac.mu.Unlock()
+        ccb.subConns[acbw] = struct{}{}
+        return acbw, nil
+}
+
+func (ccb *ccBalancerWrapper) RemoveSubConn(sc balancer.SubConn) {
+        acbw, ok := sc.(*acBalancerWrapper)
+        if !ok {
+                return
+        }
+        ccb.mu.Lock()
+        defer ccb.mu.Unlock()
+        if ccb.subConns == nil {
+                return
+        }
+        delete(ccb.subConns, acbw)
+        ccb.cc.removeAddrConn(acbw.getAddrConn(), errConnDrain)
+}
+
+func (ccb *ccBalancerWrapper) UpdateBalancerState(s connectivity.State, p balancer.Picker) {
+        ccb.mu.Lock()
+        defer ccb.mu.Unlock()
+        if ccb.subConns == nil {
+                return
+        }
+        // Update picker before updating state.  Even though the ordering here does
+        // not matter, it can lead to multiple calls of Pick in the common start-up
+        // case where we wait for ready and then perform an RPC.  If the picker is
+        // updated later, we could call the "connecting" picker when the state is
+        // updated, and then call the "ready" picker after the picker gets updated.
+        ccb.cc.blockingpicker.updatePicker(p)
+        ccb.cc.csMgr.updateState(s)
+}
+
+func (ccb *ccBalancerWrapper) ResolveNow(o resolver.ResolveNowOption) {
+        ccb.cc.resolveNow(o)
+}
+
+func (ccb *ccBalancerWrapper) Target() string {
+        return ccb.cc.target
+}
+
+// acBalancerWrapper is a wrapper on top of ac for balancers.
+// It implements balancer.SubConn interface.
+type acBalancerWrapper struct {
+        mu sync.Mutex
+        ac *addrConn
+}
+
+func (acbw *acBalancerWrapper) UpdateAddresses(addrs []resolver.Address) {
+        acbw.mu.Lock()
+        defer acbw.mu.Unlock()
+        if len(addrs) <= 0 {
+                acbw.ac.tearDown(errConnDrain)
+                return
+        }
+        if !acbw.ac.tryUpdateAddrs(addrs) {
+                cc := acbw.ac.cc
+                opts := acbw.ac.scopts
+                acbw.ac.mu.Lock()
+                // Set old ac.acbw to nil so the Shutdown state update will be ignored
+                // by balancer.
+                //
+                // TODO(bar) the state transition could be wrong when tearDown() old ac
+                // and creating new ac, fix the transition.
+                acbw.ac.acbw = nil
+                acbw.ac.mu.Unlock()
+                acState := acbw.ac.getState()
+                acbw.ac.tearDown(errConnDrain)
+
+                if acState == connectivity.Shutdown {
+                        return
+                }
+
+                ac, err := cc.newAddrConn(addrs, opts)
+                if err != nil {
+                        grpclog.Warningf("acBalancerWrapper: UpdateAddresses: failed to newAddrConn: %v", err)
+                        return
+                }
+                acbw.ac = ac
+                ac.mu.Lock()
+                ac.acbw = acbw
+                ac.mu.Unlock()
+                if acState != connectivity.Idle {
+                        ac.connect()
+                }
+        }
+}
+
+func (acbw *acBalancerWrapper) Connect() {
+        acbw.mu.Lock()
+        defer acbw.mu.Unlock()
+        acbw.ac.connect()
+}
+
+func (acbw *acBalancerWrapper) getAddrConn() *addrConn {
+        acbw.mu.Lock()
+        defer acbw.mu.Unlock()
+        return acbw.ac
+}
diff --git a/vendor/google.golang.org/grpc/balancer_v1_wrapper.go b/vendor/google.golang.org/grpc/balancer_v1_wrapper.go
new file mode 100644
index 0000000..42b60fe
--- /dev/null
+++ b/vendor/google.golang.org/grpc/balancer_v1_wrapper.go
@@ -0,0 +1,326 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package grpc
+
+import (
+        "context"
+        "strings"
+        "sync"
+
+        "google.golang.org/grpc/balancer"
+        "google.golang.org/grpc/connectivity"
+        "google.golang.org/grpc/grpclog"
+        "google.golang.org/grpc/resolver"
+)
+
+type balancerWrapperBuilder struct {
+        b Balancer // The v1 balancer.
+}
+
+func (bwb *balancerWrapperBuilder) Build(cc balancer.ClientConn, opts balancer.BuildOptions) balancer.Balancer {
+        targetAddr := cc.Target()
+        targetSplitted := strings.Split(targetAddr, ":///")
+        if len(targetSplitted) >= 2 {
+                targetAddr = targetSplitted[1]
+        }
+
+        bwb.b.Start(targetAddr, BalancerConfig{
+                DialCreds: opts.DialCreds,
+                Dialer:    opts.Dialer,
+        })
+        _, pickfirst := bwb.b.(*pickFirst)
+        bw := &balancerWrapper{
+                balancer:   bwb.b,
+                pickfirst:  pickfirst,
+                cc:         cc,
+                targetAddr: targetAddr,
+                startCh:    make(chan struct{}),
+                conns:      make(map[resolver.Address]balancer.SubConn),
+                connSt:     make(map[balancer.SubConn]*scState),
+                csEvltr:    &balancer.ConnectivityStateEvaluator{},
+                state:      connectivity.Idle,
+        }
+        cc.UpdateBalancerState(connectivity.Idle, bw)
+        go bw.lbWatcher()
+        return bw
+}
+
+func (bwb *balancerWrapperBuilder) Name() string {
+        return "wrapper"
+}
+
+type scState struct {
+        addr Address // The v1 address type.
+        s    connectivity.State
+        down func(error)
+}
+
+type balancerWrapper struct {
+        balancer  Balancer // The v1 balancer.
+        pickfirst bool
+
+        cc         balancer.ClientConn
+        targetAddr string // Target without the scheme.
+
+        mu     sync.Mutex
+        conns  map[resolver.Address]balancer.SubConn
+        connSt map[balancer.SubConn]*scState
+        // This channel is closed when handling the first resolver result.
+        // lbWatcher blocks until this is closed, to avoid race between
+        // - NewSubConn is created, cc wants to notify balancer of state changes;
+        // - Build hasn't return, cc doesn't have access to balancer.
+        startCh chan struct{}
+
+        // To aggregate the connectivity state.
+        csEvltr *balancer.ConnectivityStateEvaluator
+        state   connectivity.State
+}
+
+// lbWatcher watches the Notify channel of the balancer and manages
+// connections accordingly.
+func (bw *balancerWrapper) lbWatcher() {
+        <-bw.startCh
+        notifyCh := bw.balancer.Notify()
+        if notifyCh == nil {
+                // There's no resolver in the balancer. Connect directly.
+                a := resolver.Address{
+                        Addr: bw.targetAddr,
+                        Type: resolver.Backend,
+                }
+                sc, err := bw.cc.NewSubConn([]resolver.Address{a}, balancer.NewSubConnOptions{})
+                if err != nil {
+                        grpclog.Warningf("Error creating connection to %v. Err: %v", a, err)
+                } else {
+                        bw.mu.Lock()
+                        bw.conns[a] = sc
+                        bw.connSt[sc] = &scState{
+                                addr: Address{Addr: bw.targetAddr},
+                                s:    connectivity.Idle,
+                        }
+                        bw.mu.Unlock()
+                        sc.Connect()
+                }
+                return
+        }
+
+        for addrs := range notifyCh {
+                grpclog.Infof("balancerWrapper: got update addr from Notify: %v\n", addrs)
+                if bw.pickfirst {
+                        var (
+                                oldA  resolver.Address
+                                oldSC balancer.SubConn
+                        )
+                        bw.mu.Lock()
+                        for oldA, oldSC = range bw.conns {
+                                break
+                        }
+                        bw.mu.Unlock()
+                        if len(addrs) <= 0 {
+                                if oldSC != nil {
+                                        // Teardown old sc.
+                                        bw.mu.Lock()
+                                        delete(bw.conns, oldA)
+                                        delete(bw.connSt, oldSC)
+                                        bw.mu.Unlock()
+                                        bw.cc.RemoveSubConn(oldSC)
+                                }
+                                continue
+                        }
+
+                        var newAddrs []resolver.Address
+                        for _, a := range addrs {
+                                newAddr := resolver.Address{
+                                        Addr:       a.Addr,
+                                        Type:       resolver.Backend, // All addresses from balancer are all backends.
+                                        ServerName: "",
+                                        Metadata:   a.Metadata,
+                                }
+                                newAddrs = append(newAddrs, newAddr)
+                        }
+                        if oldSC == nil {
+                                // Create new sc.
+                                sc, err := bw.cc.NewSubConn(newAddrs, balancer.NewSubConnOptions{})
+                                if err != nil {
+                                        grpclog.Warningf("Error creating connection to %v. Err: %v", newAddrs, err)
+                                } else {
+                                        bw.mu.Lock()
+                                        // For pickfirst, there should be only one SubConn, so the
+                                        // address doesn't matter. All states updating (up and down)
+                                        // and picking should all happen on that only SubConn.
+                                        bw.conns[resolver.Address{}] = sc
+                                        bw.connSt[sc] = &scState{
+                                                addr: addrs[0], // Use the first address.
+                                                s:    connectivity.Idle,
+                                        }
+                                        bw.mu.Unlock()
+                                        sc.Connect()
+                                }
+                        } else {
+                                bw.mu.Lock()
+                                bw.connSt[oldSC].addr = addrs[0]
+                                bw.mu.Unlock()
+                                oldSC.UpdateAddresses(newAddrs)
+                        }
+                } else {
+                        var (
+                                add []resolver.Address // Addresses need to setup connections.
+                                del []balancer.SubConn // Connections need to tear down.
+                        )
+                        resAddrs := make(map[resolver.Address]Address)
+                        for _, a := range addrs {
+                                resAddrs[resolver.Address{
+                                        Addr:       a.Addr,
+                                        Type:       resolver.Backend, // All addresses from balancer are all backends.
+                                        ServerName: "",
+                                        Metadata:   a.Metadata,
+                                }] = a
+                        }
+                        bw.mu.Lock()
+                        for a := range resAddrs {
+                                if _, ok := bw.conns[a]; !ok {
+                                        add = append(add, a)
+                                }
+                        }
+                        for a, c := range bw.conns {
+                                if _, ok := resAddrs[a]; !ok {
+                                        del = append(del, c)
+                                        delete(bw.conns, a)
+                                        // Keep the state of this sc in bw.connSt until its state becomes Shutdown.
+                                }
+                        }
+                        bw.mu.Unlock()
+                        for _, a := range add {
+                                sc, err := bw.cc.NewSubConn([]resolver.Address{a}, balancer.NewSubConnOptions{})
+                                if err != nil {
+                                        grpclog.Warningf("Error creating connection to %v. Err: %v", a, err)
+                                } else {
+                                        bw.mu.Lock()
+                                        bw.conns[a] = sc
+                                        bw.connSt[sc] = &scState{
+                                                addr: resAddrs[a],
+                                                s:    connectivity.Idle,
+                                        }
+                                        bw.mu.Unlock()
+                                        sc.Connect()
+                                }
+                        }
+                        for _, c := range del {
+                                bw.cc.RemoveSubConn(c)
+                        }
+                }
+        }
+}
+
+func (bw *balancerWrapper) HandleSubConnStateChange(sc balancer.SubConn, s connectivity.State) {
+        bw.mu.Lock()
+        defer bw.mu.Unlock()
+        scSt, ok := bw.connSt[sc]
+        if !ok {
+                return
+        }
+        if s == connectivity.Idle {
+                sc.Connect()
+        }
+        oldS := scSt.s
+        scSt.s = s
+        if oldS != connectivity.Ready && s == connectivity.Ready {
+                scSt.down = bw.balancer.Up(scSt.addr)
+        } else if oldS == connectivity.Ready && s != connectivity.Ready {
+                if scSt.down != nil {
+                        scSt.down(errConnClosing)
+                }
+        }
+        sa := bw.csEvltr.RecordTransition(oldS, s)
+        if bw.state != sa {
+                bw.state = sa
+        }
+        bw.cc.UpdateBalancerState(bw.state, bw)
+        if s == connectivity.Shutdown {
+                // Remove state for this sc.
+                delete(bw.connSt, sc)
+        }
+}
+
+func (bw *balancerWrapper) HandleResolvedAddrs([]resolver.Address, error) {
+        bw.mu.Lock()
+        defer bw.mu.Unlock()
+        select {
+        case <-bw.startCh:
+        default:
+                close(bw.startCh)
+        }
+        // There should be a resolver inside the balancer.
+        // All updates here, if any, are ignored.
+}
+
+func (bw *balancerWrapper) Close() {
+        bw.mu.Lock()
+        defer bw.mu.Unlock()
+        select {
+        case <-bw.startCh:
+        default:
+                close(bw.startCh)
+        }
+        bw.balancer.Close()
+}
+
+// The picker is the balancerWrapper itself.
+// Pick should never return ErrNoSubConnAvailable.
+// It either blocks or returns error, consistent with v1 balancer Get().
+func (bw *balancerWrapper) Pick(ctx context.Context, opts balancer.PickOptions) (balancer.SubConn, func(balancer.DoneInfo), error) {
+        failfast := true // Default failfast is true.
+        if ss, ok := rpcInfoFromContext(ctx); ok {
+                failfast = ss.failfast
+        }
+        a, p, err := bw.balancer.Get(ctx, BalancerGetOptions{BlockingWait: !failfast})
+        if err != nil {
+                return nil, nil, err
+        }
+        var done func(balancer.DoneInfo)
+        if p != nil {
+                done = func(i balancer.DoneInfo) { p() }
+        }
+        var sc balancer.SubConn
+        bw.mu.Lock()
+        defer bw.mu.Unlock()
+        if bw.pickfirst {
+                // Get the first sc in conns.
+                for _, sc = range bw.conns {
+                        break
+                }
+        } else {
+                var ok bool
+                sc, ok = bw.conns[resolver.Address{
+                        Addr:       a.Addr,
+                        Type:       resolver.Backend,
+                        ServerName: "",
+                        Metadata:   a.Metadata,
+                }]
+                if !ok && failfast {
+                        return nil, nil, balancer.ErrTransientFailure
+                }
+                if s, ok := bw.connSt[sc]; failfast && (!ok || s.s != connectivity.Ready) {
+                        // If the returned sc is not ready and RPC is failfast,
+                        // return error, and this RPC will fail.
+                        return nil, nil, balancer.ErrTransientFailure
+                }
+        }
+
+        return sc, done, nil
+}
diff --git a/vendor/google.golang.org/grpc/binarylog/grpc_binarylog_v1/binarylog.pb.go b/vendor/google.golang.org/grpc/binarylog/grpc_binarylog_v1/binarylog.pb.go
new file mode 100644
index 0000000..f393bb6
--- /dev/null
+++ b/vendor/google.golang.org/grpc/binarylog/grpc_binarylog_v1/binarylog.pb.go
@@ -0,0 +1,900 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: grpc/binarylog/grpc_binarylog_v1/binarylog.proto
+
+package grpc_binarylog_v1 // import "google.golang.org/grpc/binarylog/grpc_binarylog_v1"
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import duration "github.com/golang/protobuf/ptypes/duration"
+import timestamp "github.com/golang/protobuf/ptypes/timestamp"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// Enumerates the type of event
+// Note the terminology is different from the RPC semantics
+// definition, but the same meaning is expressed here.
+type GrpcLogEntry_EventType int32
+
+const (
+        GrpcLogEntry_EVENT_TYPE_UNKNOWN GrpcLogEntry_EventType = 0
+        // Header sent from client to server
+        GrpcLogEntry_EVENT_TYPE_CLIENT_HEADER GrpcLogEntry_EventType = 1
+        // Header sent from server to client
+        GrpcLogEntry_EVENT_TYPE_SERVER_HEADER GrpcLogEntry_EventType = 2
+        // Message sent from client to server
+        GrpcLogEntry_EVENT_TYPE_CLIENT_MESSAGE GrpcLogEntry_EventType = 3
+        // Message sent from server to client
+        GrpcLogEntry_EVENT_TYPE_SERVER_MESSAGE GrpcLogEntry_EventType = 4
+        // A signal that client is done sending
+        GrpcLogEntry_EVENT_TYPE_CLIENT_HALF_CLOSE GrpcLogEntry_EventType = 5
+        // Trailer indicates the end of the RPC.
+        // On client side, this event means a trailer was either received
+        // from the network or the gRPC library locally generated a status
+        // to inform the application about a failure.
+        // On server side, this event means the server application requested
+        // to send a trailer. Note: EVENT_TYPE_CANCEL may still arrive after
+        // this due to races on server side.
+        GrpcLogEntry_EVENT_TYPE_SERVER_TRAILER GrpcLogEntry_EventType = 6
+        // A signal that the RPC is cancelled. On client side, this
+        // indicates the client application requests a cancellation.
+        // On server side, this indicates that cancellation was detected.
+        // Note: This marks the end of the RPC. Events may arrive after
+        // this due to races. For example, on client side a trailer
+        // may arrive even though the application requested to cancel the RPC.
+        GrpcLogEntry_EVENT_TYPE_CANCEL GrpcLogEntry_EventType = 7
+)
+
+var GrpcLogEntry_EventType_name = map[int32]string{
+        0: "EVENT_TYPE_UNKNOWN",
+        1: "EVENT_TYPE_CLIENT_HEADER",
+        2: "EVENT_TYPE_SERVER_HEADER",
+        3: "EVENT_TYPE_CLIENT_MESSAGE",
+        4: "EVENT_TYPE_SERVER_MESSAGE",
+        5: "EVENT_TYPE_CLIENT_HALF_CLOSE",
+        6: "EVENT_TYPE_SERVER_TRAILER",
+        7: "EVENT_TYPE_CANCEL",
+}
+var GrpcLogEntry_EventType_value = map[string]int32{
+        "EVENT_TYPE_UNKNOWN":           0,
+        "EVENT_TYPE_CLIENT_HEADER":     1,
+        "EVENT_TYPE_SERVER_HEADER":     2,
+        "EVENT_TYPE_CLIENT_MESSAGE":    3,
+        "EVENT_TYPE_SERVER_MESSAGE":    4,
+        "EVENT_TYPE_CLIENT_HALF_CLOSE": 5,
+        "EVENT_TYPE_SERVER_TRAILER":    6,
+        "EVENT_TYPE_CANCEL":            7,
+}
+
+func (x GrpcLogEntry_EventType) String() string {
+        return proto.EnumName(GrpcLogEntry_EventType_name, int32(x))
+}
+func (GrpcLogEntry_EventType) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_binarylog_264c8c9c551ce911, []int{0, 0}
+}
+
+// Enumerates the entity that generates the log entry
+type GrpcLogEntry_Logger int32
+
+const (
+        GrpcLogEntry_LOGGER_UNKNOWN GrpcLogEntry_Logger = 0
+        GrpcLogEntry_LOGGER_CLIENT  GrpcLogEntry_Logger = 1
+        GrpcLogEntry_LOGGER_SERVER  GrpcLogEntry_Logger = 2
+)
+
+var GrpcLogEntry_Logger_name = map[int32]string{
+        0: "LOGGER_UNKNOWN",
+        1: "LOGGER_CLIENT",
+        2: "LOGGER_SERVER",
+}
+var GrpcLogEntry_Logger_value = map[string]int32{
+        "LOGGER_UNKNOWN": 0,
+        "LOGGER_CLIENT":  1,
+        "LOGGER_SERVER":  2,
+}
+
+func (x GrpcLogEntry_Logger) String() string {
+        return proto.EnumName(GrpcLogEntry_Logger_name, int32(x))
+}
+func (GrpcLogEntry_Logger) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_binarylog_264c8c9c551ce911, []int{0, 1}
+}
+
+type Address_Type int32
+
+const (
+        Address_TYPE_UNKNOWN Address_Type = 0
+        // address is in 1.2.3.4 form
+        Address_TYPE_IPV4 Address_Type = 1
+        // address is in IPv6 canonical form (RFC5952 section 4)
+        // The scope is NOT included in the address string.
+        Address_TYPE_IPV6 Address_Type = 2
+        // address is UDS string
+        Address_TYPE_UNIX Address_Type = 3
+)
+
+var Address_Type_name = map[int32]string{
+        0: "TYPE_UNKNOWN",
+        1: "TYPE_IPV4",
+        2: "TYPE_IPV6",
+        3: "TYPE_UNIX",
+}
+var Address_Type_value = map[string]int32{
+        "TYPE_UNKNOWN": 0,
+        "TYPE_IPV4":    1,
+        "TYPE_IPV6":    2,
+        "TYPE_UNIX":    3,
+}
+
+func (x Address_Type) String() string {
+        return proto.EnumName(Address_Type_name, int32(x))
+}
+func (Address_Type) EnumDescriptor() ([]byte, []int) {
+        return fileDescriptor_binarylog_264c8c9c551ce911, []int{7, 0}
+}
+
+// Log entry we store in binary logs
+type GrpcLogEntry struct {
+        // The timestamp of the binary log message
+        Timestamp *timestamp.Timestamp `protobuf:"bytes,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
+        // Uniquely identifies a call. The value must not be 0 in order to disambiguate
+        // from an unset value.
+        // Each call may have several log entries, they will all have the same call_id.
+        // Nothing is guaranteed about their value other than they are unique across
+        // different RPCs in the same gRPC process.
+        CallId uint64 `protobuf:"varint,2,opt,name=call_id,json=callId,proto3" json:"call_id,omitempty"`
+        // The entry sequence id for this call. The first GrpcLogEntry has a
+        // value of 1, to disambiguate from an unset value. The purpose of
+        // this field is to detect missing entries in environments where
+        // durability or ordering is not guaranteed.
+        SequenceIdWithinCall uint64                 `protobuf:"varint,3,opt,name=sequence_id_within_call,json=sequenceIdWithinCall,proto3" json:"sequence_id_within_call,omitempty"`
+        Type                 GrpcLogEntry_EventType `protobuf:"varint,4,opt,name=type,proto3,enum=grpc.binarylog.v1.GrpcLogEntry_EventType" json:"type,omitempty"`
+        Logger               GrpcLogEntry_Logger    `protobuf:"varint,5,opt,name=logger,proto3,enum=grpc.binarylog.v1.GrpcLogEntry_Logger" json:"logger,omitempty"`
+        // The logger uses one of the following fields to record the payload,
+        // according to the type of the log entry.
+        //
+        // Types that are valid to be assigned to Payload:
+        //      *GrpcLogEntry_ClientHeader
+        //      *GrpcLogEntry_ServerHeader
+        //      *GrpcLogEntry_Message
+        //      *GrpcLogEntry_Trailer
+        Payload isGrpcLogEntry_Payload `protobuf_oneof:"payload"`
+        // true if payload does not represent the full message or metadata.
+        PayloadTruncated bool `protobuf:"varint,10,opt,name=payload_truncated,json=payloadTruncated,proto3" json:"payload_truncated,omitempty"`
+        // Peer address information, will only be recorded on the first
+        // incoming event. On client side, peer is logged on
+        // EVENT_TYPE_SERVER_HEADER normally or EVENT_TYPE_SERVER_TRAILER in
+        // the case of trailers-only. On server side, peer is always
+        // logged on EVENT_TYPE_CLIENT_HEADER.
+        Peer                 *Address `protobuf:"bytes,11,opt,name=peer,proto3" json:"peer,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GrpcLogEntry) Reset()         { *m = GrpcLogEntry{} }
+func (m *GrpcLogEntry) String() string { return proto.CompactTextString(m) }
+func (*GrpcLogEntry) ProtoMessage()    {}
+func (*GrpcLogEntry) Descriptor() ([]byte, []int) {
+        return fileDescriptor_binarylog_264c8c9c551ce911, []int{0}
+}
+func (m *GrpcLogEntry) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_GrpcLogEntry.Unmarshal(m, b)
+}
+func (m *GrpcLogEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_GrpcLogEntry.Marshal(b, m, deterministic)
+}
+func (dst *GrpcLogEntry) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_GrpcLogEntry.Merge(dst, src)
+}
+func (m *GrpcLogEntry) XXX_Size() int {
+        return xxx_messageInfo_GrpcLogEntry.Size(m)
+}
+func (m *GrpcLogEntry) XXX_DiscardUnknown() {
+        xxx_messageInfo_GrpcLogEntry.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GrpcLogEntry proto.InternalMessageInfo
+
+func (m *GrpcLogEntry) GetTimestamp() *timestamp.Timestamp {
+        if m != nil {
+                return m.Timestamp
+        }
+        return nil
+}
+
+func (m *GrpcLogEntry) GetCallId() uint64 {
+        if m != nil {
+                return m.CallId
+        }
+        return 0
+}
+
+func (m *GrpcLogEntry) GetSequenceIdWithinCall() uint64 {
+        if m != nil {
+                return m.SequenceIdWithinCall
+        }
+        return 0
+}
+
+func (m *GrpcLogEntry) GetType() GrpcLogEntry_EventType {
+        if m != nil {
+                return m.Type
+        }
+        return GrpcLogEntry_EVENT_TYPE_UNKNOWN
+}
+
+func (m *GrpcLogEntry) GetLogger() GrpcLogEntry_Logger {
+        if m != nil {
+                return m.Logger
+        }
+        return GrpcLogEntry_LOGGER_UNKNOWN
+}
+
+type isGrpcLogEntry_Payload interface {
+        isGrpcLogEntry_Payload()
+}
+
+type GrpcLogEntry_ClientHeader struct {
+        ClientHeader *ClientHeader `protobuf:"bytes,6,opt,name=client_header,json=clientHeader,proto3,oneof"`
+}
+
+type GrpcLogEntry_ServerHeader struct {
+        ServerHeader *ServerHeader `protobuf:"bytes,7,opt,name=server_header,json=serverHeader,proto3,oneof"`
+}
+
+type GrpcLogEntry_Message struct {
+        Message *Message `protobuf:"bytes,8,opt,name=message,proto3,oneof"`
+}
+
+type GrpcLogEntry_Trailer struct {
+        Trailer *Trailer `protobuf:"bytes,9,opt,name=trailer,proto3,oneof"`
+}
+
+func (*GrpcLogEntry_ClientHeader) isGrpcLogEntry_Payload() {}
+
+func (*GrpcLogEntry_ServerHeader) isGrpcLogEntry_Payload() {}
+
+func (*GrpcLogEntry_Message) isGrpcLogEntry_Payload() {}
+
+func (*GrpcLogEntry_Trailer) isGrpcLogEntry_Payload() {}
+
+func (m *GrpcLogEntry) GetPayload() isGrpcLogEntry_Payload {
+        if m != nil {
+                return m.Payload
+        }
+        return nil
+}
+
+func (m *GrpcLogEntry) GetClientHeader() *ClientHeader {
+        if x, ok := m.GetPayload().(*GrpcLogEntry_ClientHeader); ok {
+                return x.ClientHeader
+        }
+        return nil
+}
+
+func (m *GrpcLogEntry) GetServerHeader() *ServerHeader {
+        if x, ok := m.GetPayload().(*GrpcLogEntry_ServerHeader); ok {
+                return x.ServerHeader
+        }
+        return nil
+}
+
+func (m *GrpcLogEntry) GetMessage() *Message {
+        if x, ok := m.GetPayload().(*GrpcLogEntry_Message); ok {
+                return x.Message
+        }
+        return nil
+}
+
+func (m *GrpcLogEntry) GetTrailer() *Trailer {
+        if x, ok := m.GetPayload().(*GrpcLogEntry_Trailer); ok {
+                return x.Trailer
+        }
+        return nil
+}
+
+func (m *GrpcLogEntry) GetPayloadTruncated() bool {
+        if m != nil {
+                return m.PayloadTruncated
+        }
+        return false
+}
+
+func (m *GrpcLogEntry) GetPeer() *Address {
+        if m != nil {
+                return m.Peer
+        }
+        return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*GrpcLogEntry) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+        return _GrpcLogEntry_OneofMarshaler, _GrpcLogEntry_OneofUnmarshaler, _GrpcLogEntry_OneofSizer, []interface{}{
+                (*GrpcLogEntry_ClientHeader)(nil),
+                (*GrpcLogEntry_ServerHeader)(nil),
+                (*GrpcLogEntry_Message)(nil),
+                (*GrpcLogEntry_Trailer)(nil),
+        }
+}
+
+func _GrpcLogEntry_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+        m := msg.(*GrpcLogEntry)
+        // payload
+        switch x := m.Payload.(type) {
+        case *GrpcLogEntry_ClientHeader:
+                b.EncodeVarint(6<<3 | proto.WireBytes)
+                if err := b.EncodeMessage(x.ClientHeader); err != nil {
+                        return err
+                }
+        case *GrpcLogEntry_ServerHeader:
+                b.EncodeVarint(7<<3 | proto.WireBytes)
+                if err := b.EncodeMessage(x.ServerHeader); err != nil {
+                        return err
+                }
+        case *GrpcLogEntry_Message:
+                b.EncodeVarint(8<<3 | proto.WireBytes)
+                if err := b.EncodeMessage(x.Message); err != nil {
+                        return err
+                }
+        case *GrpcLogEntry_Trailer:
+                b.EncodeVarint(9<<3 | proto.WireBytes)
+                if err := b.EncodeMessage(x.Trailer); err != nil {
+                        return err
+                }
+        case nil:
+        default:
+                return fmt.Errorf("GrpcLogEntry.Payload has unexpected type %T", x)
+        }
+        return nil
+}
+
+func _GrpcLogEntry_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+        m := msg.(*GrpcLogEntry)
+        switch tag {
+        case 6: // payload.client_header
+                if wire != proto.WireBytes {
+                        return true, proto.ErrInternalBadWireType
+                }
+                msg := new(ClientHeader)
+                err := b.DecodeMessage(msg)
+                m.Payload = &GrpcLogEntry_ClientHeader{msg}
+                return true, err
+        case 7: // payload.server_header
+                if wire != proto.WireBytes {
+                        return true, proto.ErrInternalBadWireType
+                }
+                msg := new(ServerHeader)
+                err := b.DecodeMessage(msg)
+                m.Payload = &GrpcLogEntry_ServerHeader{msg}
+                return true, err
+        case 8: // payload.message
+                if wire != proto.WireBytes {
+                        return true, proto.ErrInternalBadWireType
+                }
+                msg := new(Message)
+                err := b.DecodeMessage(msg)
+                m.Payload = &GrpcLogEntry_Message{msg}
+                return true, err
+        case 9: // payload.trailer
+                if wire != proto.WireBytes {
+                        return true, proto.ErrInternalBadWireType
+                }
+                msg := new(Trailer)
+                err := b.DecodeMessage(msg)
+                m.Payload = &GrpcLogEntry_Trailer{msg}
+                return true, err
+        default:
+                return false, nil
+        }
+}
+
+func _GrpcLogEntry_OneofSizer(msg proto.Message) (n int) {
+        m := msg.(*GrpcLogEntry)
+        // payload
+        switch x := m.Payload.(type) {
+        case *GrpcLogEntry_ClientHeader:
+                s := proto.Size(x.ClientHeader)
+                n += 1 // tag and wire
+                n += proto.SizeVarint(uint64(s))
+                n += s
+        case *GrpcLogEntry_ServerHeader:
+                s := proto.Size(x.ServerHeader)
+                n += 1 // tag and wire
+                n += proto.SizeVarint(uint64(s))
+                n += s
+        case *GrpcLogEntry_Message:
+                s := proto.Size(x.Message)
+                n += 1 // tag and wire
+                n += proto.SizeVarint(uint64(s))
+                n += s
+        case *GrpcLogEntry_Trailer:
+                s := proto.Size(x.Trailer)
+                n += 1 // tag and wire
+                n += proto.SizeVarint(uint64(s))
+                n += s
+        case nil:
+        default:
+                panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+        }
+        return n
+}
+
+type ClientHeader struct {
+        // This contains only the metadata from the application.
+        Metadata *Metadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
+        // The name of the RPC method, which looks something like:
+        // /<service>/<method>
+        // Note the leading "/" character.
+        MethodName string `protobuf:"bytes,2,opt,name=method_name,json=methodName,proto3" json:"method_name,omitempty"`
+        // A single process may be used to run multiple virtual
+        // servers with different identities.
+        // The authority is the name of such a server identitiy.
+        // It is typically a portion of the URI in the form of
+        // <host> or <host>:<port> .
+        Authority string `protobuf:"bytes,3,opt,name=authority,proto3" json:"authority,omitempty"`
+        // the RPC timeout
+        Timeout              *duration.Duration `protobuf:"bytes,4,opt,name=timeout,proto3" json:"timeout,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}           `json:"-"`
+        XXX_unrecognized     []byte             `json:"-"`
+        XXX_sizecache        int32              `json:"-"`
+}
+
+func (m *ClientHeader) Reset()         { *m = ClientHeader{} }
+func (m *ClientHeader) String() string { return proto.CompactTextString(m) }
+func (*ClientHeader) ProtoMessage()    {}
+func (*ClientHeader) Descriptor() ([]byte, []int) {
+        return fileDescriptor_binarylog_264c8c9c551ce911, []int{1}
+}
+func (m *ClientHeader) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_ClientHeader.Unmarshal(m, b)
+}
+func (m *ClientHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_ClientHeader.Marshal(b, m, deterministic)
+}
+func (dst *ClientHeader) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_ClientHeader.Merge(dst, src)
+}
+func (m *ClientHeader) XXX_Size() int {
+        return xxx_messageInfo_ClientHeader.Size(m)
+}
+func (m *ClientHeader) XXX_DiscardUnknown() {
+        xxx_messageInfo_ClientHeader.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ClientHeader proto.InternalMessageInfo
+
+func (m *ClientHeader) GetMetadata() *Metadata {
+        if m != nil {
+                return m.Metadata
+        }
+        return nil
+}
+
+func (m *ClientHeader) GetMethodName() string {
+        if m != nil {
+                return m.MethodName
+        }
+        return ""
+}
+
+func (m *ClientHeader) GetAuthority() string {
+        if m != nil {
+                return m.Authority
+        }
+        return ""
+}
+
+func (m *ClientHeader) GetTimeout() *duration.Duration {
+        if m != nil {
+                return m.Timeout
+        }
+        return nil
+}
+
+type ServerHeader struct {
+        // This contains only the metadata from the application.
+        Metadata             *Metadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}  `json:"-"`
+        XXX_unrecognized     []byte    `json:"-"`
+        XXX_sizecache        int32     `json:"-"`
+}
+
+func (m *ServerHeader) Reset()         { *m = ServerHeader{} }
+func (m *ServerHeader) String() string { return proto.CompactTextString(m) }
+func (*ServerHeader) ProtoMessage()    {}
+func (*ServerHeader) Descriptor() ([]byte, []int) {
+        return fileDescriptor_binarylog_264c8c9c551ce911, []int{2}
+}
+func (m *ServerHeader) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_ServerHeader.Unmarshal(m, b)
+}
+func (m *ServerHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_ServerHeader.Marshal(b, m, deterministic)
+}
+func (dst *ServerHeader) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_ServerHeader.Merge(dst, src)
+}
+func (m *ServerHeader) XXX_Size() int {
+        return xxx_messageInfo_ServerHeader.Size(m)
+}
+func (m *ServerHeader) XXX_DiscardUnknown() {
+        xxx_messageInfo_ServerHeader.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServerHeader proto.InternalMessageInfo
+
+func (m *ServerHeader) GetMetadata() *Metadata {
+        if m != nil {
+                return m.Metadata
+        }
+        return nil
+}
+
+type Trailer struct {
+        // This contains only the metadata from the application.
+        Metadata *Metadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
+        // The gRPC status code.
+        StatusCode uint32 `protobuf:"varint,2,opt,name=status_code,json=statusCode,proto3" json:"status_code,omitempty"`
+        // An original status message before any transport specific
+        // encoding.
+        StatusMessage string `protobuf:"bytes,3,opt,name=status_message,json=statusMessage,proto3" json:"status_message,omitempty"`
+        // The value of the 'grpc-status-details-bin' metadata key. If
+        // present, this is always an encoded 'google.rpc.Status' message.
+        StatusDetails        []byte   `protobuf:"bytes,4,opt,name=status_details,json=statusDetails,proto3" json:"status_details,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Trailer) Reset()         { *m = Trailer{} }
+func (m *Trailer) String() string { return proto.CompactTextString(m) }
+func (*Trailer) ProtoMessage()    {}
+func (*Trailer) Descriptor() ([]byte, []int) {
+        return fileDescriptor_binarylog_264c8c9c551ce911, []int{3}
+}
+func (m *Trailer) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Trailer.Unmarshal(m, b)
+}
+func (m *Trailer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Trailer.Marshal(b, m, deterministic)
+}
+func (dst *Trailer) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Trailer.Merge(dst, src)
+}
+func (m *Trailer) XXX_Size() int {
+        return xxx_messageInfo_Trailer.Size(m)
+}
+func (m *Trailer) XXX_DiscardUnknown() {
+        xxx_messageInfo_Trailer.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Trailer proto.InternalMessageInfo
+
+func (m *Trailer) GetMetadata() *Metadata {
+        if m != nil {
+                return m.Metadata
+        }
+        return nil
+}
+
+func (m *Trailer) GetStatusCode() uint32 {
+        if m != nil {
+                return m.StatusCode
+        }
+        return 0
+}
+
+func (m *Trailer) GetStatusMessage() string {
+        if m != nil {
+                return m.StatusMessage
+        }
+        return ""
+}
+
+func (m *Trailer) GetStatusDetails() []byte {
+        if m != nil {
+                return m.StatusDetails
+        }
+        return nil
+}
+
+// Message payload, used by CLIENT_MESSAGE and SERVER_MESSAGE
+type Message struct {
+        // Length of the message. It may not be the same as the length of the
+        // data field, as the logging payload can be truncated or omitted.
+        Length uint32 `protobuf:"varint,1,opt,name=length,proto3" json:"length,omitempty"`
+        // May be truncated or omitted.
+        Data                 []byte   `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Message) Reset()         { *m = Message{} }
+func (m *Message) String() string { return proto.CompactTextString(m) }
+func (*Message) ProtoMessage()    {}
+func (*Message) Descriptor() ([]byte, []int) {
+        return fileDescriptor_binarylog_264c8c9c551ce911, []int{4}
+}
+func (m *Message) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Message.Unmarshal(m, b)
+}
+func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Message.Marshal(b, m, deterministic)
+}
+func (dst *Message) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Message.Merge(dst, src)
+}
+func (m *Message) XXX_Size() int {
+        return xxx_messageInfo_Message.Size(m)
+}
+func (m *Message) XXX_DiscardUnknown() {
+        xxx_messageInfo_Message.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Message proto.InternalMessageInfo
+
+func (m *Message) GetLength() uint32 {
+        if m != nil {
+                return m.Length
+        }
+        return 0
+}
+
+func (m *Message) GetData() []byte {
+        if m != nil {
+                return m.Data
+        }
+        return nil
+}
+
+// A list of metadata pairs, used in the payload of client header,
+// server header, and server trailer.
+// Implementations may omit some entries to honor the header limits
+// of GRPC_BINARY_LOG_CONFIG.
+//
+// Header keys added by gRPC are omitted. To be more specific,
+// implementations will not log the following entries, and this is
+// not to be treated as a truncation:
+// - entries handled by grpc that are not user visible, such as those
+//   that begin with 'grpc-' (with exception of grpc-trace-bin)
+//   or keys like 'lb-token'
+// - transport specific entries, including but not limited to:
+//   ':path', ':authority', 'content-encoding', 'user-agent', 'te', etc
+// - entries added for call credentials
+//
+// Implementations must always log grpc-trace-bin if it is present.
+// Practically speaking it will only be visible on server side because
+// grpc-trace-bin is managed by low level client side mechanisms
+// inaccessible from the application level. On server side, the
+// header is just a normal metadata key.
+// The pair will not count towards the size limit.
+type Metadata struct {
+        Entry                []*MetadataEntry `protobuf:"bytes,1,rep,name=entry,proto3" json:"entry,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+        XXX_unrecognized     []byte           `json:"-"`
+        XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *Metadata) Reset()         { *m = Metadata{} }
+func (m *Metadata) String() string { return proto.CompactTextString(m) }
+func (*Metadata) ProtoMessage()    {}
+func (*Metadata) Descriptor() ([]byte, []int) {
+        return fileDescriptor_binarylog_264c8c9c551ce911, []int{5}
+}
+func (m *Metadata) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Metadata.Unmarshal(m, b)
+}
+func (m *Metadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Metadata.Marshal(b, m, deterministic)
+}
+func (dst *Metadata) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Metadata.Merge(dst, src)
+}
+func (m *Metadata) XXX_Size() int {
+        return xxx_messageInfo_Metadata.Size(m)
+}
+func (m *Metadata) XXX_DiscardUnknown() {
+        xxx_messageInfo_Metadata.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Metadata proto.InternalMessageInfo
+
+func (m *Metadata) GetEntry() []*MetadataEntry {
+        if m != nil {
+                return m.Entry
+        }
+        return nil
+}
+
+// A metadata key value pair
+type MetadataEntry struct {
+        Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+        Value                []byte   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *MetadataEntry) Reset()         { *m = MetadataEntry{} }
+func (m *MetadataEntry) String() string { return proto.CompactTextString(m) }
+func (*MetadataEntry) ProtoMessage()    {}
+func (*MetadataEntry) Descriptor() ([]byte, []int) {
+        return fileDescriptor_binarylog_264c8c9c551ce911, []int{6}
+}
+func (m *MetadataEntry) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_MetadataEntry.Unmarshal(m, b)
+}
+func (m *MetadataEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_MetadataEntry.Marshal(b, m, deterministic)
+}
+func (dst *MetadataEntry) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_MetadataEntry.Merge(dst, src)
+}
+func (m *MetadataEntry) XXX_Size() int {
+        return xxx_messageInfo_MetadataEntry.Size(m)
+}
+func (m *MetadataEntry) XXX_DiscardUnknown() {
+        xxx_messageInfo_MetadataEntry.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MetadataEntry proto.InternalMessageInfo
+
+func (m *MetadataEntry) GetKey() string {
+        if m != nil {
+                return m.Key
+        }
+        return ""
+}
+
+func (m *MetadataEntry) GetValue() []byte {
+        if m != nil {
+                return m.Value
+        }
+        return nil
+}
+
+// Address information
+type Address struct {
+        Type    Address_Type `protobuf:"varint,1,opt,name=type,proto3,enum=grpc.binarylog.v1.Address_Type" json:"type,omitempty"`
+        Address string       `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
+        // only for TYPE_IPV4 and TYPE_IPV6
+        IpPort               uint32   `protobuf:"varint,3,opt,name=ip_port,json=ipPort,proto3" json:"ip_port,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Address) Reset()         { *m = Address{} }
+func (m *Address) String() string { return proto.CompactTextString(m) }
+func (*Address) ProtoMessage()    {}
+func (*Address) Descriptor() ([]byte, []int) {
+        return fileDescriptor_binarylog_264c8c9c551ce911, []int{7}
+}
+func (m *Address) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_Address.Unmarshal(m, b)
+}
+func (m *Address) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_Address.Marshal(b, m, deterministic)
+}
+func (dst *Address) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_Address.Merge(dst, src)
+}
+func (m *Address) XXX_Size() int {
+        return xxx_messageInfo_Address.Size(m)
+}
+func (m *Address) XXX_DiscardUnknown() {
+        xxx_messageInfo_Address.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Address proto.InternalMessageInfo
+
+func (m *Address) GetType() Address_Type {
+        if m != nil {
+                return m.Type
+        }
+        return Address_TYPE_UNKNOWN
+}
+
+func (m *Address) GetAddress() string {
+        if m != nil {
+                return m.Address
+        }
+        return ""
+}
+
+func (m *Address) GetIpPort() uint32 {
+        if m != nil {
+                return m.IpPort
+        }
+        return 0
+}
+
+func init() {
+        proto.RegisterType((*GrpcLogEntry)(nil), "grpc.binarylog.v1.GrpcLogEntry")
+        proto.RegisterType((*ClientHeader)(nil), "grpc.binarylog.v1.ClientHeader")
+        proto.RegisterType((*ServerHeader)(nil), "grpc.binarylog.v1.ServerHeader")
+        proto.RegisterType((*Trailer)(nil), "grpc.binarylog.v1.Trailer")
+        proto.RegisterType((*Message)(nil), "grpc.binarylog.v1.Message")
+        proto.RegisterType((*Metadata)(nil), "grpc.binarylog.v1.Metadata")
+        proto.RegisterType((*MetadataEntry)(nil), "grpc.binarylog.v1.MetadataEntry")
+        proto.RegisterType((*Address)(nil), "grpc.binarylog.v1.Address")
+        proto.RegisterEnum("grpc.binarylog.v1.GrpcLogEntry_EventType", GrpcLogEntry_EventType_name, GrpcLogEntry_EventType_value)
+        proto.RegisterEnum("grpc.binarylog.v1.GrpcLogEntry_Logger", GrpcLogEntry_Logger_name, GrpcLogEntry_Logger_value)
+        proto.RegisterEnum("grpc.binarylog.v1.Address_Type", Address_Type_name, Address_Type_value)
+}
+
+func init() {
+        proto.RegisterFile("grpc/binarylog/grpc_binarylog_v1/binarylog.proto", fileDescriptor_binarylog_264c8c9c551ce911)
+}
+
+var fileDescriptor_binarylog_264c8c9c551ce911 = []byte{
+        // 900 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0x51, 0x6f, 0xe3, 0x44,
+        0x10, 0x3e, 0x37, 0x69, 0xdc, 0x4c, 0x92, 0xca, 0x5d, 0x95, 0x3b, 0x5f, 0x29, 0x34, 0xb2, 0x04,
+        0x0a, 0x42, 0x72, 0xb9, 0x94, 0xeb, 0xf1, 0x02, 0x52, 0x92, 0xfa, 0xd2, 0x88, 0x5c, 0x1a, 0x6d,
+        0x72, 0x3d, 0x40, 0x48, 0xd6, 0x36, 0x5e, 0x1c, 0x0b, 0xc7, 0x6b, 0xd6, 0x9b, 0xa0, 0xfc, 0x2c,
+        0xde, 0x90, 0xee, 0x77, 0xf1, 0x8e, 0xbc, 0x6b, 0x27, 0xa6, 0x69, 0x0f, 0x09, 0xde, 0x3c, 0xdf,
+        0x7c, 0xf3, 0xcd, 0xee, 0x78, 0x66, 0x16, 0xbe, 0xf2, 0x79, 0x3c, 0x3b, 0xbf, 0x0b, 0x22, 0xc2,
+        0xd7, 0x21, 0xf3, 0xcf, 0x53, 0xd3, 0xdd, 0x98, 0xee, 0xea, 0xc5, 0xd6, 0x67, 0xc7, 0x9c, 0x09,
+        0x86, 0x8e, 0x52, 0x8a, 0xbd, 0x45, 0x57, 0x2f, 0x4e, 0x3e, 0xf5, 0x19, 0xf3, 0x43, 0x7a, 0x2e,
+        0x09, 0x77, 0xcb, 0x5f, 0xce, 0xbd, 0x25, 0x27, 0x22, 0x60, 0x91, 0x0a, 0x39, 0x39, 0xbb, 0xef,
+        0x17, 0xc1, 0x82, 0x26, 0x82, 0x2c, 0x62, 0x45, 0xb0, 0xde, 0xeb, 0x50, 0xef, 0xf3, 0x78, 0x36,
+        0x64, 0xbe, 0x13, 0x09, 0xbe, 0x46, 0xdf, 0x40, 0x75, 0xc3, 0x31, 0xb5, 0xa6, 0xd6, 0xaa, 0xb5,
+        0x4f, 0x6c, 0xa5, 0x62, 0xe7, 0x2a, 0xf6, 0x34, 0x67, 0xe0, 0x2d, 0x19, 0x3d, 0x03, 0x7d, 0x46,
+        0xc2, 0xd0, 0x0d, 0x3c, 0x73, 0xaf, 0xa9, 0xb5, 0xca, 0xb8, 0x92, 0x9a, 0x03, 0x0f, 0xbd, 0x84,
+        0x67, 0x09, 0xfd, 0x6d, 0x49, 0xa3, 0x19, 0x75, 0x03, 0xcf, 0xfd, 0x3d, 0x10, 0xf3, 0x20, 0x72,
+        0x53, 0xa7, 0x59, 0x92, 0xc4, 0xe3, 0xdc, 0x3d, 0xf0, 0xde, 0x49, 0x67, 0x8f, 0x84, 0x21, 0xfa,
+        0x16, 0xca, 0x62, 0x1d, 0x53, 0xb3, 0xdc, 0xd4, 0x5a, 0x87, 0xed, 0x2f, 0xec, 0x9d, 0xdb, 0xdb,
+        0xc5, 0x83, 0xdb, 0xce, 0x8a, 0x46, 0x62, 0xba, 0x8e, 0x29, 0x96, 0x61, 0xe8, 0x3b, 0xa8, 0x84,
+        0xcc, 0xf7, 0x29, 0x37, 0xf7, 0xa5, 0xc0, 0xe7, 0xff, 0x26, 0x30, 0x94, 0x6c, 0x9c, 0x45, 0xa1,
+        0xd7, 0xd0, 0x98, 0x85, 0x01, 0x8d, 0x84, 0x3b, 0xa7, 0xc4, 0xa3, 0xdc, 0xac, 0xc8, 0x62, 0x9c,
+        0x3d, 0x20, 0xd3, 0x93, 0xbc, 0x6b, 0x49, 0xbb, 0x7e, 0x82, 0xeb, 0xb3, 0x82, 0x9d, 0xea, 0x24,
+        0x94, 0xaf, 0x28, 0xcf, 0x75, 0xf4, 0x47, 0x75, 0x26, 0x92, 0xb7, 0xd5, 0x49, 0x0a, 0x36, 0xba,
+        0x04, 0x7d, 0x41, 0x93, 0x84, 0xf8, 0xd4, 0x3c, 0xc8, 0x7f, 0xcb, 0x8e, 0xc2, 0x1b, 0xc5, 0xb8,
+        0x7e, 0x82, 0x73, 0x72, 0x1a, 0x27, 0x38, 0x09, 0x42, 0xca, 0xcd, 0xea, 0xa3, 0x71, 0x53, 0xc5,
+        0x48, 0xe3, 0x32, 0x32, 0xfa, 0x12, 0x8e, 0x62, 0xb2, 0x0e, 0x19, 0xf1, 0x5c, 0xc1, 0x97, 0xd1,
+        0x8c, 0x08, 0xea, 0x99, 0xd0, 0xd4, 0x5a, 0x07, 0xd8, 0xc8, 0x1c, 0xd3, 0x1c, 0x47, 0x36, 0x94,
+        0x63, 0x4a, 0xb9, 0x59, 0x7b, 0x34, 0x43, 0xc7, 0xf3, 0x38, 0x4d, 0x12, 0x2c, 0x79, 0xd6, 0x5f,
+        0x1a, 0x54, 0x37, 0x3f, 0x0c, 0x3d, 0x05, 0xe4, 0xdc, 0x3a, 0xa3, 0xa9, 0x3b, 0xfd, 0x71, 0xec,
+        0xb8, 0x6f, 0x47, 0xdf, 0x8f, 0x6e, 0xde, 0x8d, 0x8c, 0x27, 0xe8, 0x14, 0xcc, 0x02, 0xde, 0x1b,
+        0x0e, 0xd2, 0xef, 0x6b, 0xa7, 0x73, 0xe5, 0x60, 0x43, 0xbb, 0xe7, 0x9d, 0x38, 0xf8, 0xd6, 0xc1,
+        0xb9, 0x77, 0x0f, 0x7d, 0x02, 0xcf, 0x77, 0x63, 0xdf, 0x38, 0x93, 0x49, 0xa7, 0xef, 0x18, 0xa5,
+        0x7b, 0xee, 0x2c, 0x38, 0x77, 0x97, 0x51, 0x13, 0x4e, 0x1f, 0xc8, 0xdc, 0x19, 0xbe, 0x76, 0x7b,
+        0xc3, 0x9b, 0x89, 0x63, 0xec, 0x3f, 0x2c, 0x30, 0xc5, 0x9d, 0xc1, 0xd0, 0xc1, 0x46, 0x05, 0x7d,
+        0x04, 0x47, 0x45, 0x81, 0xce, 0xa8, 0xe7, 0x0c, 0x0d, 0xdd, 0xea, 0x42, 0x45, 0xb5, 0x19, 0x42,
+        0x70, 0x38, 0xbc, 0xe9, 0xf7, 0x1d, 0x5c, 0xb8, 0xef, 0x11, 0x34, 0x32, 0x4c, 0x65, 0x34, 0xb4,
+        0x02, 0xa4, 0x52, 0x18, 0x7b, 0xdd, 0x2a, 0xe8, 0x59, 0xfd, 0xad, 0xf7, 0x1a, 0xd4, 0x8b, 0xcd,
+        0x87, 0x5e, 0xc1, 0xc1, 0x82, 0x0a, 0xe2, 0x11, 0x41, 0xb2, 0xe1, 0xfd, 0xf8, 0xc1, 0x2e, 0x51,
+        0x14, 0xbc, 0x21, 0xa3, 0x33, 0xa8, 0x2d, 0xa8, 0x98, 0x33, 0xcf, 0x8d, 0xc8, 0x82, 0xca, 0x01,
+        0xae, 0x62, 0x50, 0xd0, 0x88, 0x2c, 0x28, 0x3a, 0x85, 0x2a, 0x59, 0x8a, 0x39, 0xe3, 0x81, 0x58,
+        0xcb, 0xb1, 0xad, 0xe2, 0x2d, 0x80, 0x2e, 0x40, 0x4f, 0x17, 0x01, 0x5b, 0x0a, 0x39, 0xae, 0xb5,
+        0xf6, 0xf3, 0x9d, 0x9d, 0x71, 0x95, 0x6d, 0x26, 0x9c, 0x33, 0xad, 0x3e, 0xd4, 0x8b, 0x1d, 0xff,
+        0x9f, 0x0f, 0x6f, 0xfd, 0xa1, 0x81, 0x9e, 0x75, 0xf0, 0xff, 0xaa, 0x40, 0x22, 0x88, 0x58, 0x26,
+        0xee, 0x8c, 0x79, 0xaa, 0x02, 0x0d, 0x0c, 0x0a, 0xea, 0x31, 0x8f, 0xa2, 0xcf, 0xe0, 0x30, 0x23,
+        0xe4, 0x73, 0xa8, 0xca, 0xd0, 0x50, 0x68, 0x36, 0x7a, 0x05, 0x9a, 0x47, 0x05, 0x09, 0xc2, 0x44,
+        0x56, 0xa4, 0x9e, 0xd3, 0xae, 0x14, 0x68, 0xbd, 0x04, 0x3d, 0x8f, 0x78, 0x0a, 0x95, 0x90, 0x46,
+        0xbe, 0x98, 0xcb, 0x03, 0x37, 0x70, 0x66, 0x21, 0x04, 0x65, 0x79, 0x8d, 0x3d, 0x19, 0x2f, 0xbf,
+        0xad, 0x2e, 0x1c, 0xe4, 0x67, 0x47, 0x97, 0xb0, 0x4f, 0xd3, 0xcd, 0x65, 0x6a, 0xcd, 0x52, 0xab,
+        0xd6, 0x6e, 0x7e, 0xe0, 0x9e, 0x72, 0xc3, 0x61, 0x45, 0xb7, 0x5e, 0x41, 0xe3, 0x1f, 0x38, 0x32,
+        0xa0, 0xf4, 0x2b, 0x5d, 0xcb, 0xec, 0x55, 0x9c, 0x7e, 0xa2, 0x63, 0xd8, 0x5f, 0x91, 0x70, 0x49,
+        0xb3, 0xdc, 0xca, 0xb0, 0xfe, 0xd4, 0x40, 0xcf, 0xe6, 0x18, 0x5d, 0x64, 0xdb, 0x59, 0x93, 0xcb,
+        0xf5, 0xec, 0xf1, 0x89, 0xb7, 0x0b, 0x3b, 0xd9, 0x04, 0x9d, 0x28, 0x34, 0xeb, 0xb0, 0xdc, 0x4c,
+        0x1f, 0x8f, 0x20, 0x76, 0x63, 0xc6, 0x85, 0xac, 0x6a, 0x03, 0x57, 0x82, 0x78, 0xcc, 0xb8, 0xb0,
+        0x1c, 0x28, 0xcb, 0x1d, 0x61, 0x40, 0xfd, 0xde, 0x76, 0x68, 0x40, 0x55, 0x22, 0x83, 0xf1, 0xed,
+        0xd7, 0x86, 0x56, 0x34, 0x2f, 0x8d, 0xbd, 0x8d, 0xf9, 0x76, 0x34, 0xf8, 0xc1, 0x28, 0x75, 0x7f,
+        0x86, 0xe3, 0x80, 0xed, 0x1e, 0xb2, 0x7b, 0xd8, 0x95, 0xd6, 0x90, 0xf9, 0xe3, 0xb4, 0x51, 0xc7,
+        0xda, 0x4f, 0xed, 0xac, 0x71, 0x7d, 0x16, 0x92, 0xc8, 0xb7, 0x19, 0x57, 0x4f, 0xf3, 0x87, 0x5e,
+        0xea, 0xbb, 0x8a, 0xec, 0xf2, 0x8b, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0xe7, 0xf6, 0x4b, 0x50,
+        0xd4, 0x07, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/grpc/call.go b/vendor/google.golang.org/grpc/call.go
index 797190f..100f05d 100644
--- a/vendor/google.golang.org/grpc/call.go
+++ b/vendor/google.golang.org/grpc/call.go
@@ -19,291 +19,56 @@
 package grpc
 
 import (
-        "bytes"
-        "io"
-        "time"
-
-        "golang.org/x/net/context"
-        "golang.org/x/net/trace"
-        "google.golang.org/grpc/codes"
-        "google.golang.org/grpc/peer"
-        "google.golang.org/grpc/stats"
-        "google.golang.org/grpc/status"
-        "google.golang.org/grpc/transport"
+        "context"
 )
 
-// recvResponse receives and parses an RPC response.
-// On error, it returns the error and indicates whether the call should be retried.
+// Invoke sends the RPC request on the wire and returns after response is
+// received.  This is typically called by generated code.
 //
-// TODO(zhaoq): Check whether the received message sequence is valid.
-// TODO ctx is used for stats collection and processing. It is the context passed from the application.
-func recvResponse(ctx context.Context, dopts dialOptions, t transport.ClientTransport, c *callInfo, stream *transport.Stream, reply interface{}) (err error) {
-        // Try to acquire header metadata from the server if there is any.
-        defer func() {
-                if err != nil {
-                        if _, ok := err.(transport.ConnectionError); !ok {
-                                t.CloseStream(stream, err)
-                        }
-                }
-        }()
-        c.headerMD, err = stream.Header()
-        if err != nil {
-                return
-        }
-        p := &parser{r: stream}
-        var inPayload *stats.InPayload
-        if dopts.copts.StatsHandler != nil {
-                inPayload = &stats.InPayload{
-                        Client: true,
-                }
-        }
-        for {
-                if c.maxReceiveMessageSize == nil {
-                        return Errorf(codes.Internal, "callInfo maxReceiveMessageSize field uninitialized(nil)")
-                }
-                if err = recv(p, dopts.codec, stream, dopts.dc, reply, *c.maxReceiveMessageSize, inPayload); err != nil {
-                        if err == io.EOF {
-                                break
-                        }
-                        return
-                }
-        }
-        if inPayload != nil && err == io.EOF && stream.Status().Code() == codes.OK {
-                // TODO in the current implementation, inTrailer may be handled before inPayload in some cases.
-                // Fix the order if necessary.
-                dopts.copts.StatsHandler.HandleRPC(ctx, inPayload)
-        }
-        c.trailerMD = stream.Trailer()
-        return nil
-}
-
-// sendRequest writes out various information of an RPC such as Context and Message.
-func sendRequest(ctx context.Context, dopts dialOptions, compressor Compressor, c *callInfo, callHdr *transport.CallHdr, stream *transport.Stream, t transport.ClientTransport, args interface{}, opts *transport.Options) (err error) {
-        defer func() {
-                if err != nil {
-                        // If err is connection error, t will be closed, no need to close stream here.
-                        if _, ok := err.(transport.ConnectionError); !ok {
-                                t.CloseStream(stream, err)
-                        }
-                }
-        }()
-        var (
-                cbuf       *bytes.Buffer
-                outPayload *stats.OutPayload
-        )
-        if compressor != nil {
-                cbuf = new(bytes.Buffer)
-        }
-        if dopts.copts.StatsHandler != nil {
-                outPayload = &stats.OutPayload{
-                        Client: true,
-                }
-        }
-        outBuf, err := encode(dopts.codec, args, compressor, cbuf, outPayload)
-        if err != nil {
-                return err
-        }
-        if c.maxSendMessageSize == nil {
-                return Errorf(codes.Internal, "callInfo maxSendMessageSize field uninitialized(nil)")
-        }
-        if len(outBuf) > *c.maxSendMessageSize {
-                return Errorf(codes.ResourceExhausted, "grpc: trying to send message larger than max (%d vs. %d)", len(outBuf), *c.maxSendMessageSize)
-        }
-        err = t.Write(stream, outBuf, opts)
-        if err == nil && outPayload != nil {
-                outPayload.SentTime = time.Now()
-                dopts.copts.StatsHandler.HandleRPC(ctx, outPayload)
-        }
-        // t.NewStream(...) could lead to an early rejection of the RPC (e.g., the service/method
-        // does not exist.) so that t.Write could get io.EOF from wait(...). Leave the following
-        // recvResponse to get the final status.
-        if err != nil && err != io.EOF {
-                return err
-        }
-        // Sent successfully.
-        return nil
-}
+// All errors returned by Invoke are compatible with the status package.
+func (cc *ClientConn) Invoke(ctx context.Context, method string, args, reply interface{}, opts ...CallOption) error {
+        // allow interceptor to see all applicable call options, which means those
+        // configured as defaults from dial option as well as per-call options
+        opts = combine(cc.dopts.callOptions, opts)
 
-// Invoke sends the RPC request on the wire and returns after response is received.
-// Invoke is called by generated code. Also users can call Invoke directly when it
-// is really needed in their use cases.
-func Invoke(ctx context.Context, method string, args, reply interface{}, cc *ClientConn, opts ...CallOption) error {
         if cc.dopts.unaryInt != nil {
                 return cc.dopts.unaryInt(ctx, method, args, reply, cc, invoke, opts...)
         }
         return invoke(ctx, method, args, reply, cc, opts...)
 }
 
-func invoke(ctx context.Context, method string, args, reply interface{}, cc *ClientConn, opts ...CallOption) (e error) {
-        c := defaultCallInfo
-        mc := cc.GetMethodConfig(method)
-        if mc.WaitForReady != nil {
-                c.failFast = !*mc.WaitForReady
-        }
-
-        if mc.Timeout != nil && *mc.Timeout >= 0 {
-                var cancel context.CancelFunc
-                ctx, cancel = context.WithTimeout(ctx, *mc.Timeout)
-                defer cancel()
-        }
+func combine(o1 []CallOption, o2 []CallOption) []CallOption {
+        // we don't use append because o1 could have extra capacity whose
+        // elements would be overwritten, which could cause inadvertent
+        // sharing (and race connditions) between concurrent calls
+        if len(o1) == 0 {
+                return o2
+        } else if len(o2) == 0 {
+                return o1
+        }
+        ret := make([]CallOption, len(o1)+len(o2))
+        copy(ret, o1)
+        copy(ret[len(o1):], o2)
+        return ret
+}
 
-        opts = append(cc.dopts.callOptions, opts...)
-        for _, o := range opts {
-                if err := o.before(&c); err != nil {
-                        return toRPCErr(err)
-                }
-        }
-        defer func() {
-                for _, o := range opts {
-                        o.after(&c)
-                }
-        }()
+// Invoke sends the RPC request on the wire and returns after response is
+// received.  This is typically called by generated code.
+//
+// DEPRECATED: Use ClientConn.Invoke instead.
+func Invoke(ctx context.Context, method string, args, reply interface{}, cc *ClientConn, opts ...CallOption) error {
+        return cc.Invoke(ctx, method, args, reply, opts...)
+}
 
-        c.maxSendMessageSize = getMaxSize(mc.MaxReqSize, c.maxSendMessageSize, defaultClientMaxSendMessageSize)
-        c.maxReceiveMessageSize = getMaxSize(mc.MaxRespSize, c.maxReceiveMessageSize, defaultClientMaxReceiveMessageSize)
+var unaryStreamDesc = &StreamDesc{ServerStreams: false, ClientStreams: false}
 
-        if EnableTracing {
-                c.traceInfo.tr = trace.New("grpc.Sent."+methodFamily(method), method)
-                defer c.traceInfo.tr.Finish()
-                c.traceInfo.firstLine.client = true
-                if deadline, ok := ctx.Deadline(); ok {
-                        c.traceInfo.firstLine.deadline = deadline.Sub(time.Now())
-                }
-                c.traceInfo.tr.LazyLog(&c.traceInfo.firstLine, false)
-                // TODO(dsymonds): Arrange for c.traceInfo.firstLine.remoteAddr to be set.
-                defer func() {
-                        if e != nil {
-                                c.traceInfo.tr.LazyLog(&fmtStringer{"%v", []interface{}{e}}, true)
-                                c.traceInfo.tr.SetError()
-                        }
-                }()
-        }
-        ctx = newContextWithRPCInfo(ctx)
-        sh := cc.dopts.copts.StatsHandler
-        if sh != nil {
-                ctx = sh.TagRPC(ctx, &stats.RPCTagInfo{FullMethodName: method, FailFast: c.failFast})
-                begin := &stats.Begin{
-                        Client:    true,
-                        BeginTime: time.Now(),
-                        FailFast:  c.failFast,
-                }
-                sh.HandleRPC(ctx, begin)
-                defer func() {
-                        end := &stats.End{
-                                Client:  true,
-                                EndTime: time.Now(),
-                                Error:   e,
-                        }
-                        sh.HandleRPC(ctx, end)
-                }()
-        }
-        topts := &transport.Options{
-                Last:  true,
-                Delay: false,
+func invoke(ctx context.Context, method string, req, reply interface{}, cc *ClientConn, opts ...CallOption) error {
+        cs, err := newClientStream(ctx, unaryStreamDesc, cc, method, opts...)
+        if err != nil {
+                return err
         }
-        for {
-                var (
-                        err    error
-                        t      transport.ClientTransport
-                        stream *transport.Stream
-                        // Record the put handler from Balancer.Get(...). It is called once the
-                        // RPC has completed or failed.
-                        put func()
-                )
-                // TODO(zhaoq): Need a formal spec of fail-fast.
-                callHdr := &transport.CallHdr{
-                        Host:   cc.authority,
-                        Method: method,
-                }
-                if cc.dopts.cp != nil {
-                        callHdr.SendCompress = cc.dopts.cp.Type()
-                }
-                if c.creds != nil {
-                        callHdr.Creds = c.creds
-                }
-
-                gopts := BalancerGetOptions{
-                        BlockingWait: !c.failFast,
-                }
-                t, put, err = cc.getTransport(ctx, gopts)
-                if err != nil {
-                        // TODO(zhaoq): Probably revisit the error handling.
-                        if _, ok := status.FromError(err); ok {
-                                return err
-                        }
-                        if err == errConnClosing || err == errConnUnavailable {
-                                if c.failFast {
-                                        return Errorf(codes.Unavailable, "%v", err)
-                                }
-                                continue
-                        }
-                        // All the other errors are treated as Internal errors.
-                        return Errorf(codes.Internal, "%v", err)
-                }
-                if c.traceInfo.tr != nil {
-                        c.traceInfo.tr.LazyLog(&payload{sent: true, msg: args}, true)
-                }
-                stream, err = t.NewStream(ctx, callHdr)
-                if err != nil {
-                        if put != nil {
-                                if _, ok := err.(transport.ConnectionError); ok {
-                                        // If error is connection error, transport was sending data on wire,
-                                        // and we are not sure if anything has been sent on wire.
-                                        // If error is not connection error, we are sure nothing has been sent.
-                                        updateRPCInfoInContext(ctx, rpcInfo{bytesSent: true, bytesReceived: false})
-                                }
-                                put()
-                        }
-                        if _, ok := err.(transport.ConnectionError); (ok || err == transport.ErrStreamDrain) && !c.failFast {
-                                continue
-                        }
-                        return toRPCErr(err)
-                }
-                if peer, ok := peer.FromContext(stream.Context()); ok {
-                        c.peer = peer
-                }
-                err = sendRequest(ctx, cc.dopts, cc.dopts.cp, &c, callHdr, stream, t, args, topts)
-                if err != nil {
-                        if put != nil {
-                                updateRPCInfoInContext(ctx, rpcInfo{
-                                        bytesSent:     stream.BytesSent(),
-                                        bytesReceived: stream.BytesReceived(),
-                                })
-                                put()
-                        }
-                        // Retry a non-failfast RPC when
-                        // i) there is a connection error; or
-                        // ii) the server started to drain before this RPC was initiated.
-                        if _, ok := err.(transport.ConnectionError); (ok || err == transport.ErrStreamDrain) && !c.failFast {
-                                continue
-                        }
-                        return toRPCErr(err)
-                }
-                err = recvResponse(ctx, cc.dopts, t, &c, stream, reply)
-                if err != nil {
-                        if put != nil {
-                                updateRPCInfoInContext(ctx, rpcInfo{
-                                        bytesSent:     stream.BytesSent(),
-                                        bytesReceived: stream.BytesReceived(),
-                                })
-                                put()
-                        }
-                        if _, ok := err.(transport.ConnectionError); (ok || err == transport.ErrStreamDrain) && !c.failFast {
-                                continue
-                        }
-                        return toRPCErr(err)
-                }
-                if c.traceInfo.tr != nil {
-                        c.traceInfo.tr.LazyLog(&payload{sent: false, msg: reply}, true)
-                }
-                t.CloseStream(stream, nil)
-                if put != nil {
-                        updateRPCInfoInContext(ctx, rpcInfo{
-                                bytesSent:     stream.BytesSent(),
-                                bytesReceived: stream.BytesReceived(),
-                        })
-                        put()
-                }
-                return stream.Status().Err()
+        if err := cs.SendMsg(req); err != nil {
+                return err
         }
+        return cs.RecvMsg(reply)
 }
diff --git a/vendor/google.golang.org/grpc/clientconn.go b/vendor/google.golang.org/grpc/clientconn.go
index e3f6cb1..56d0bf7 100644
--- a/vendor/google.golang.org/grpc/clientconn.go
+++ b/vendor/google.golang.org/grpc/clientconn.go
@@ -19,35 +19,72 @@
 package grpc
 
 import (
+        "context"
         "errors"
+        "fmt"
+        "math"
         "net"
+        "reflect"
         "strings"
         "sync"
+        "sync/atomic"
         "time"
 
-        "golang.org/x/net/context"
-        "golang.org/x/net/trace"
+        "google.golang.org/grpc/balancer"
+        _ "google.golang.org/grpc/balancer/roundrobin" // To register roundrobin.
+        "google.golang.org/grpc/codes"
         "google.golang.org/grpc/connectivity"
         "google.golang.org/grpc/credentials"
         "google.golang.org/grpc/grpclog"
+        "google.golang.org/grpc/internal/backoff"
+        "google.golang.org/grpc/internal/channelz"
+        "google.golang.org/grpc/internal/envconfig"
+        "google.golang.org/grpc/internal/grpcsync"
+        "google.golang.org/grpc/internal/transport"
         "google.golang.org/grpc/keepalive"
-        "google.golang.org/grpc/stats"
-        "google.golang.org/grpc/transport"
+        "google.golang.org/grpc/metadata"
+        "google.golang.org/grpc/resolver"
+        _ "google.golang.org/grpc/resolver/dns"         // To register dns resolver.
+        _ "google.golang.org/grpc/resolver/passthrough" // To register passthrough resolver.
+        "google.golang.org/grpc/status"
+)
+
+const (
+        // minimum time to give a connection to complete
+        minConnectTimeout = 20 * time.Second
+        // must match grpclbName in grpclb/grpclb.go
+        grpclbName = "grpclb"
 )
 
 var (
         // ErrClientConnClosing indicates that the operation is illegal because
         // the ClientConn is closing.
-        ErrClientConnClosing = errors.New("grpc: the client connection is closing")
-        // ErrClientConnTimeout indicates that the ClientConn cannot establish the
-        // underlying connections within the specified timeout.
-        // DEPRECATED: Please use context.DeadlineExceeded instead.
-        ErrClientConnTimeout = errors.New("grpc: timed out when dialing")
+        //
+        // Deprecated: this error should not be relied upon by users; use the status
+        // code of Canceled instead.
+        ErrClientConnClosing = status.Error(codes.Canceled, "grpc: the client connection is closing")
+        // errConnDrain indicates that the connection starts to be drained and does not accept any new RPCs.
+        errConnDrain = errors.New("grpc: the connection is drained")
+        // errConnClosing indicates that the connection is closing.
+        errConnClosing = errors.New("grpc: the connection is closing")
+        // errBalancerClosed indicates that the balancer is closed.
+        errBalancerClosed = errors.New("grpc: balancer is closed")
+        // We use an accessor so that minConnectTimeout can be
+        // atomically read and updated while testing.
+        getMinConnectTimeout = func() time.Duration {
+                return minConnectTimeout
+        }
+)
 
+// The following errors are returned from Dial and DialContext
+var (
         // errNoTransportSecurity indicates that there is no transport security
         // being set for ClientConn. Users should either set one or explicitly
         // call WithInsecure DialOption to disable security.
         errNoTransportSecurity = errors.New("grpc: no transport security set (use grpc.WithInsecure() explicitly or set credentials)")
+        // errTransportCredsAndBundle indicates that creds bundle is used together
+        // with other individual Transport Credentials.
+        errTransportCredsAndBundle = errors.New("grpc: credentials.Bundle may not be used with individual TransportCredentials")
         // errTransportCredentialsMissing indicates that users want to transmit security
         // information (e.g., oauth2 token) which requires secure connection on an insecure
         // connection.
@@ -55,278 +92,100 @@ var (
         // errCredentialsConflict indicates that grpc.WithTransportCredentials()
         // and grpc.WithInsecure() are both called for a connection.
         errCredentialsConflict = errors.New("grpc: transport credentials are set for an insecure connection (grpc.WithTransportCredentials() and grpc.WithInsecure() are both called)")
-        // errNetworkIO indicates that the connection is down due to some network I/O error.
-        errNetworkIO = errors.New("grpc: failed with network I/O error")
-        // errConnDrain indicates that the connection starts to be drained and does not accept any new RPCs.
-        errConnDrain = errors.New("grpc: the connection is drained")
-        // errConnClosing indicates that the connection is closing.
-        errConnClosing = errors.New("grpc: the connection is closing")
-        // errConnUnavailable indicates that the connection is unavailable.
-        errConnUnavailable = errors.New("grpc: the connection is unavailable")
-        // errBalancerClosed indicates that the balancer is closed.
-        errBalancerClosed = errors.New("grpc: balancer is closed")
-        // minimum time to give a connection to complete
-        minConnectTimeout = 20 * time.Second
 )
 
-// dialOptions configure a Dial call. dialOptions are set by the DialOption
-// values passed to Dial.
-type dialOptions struct {
-        unaryInt    UnaryClientInterceptor
-        streamInt   StreamClientInterceptor
-        codec       Codec
-        cp          Compressor
-        dc          Decompressor
-        bs          backoffStrategy
-        balancer    Balancer
-        block       bool
-        insecure    bool
-        timeout     time.Duration
-        scChan      <-chan ServiceConfig
-        copts       transport.ConnectOptions
-        callOptions []CallOption
-}
-
 const (
         defaultClientMaxReceiveMessageSize = 1024 * 1024 * 4
-        defaultClientMaxSendMessageSize    = 1024 * 1024 * 4
+        defaultClientMaxSendMessageSize    = math.MaxInt32
+        // http2IOBufSize specifies the buffer size for sending frames.
+        defaultWriteBufSize = 32 * 1024
+        defaultReadBufSize  = 32 * 1024
 )
 
-// DialOption configures how we set up the connection.
-type DialOption func(*dialOptions)
-
-// WithInitialWindowSize returns a DialOption which sets the value for initial window size on a stream.
-// The lower bound for window size is 64K and any value smaller than that will be ignored.
-func WithInitialWindowSize(s int32) DialOption {
-        return func(o *dialOptions) {
-                o.copts.InitialWindowSize = s
-        }
-}
-
-// WithInitialConnWindowSize returns a DialOption which sets the value for initial window size on a connection.
-// The lower bound for window size is 64K and any value smaller than that will be ignored.
-func WithInitialConnWindowSize(s int32) DialOption {
-        return func(o *dialOptions) {
-                o.copts.InitialConnWindowSize = s
-        }
-}
-
-// WithMaxMsgSize returns a DialOption which sets the maximum message size the client can receive. Deprecated: use WithDefaultCallOptions(MaxCallRecvMsgSize(s)) instead.
-func WithMaxMsgSize(s int) DialOption {
-        return WithDefaultCallOptions(MaxCallRecvMsgSize(s))
-}
-
-// WithDefaultCallOptions returns a DialOption which sets the default CallOptions for calls over the connection.
-func WithDefaultCallOptions(cos ...CallOption) DialOption {
-        return func(o *dialOptions) {
-                o.callOptions = append(o.callOptions, cos...)
-        }
-}
-
-// WithCodec returns a DialOption which sets a codec for message marshaling and unmarshaling.
-func WithCodec(c Codec) DialOption {
-        return func(o *dialOptions) {
-                o.codec = c
-        }
-}
-
-// WithCompressor returns a DialOption which sets a CompressorGenerator for generating message
-// compressor.
-func WithCompressor(cp Compressor) DialOption {
-        return func(o *dialOptions) {
-                o.cp = cp
-        }
-}
-
-// WithDecompressor returns a DialOption which sets a DecompressorGenerator for generating
-// message decompressor.
-func WithDecompressor(dc Decompressor) DialOption {
-        return func(o *dialOptions) {
-                o.dc = dc
-        }
-}
-
-// WithBalancer returns a DialOption which sets a load balancer.
-func WithBalancer(b Balancer) DialOption {
-        return func(o *dialOptions) {
-                o.balancer = b
-        }
-}
-
-// WithServiceConfig returns a DialOption which has a channel to read the service configuration.
-func WithServiceConfig(c <-chan ServiceConfig) DialOption {
-        return func(o *dialOptions) {
-                o.scChan = c
-        }
-}
-
-// WithBackoffMaxDelay configures the dialer to use the provided maximum delay
-// when backing off after failed connection attempts.
-func WithBackoffMaxDelay(md time.Duration) DialOption {
-        return WithBackoffConfig(BackoffConfig{MaxDelay: md})
-}
-
-// WithBackoffConfig configures the dialer to use the provided backoff
-// parameters after connection failures.
-//
-// Use WithBackoffMaxDelay until more parameters on BackoffConfig are opened up
-// for use.
-func WithBackoffConfig(b BackoffConfig) DialOption {
-        // Set defaults to ensure that provided BackoffConfig is valid and
-        // unexported fields get default values.
-        setDefaults(&b)
-        return withBackoff(b)
-}
-
-// withBackoff sets the backoff strategy used for retries after a
-// failed connection attempt.
-//
-// This can be exported if arbitrary backoff strategies are allowed by gRPC.
-func withBackoff(bs backoffStrategy) DialOption {
-        return func(o *dialOptions) {
-                o.bs = bs
-        }
-}
-
-// WithBlock returns a DialOption which makes caller of Dial blocks until the underlying
-// connection is up. Without this, Dial returns immediately and connecting the server
-// happens in background.
-func WithBlock() DialOption {
-        return func(o *dialOptions) {
-                o.block = true
-        }
-}
-
-// WithInsecure returns a DialOption which disables transport security for this ClientConn.
-// Note that transport security is required unless WithInsecure is set.
-func WithInsecure() DialOption {
-        return func(o *dialOptions) {
-                o.insecure = true
-        }
-}
-
-// WithTransportCredentials returns a DialOption which configures a
-// connection level security credentials (e.g., TLS/SSL).
-func WithTransportCredentials(creds credentials.TransportCredentials) DialOption {
-        return func(o *dialOptions) {
-                o.copts.TransportCredentials = creds
-        }
-}
-
-// WithPerRPCCredentials returns a DialOption which sets
-// credentials and places auth state on each outbound RPC.
-func WithPerRPCCredentials(creds credentials.PerRPCCredentials) DialOption {
-        return func(o *dialOptions) {
-                o.copts.PerRPCCredentials = append(o.copts.PerRPCCredentials, creds)
-        }
-}
-
-// WithTimeout returns a DialOption that configures a timeout for dialing a ClientConn
-// initially. This is valid if and only if WithBlock() is present.
-// Deprecated: use DialContext and context.WithTimeout instead.
-func WithTimeout(d time.Duration) DialOption {
-        return func(o *dialOptions) {
-                o.timeout = d
-        }
-}
-
-// WithDialer returns a DialOption that specifies a function to use for dialing network addresses.
-// If FailOnNonTempDialError() is set to true, and an error is returned by f, gRPC checks the error's
-// Temporary() method to decide if it should try to reconnect to the network address.
-func WithDialer(f func(string, time.Duration) (net.Conn, error)) DialOption {
-        return func(o *dialOptions) {
-                o.copts.Dialer = func(ctx context.Context, addr string) (net.Conn, error) {
-                        if deadline, ok := ctx.Deadline(); ok {
-                                return f(addr, deadline.Sub(time.Now()))
-                        }
-                        return f(addr, 0)
-                }
-        }
-}
-
-// WithStatsHandler returns a DialOption that specifies the stats handler
-// for all the RPCs and underlying network connections in this ClientConn.
-func WithStatsHandler(h stats.Handler) DialOption {
-        return func(o *dialOptions) {
-                o.copts.StatsHandler = h
-        }
-}
-
-// FailOnNonTempDialError returns a DialOption that specifies if gRPC fails on non-temporary dial errors.
-// If f is true, and dialer returns a non-temporary error, gRPC will fail the connection to the network
-// address and won't try to reconnect.
-// The default value of FailOnNonTempDialError is false.
-// This is an EXPERIMENTAL API.
-func FailOnNonTempDialError(f bool) DialOption {
-        return func(o *dialOptions) {
-                o.copts.FailOnNonTempDialError = f
-        }
-}
-
-// WithUserAgent returns a DialOption that specifies a user agent string for all the RPCs.
-func WithUserAgent(s string) DialOption {
-        return func(o *dialOptions) {
-                o.copts.UserAgent = s
-        }
-}
-
-// WithKeepaliveParams returns a DialOption that specifies keepalive paramaters for the client transport.
-func WithKeepaliveParams(kp keepalive.ClientParameters) DialOption {
-        return func(o *dialOptions) {
-                o.copts.KeepaliveParams = kp
-        }
-}
-
-// WithUnaryInterceptor returns a DialOption that specifies the interceptor for unary RPCs.
-func WithUnaryInterceptor(f UnaryClientInterceptor) DialOption {
-        return func(o *dialOptions) {
-                o.unaryInt = f
-        }
-}
-
-// WithStreamInterceptor returns a DialOption that specifies the interceptor for streaming RPCs.
-func WithStreamInterceptor(f StreamClientInterceptor) DialOption {
-        return func(o *dialOptions) {
-                o.streamInt = f
-        }
-}
-
-// WithAuthority returns a DialOption that specifies the value to be used as
-// the :authority pseudo-header. This value only works with WithInsecure and
-// has no effect if TransportCredentials are present.
-func WithAuthority(a string) DialOption {
-        return func(o *dialOptions) {
-                o.copts.Authority = a
-        }
-}
-
 // Dial creates a client connection to the given target.
 func Dial(target string, opts ...DialOption) (*ClientConn, error) {
         return DialContext(context.Background(), target, opts...)
 }
 
-// DialContext creates a client connection to the given target. ctx can be used to
-// cancel or expire the pending connection. Once this function returns, the
-// cancellation and expiration of ctx will be noop. Users should call ClientConn.Close
-// to terminate all the pending operations after this function returns.
+// DialContext creates a client connection to the given target. By default, it's
+// a non-blocking dial (the function won't wait for connections to be
+// established, and connecting happens in the background). To make it a blocking
+// dial, use WithBlock() dial option.
+//
+// In the non-blocking case, the ctx does not act against the connection. It
+// only controls the setup steps.
+//
+// In the blocking case, ctx can be used to cancel or expire the pending
+// connection. Once this function returns, the cancellation and expiration of
+// ctx will be noop. Users should call ClientConn.Close to terminate all the
+// pending operations after this function returns.
+//
+// The target name syntax is defined in
+// https://github.com/grpc/grpc/blob/master/doc/naming.md.
+// e.g. to use dns resolver, a "dns:///" prefix should be applied to the target.
 func DialContext(ctx context.Context, target string, opts ...DialOption) (conn *ClientConn, err error) {
         cc := &ClientConn{
-                target: target,
-                csMgr:  &connectivityStateManager{},
-                conns:  make(map[Address]*addrConn),
-        }
-        cc.csEvltr = &connectivityStateEvaluator{csMgr: cc.csMgr}
+                target:            target,
+                csMgr:             &connectivityStateManager{},
+                conns:             make(map[*addrConn]struct{}),
+                dopts:             defaultDialOptions(),
+                blockingpicker:    newPickerWrapper(),
+                czData:            new(channelzData),
+                firstResolveEvent: grpcsync.NewEvent(),
+        }
+        cc.retryThrottler.Store((*retryThrottler)(nil))
         cc.ctx, cc.cancel = context.WithCancel(context.Background())
 
         for _, opt := range opts {
-                opt(&cc.dopts)
+                opt.apply(&cc.dopts)
+        }
+
+        if channelz.IsOn() {
+                if cc.dopts.channelzParentID != 0 {
+                        cc.channelzID = channelz.RegisterChannel(&channelzChannel{cc}, cc.dopts.channelzParentID, target)
+                        channelz.AddTraceEvent(cc.channelzID, &channelz.TraceEventDesc{
+                                Desc:     "Channel Created",
+                                Severity: channelz.CtINFO,
+                                Parent: &channelz.TraceEventDesc{
+                                        Desc:     fmt.Sprintf("Nested Channel(id:%d) created", cc.channelzID),
+                                        Severity: channelz.CtINFO,
+                                },
+                        })
+                } else {
+                        cc.channelzID = channelz.RegisterChannel(&channelzChannel{cc}, 0, target)
+                        channelz.AddTraceEvent(cc.channelzID, &channelz.TraceEventDesc{
+                                Desc:     "Channel Created",
+                                Severity: channelz.CtINFO,
+                        })
+                }
+                cc.csMgr.channelzID = cc.channelzID
         }
+
+        if !cc.dopts.insecure {
+                if cc.dopts.copts.TransportCredentials == nil && cc.dopts.copts.CredsBundle == nil {
+                        return nil, errNoTransportSecurity
+                }
+                if cc.dopts.copts.TransportCredentials != nil && cc.dopts.copts.CredsBundle != nil {
+                        return nil, errTransportCredsAndBundle
+                }
+        } else {
+                if cc.dopts.copts.TransportCredentials != nil || cc.dopts.copts.CredsBundle != nil {
+                        return nil, errCredentialsConflict
+                }
+                for _, cd := range cc.dopts.copts.PerRPCCredentials {
+                        if cd.RequireTransportSecurity() {
+                                return nil, errTransportCredentialsMissing
+                        }
+                }
+        }
+
         cc.mkp = cc.dopts.copts.KeepaliveParams
 
         if cc.dopts.copts.Dialer == nil {
                 cc.dopts.copts.Dialer = newProxyDialer(
                         func(ctx context.Context, addr string) (net.Conn, error) {
-                                return dialContext(ctx, "tcp", addr)
+                                network, addr := parseDialTarget(addr)
+                                return (&net.Dialer{}).DialContext(ctx, network, addr)
                         },
                 )
         }
@@ -367,66 +226,41 @@ func DialContext(ctx context.Context, target string, opts ...DialOption) (conn *
                 default:
                 }
         }
-        // Set defaults.
-        if cc.dopts.codec == nil {
-                cc.dopts.codec = protoCodec{}
-        }
         if cc.dopts.bs == nil {
-                cc.dopts.bs = DefaultBackoffConfig
+                cc.dopts.bs = backoff.Exponential{
+                        MaxDelay: DefaultBackoffConfig.MaxDelay,
+                }
+        }
+        if cc.dopts.resolverBuilder == nil {
+                // Only try to parse target when resolver builder is not already set.
+                cc.parsedTarget = parseTarget(cc.target)
+                grpclog.Infof("parsed scheme: %q", cc.parsedTarget.Scheme)
+                cc.dopts.resolverBuilder = resolver.Get(cc.parsedTarget.Scheme)
+                if cc.dopts.resolverBuilder == nil {
+                        // If resolver builder is still nil, the parse target's scheme is
+                        // not registered. Fallback to default resolver and set Endpoint to
+                        // the original unparsed target.
+                        grpclog.Infof("scheme %q not registered, fallback to default scheme", cc.parsedTarget.Scheme)
+                        cc.parsedTarget = resolver.Target{
+                                Scheme:   resolver.GetDefaultScheme(),
+                                Endpoint: target,
+                        }
+                        cc.dopts.resolverBuilder = resolver.Get(cc.parsedTarget.Scheme)
+                }
+        } else {
+                cc.parsedTarget = resolver.Target{Endpoint: target}
         }
         creds := cc.dopts.copts.TransportCredentials
         if creds != nil && creds.Info().ServerName != "" {
                 cc.authority = creds.Info().ServerName
-        } else if cc.dopts.insecure && cc.dopts.copts.Authority != "" {
-                cc.authority = cc.dopts.copts.Authority
+        } else if cc.dopts.insecure && cc.dopts.authority != "" {
+                cc.authority = cc.dopts.authority
         } else {
-                cc.authority = target
-        }
-        waitC := make(chan error, 1)
-        go func() {
-                defer close(waitC)
-                if cc.dopts.balancer == nil && cc.sc.LB != nil {
-                        cc.dopts.balancer = cc.sc.LB
-                }
-                if cc.dopts.balancer != nil {
-                        var credsClone credentials.TransportCredentials
-                        if creds != nil {
-                                credsClone = creds.Clone()
-                        }
-                        config := BalancerConfig{
-                                DialCreds: credsClone,
-                                Dialer:    cc.dopts.copts.Dialer,
-                        }
-                        if err := cc.dopts.balancer.Start(target, config); err != nil {
-                                waitC <- err
-                                return
-                        }
-                        ch := cc.dopts.balancer.Notify()
-                        if ch != nil {
-                                if cc.dopts.block {
-                                        doneChan := make(chan struct{})
-                                        go cc.lbWatcher(doneChan)
-                                        <-doneChan
-                                } else {
-                                        go cc.lbWatcher(nil)
-                                }
-                                return
-                        }
-                }
-                // No balancer, or no resolver within the balancer.  Connect directly.
-                if err := cc.resetAddrConn(Address{Addr: target}, cc.dopts.block, nil); err != nil {
-                        waitC <- err
-                        return
-                }
-        }()
-        select {
-        case <-ctx.Done():
-                return nil, ctx.Err()
-        case err := <-waitC:
-                if err != nil {
-                        return nil, err
-                }
+                // Use endpoint from "scheme://authority/endpoint" as the default
+                // authority for ClientConn.
+                cc.authority = cc.parsedTarget.Endpoint
         }
+
         if cc.dopts.scChan != nil && !scSet {
                 // Blocking wait for the initial service config.
                 select {
@@ -442,55 +276,50 @@ func DialContext(ctx context.Context, target string, opts ...DialOption) (conn *
                 go cc.scWatcher()
         }
 
-        return cc, nil
-}
+        var credsClone credentials.TransportCredentials
+        if creds := cc.dopts.copts.TransportCredentials; creds != nil {
+                credsClone = creds.Clone()
+        }
+        cc.balancerBuildOpts = balancer.BuildOptions{
+                DialCreds:        credsClone,
+                CredsBundle:      cc.dopts.copts.CredsBundle,
+                Dialer:           cc.dopts.copts.Dialer,
+                ChannelzParentID: cc.channelzID,
+        }
 
-// connectivityStateEvaluator gets updated by addrConns when their
-// states transition, based on which it evaluates the state of
-// ClientConn.
-// Note: This code will eventually sit in the balancer in the new design.
-type connectivityStateEvaluator struct {
-        csMgr               *connectivityStateManager
-        mu                  sync.Mutex
-        numReady            uint64 // Number of addrConns in ready state.
-        numConnecting       uint64 // Number of addrConns in connecting state.
-        numTransientFailure uint64 // Number of addrConns in transientFailure.
-}
+        // Build the resolver.
+        rWrapper, err := newCCResolverWrapper(cc)
+        if err != nil {
+                return nil, fmt.Errorf("failed to build resolver: %v", err)
+        }
 
-// recordTransition records state change happening in every addrConn and based on
-// that it evaluates what state the ClientConn is in.
-// It can only transition between connectivity.Ready, connectivity.Connecting and connectivity.TransientFailure. Other states,
-// Idle and connectivity.Shutdown are transitioned into by ClientConn; in the begining of the connection
-// before any addrConn is created ClientConn is in idle state. In the end when ClientConn
-// closes it is in connectivity.Shutdown state.
-// TODO Note that in later releases, a ClientConn with no activity will be put into an Idle state.
-func (cse *connectivityStateEvaluator) recordTransition(oldState, newState connectivity.State) {
-        cse.mu.Lock()
-        defer cse.mu.Unlock()
-
-        // Update counters.
-        for idx, state := range []connectivity.State{oldState, newState} {
-                updateVal := 2*uint64(idx) - 1 // -1 for oldState and +1 for new.
-                switch state {
-                case connectivity.Ready:
-                        cse.numReady += updateVal
-                case connectivity.Connecting:
-                        cse.numConnecting += updateVal
-                case connectivity.TransientFailure:
-                        cse.numTransientFailure += updateVal
+        cc.mu.Lock()
+        cc.resolverWrapper = rWrapper
+        cc.mu.Unlock()
+        // A blocking dial blocks until the clientConn is ready.
+        if cc.dopts.block {
+                for {
+                        s := cc.GetState()
+                        if s == connectivity.Ready {
+                                break
+                        } else if cc.dopts.copts.FailOnNonTempDialError && s == connectivity.TransientFailure {
+                                if err = cc.blockingpicker.connectionError(); err != nil {
+                                        terr, ok := err.(interface {
+                                                Temporary() bool
+                                        })
+                                        if ok && !terr.Temporary() {
+                                                return nil, err
+                                        }
+                                }
+                        }
+                        if !cc.WaitForStateChange(ctx, s) {
+                                // ctx got timeout or canceled.
+                                return nil, ctx.Err()
+                        }
                 }
         }
 
-        // Evaluate.
-        if cse.numReady > 0 {
-                cse.csMgr.updateState(connectivity.Ready)
-                return
-        }
-        if cse.numConnecting > 0 {
-                cse.csMgr.updateState(connectivity.Connecting)
-                return
-        }
-        cse.csMgr.updateState(connectivity.TransientFailure)
+        return cc, nil
 }
 
 // connectivityStateManager keeps the connectivity.State of ClientConn.
@@ -499,6 +328,7 @@ type connectivityStateManager struct {
         mu         sync.Mutex
         state      connectivity.State
         notifyChan chan struct{}
+        channelzID int64
 }
 
 // updateState updates the connectivity.State of ClientConn.
@@ -514,6 +344,12 @@ func (csm *connectivityStateManager) updateState(state connectivity.State) {
                 return
         }
         csm.state = state
+        if channelz.IsOn() {
+                channelz.AddTraceEvent(csm.channelzID, &channelz.TraceEventDesc{
+                        Desc:     fmt.Sprintf("Channel Connectivity change to %v", state),
+                        Severity: channelz.CtINFO,
+                })
+        }
         if csm.notifyChan != nil {
                 // There are other goroutines waiting on this channel.
                 close(csm.notifyChan)
@@ -541,17 +377,32 @@ type ClientConn struct {
         ctx    context.Context
         cancel context.CancelFunc
 
-        target    string
-        authority string
-        dopts     dialOptions
-        csMgr     *connectivityStateManager
-        csEvltr   *connectivityStateEvaluator // This will eventually be part of balancer.
+        target       string
+        parsedTarget resolver.Target
+        authority    string
+        dopts        dialOptions
+        csMgr        *connectivityStateManager
 
-        mu    sync.RWMutex
-        sc    ServiceConfig
-        conns map[Address]*addrConn
+        balancerBuildOpts balancer.BuildOptions
+        blockingpicker    *pickerWrapper
+
+        mu              sync.RWMutex
+        resolverWrapper *ccResolverWrapper
+        sc              ServiceConfig
+        scRaw           string
+        conns           map[*addrConn]struct{}
         // Keepalive parameter can be updated if a GoAway is received.
-        mkp keepalive.ClientParameters
+        mkp             keepalive.ClientParameters
+        curBalancerName string
+        preBalancerName string // previous balancer name.
+        curAddresses    []resolver.Address
+        balancerWrapper *ccBalancerWrapper
+        retryThrottler  atomic.Value
+
+        firstResolveEvent *grpcsync.Event
+
+        channelzID int64 // channelz unique identification number
+        czData     *channelzData
 }
 
 // WaitForStateChange waits until the connectivity.State of ClientConn changes from sourceState or
@@ -576,65 +427,6 @@ func (cc *ClientConn) GetState() connectivity.State {
         return cc.csMgr.getState()
 }
 
-// lbWatcher watches the Notify channel of the balancer in cc and manages
-// connections accordingly.  If doneChan is not nil, it is closed after the
-// first successfull connection is made.
-func (cc *ClientConn) lbWatcher(doneChan chan struct{}) {
-        defer func() {
-                // In case channel from cc.dopts.balancer.Notify() gets closed before a
-                // successful connection gets established, don't forget to notify the
-                // caller.
-                if doneChan != nil {
-                        close(doneChan)
-                }
-        }()
-
-        for addrs := range cc.dopts.balancer.Notify() {
-                var (
-                        add []Address   // Addresses need to setup connections.
-                        del []*addrConn // Connections need to tear down.
-                )
-                cc.mu.Lock()
-                for _, a := range addrs {
-                        if _, ok := cc.conns[a]; !ok {
-                                add = append(add, a)
-                        }
-                }
-                for k, c := range cc.conns {
-                        var keep bool
-                        for _, a := range addrs {
-                                if k == a {
-                                        keep = true
-                                        break
-                                }
-                        }
-                        if !keep {
-                                del = append(del, c)
-                                delete(cc.conns, c.addr)
-                        }
-                }
-                cc.mu.Unlock()
-                for _, a := range add {
-                        var err error
-                        if doneChan != nil {
-                                err = cc.resetAddrConn(a, true, nil)
-                                if err == nil {
-                                        close(doneChan)
-                                        doneChan = nil
-                                }
-                        } else {
-                                err = cc.resetAddrConn(a, false, nil)
-                        }
-                        if err != nil {
-                                grpclog.Warningf("Error creating connection to %v. Err: %v", a, err)
-                        }
-                }
-                for _, c := range del {
-                        c.tearDown(errConnDrain)
-                }
-        }
-}
-
 func (cc *ClientConn) scWatcher() {
         for {
                 select {
@@ -646,6 +438,7 @@ func (cc *ClientConn) scWatcher() {
                         // TODO: load balance policy runtime change is ignored.
                         // We may revist this decision in the future.
                         cc.sc = sc
+                        cc.scRaw = ""
                         cc.mu.Unlock()
                 case <-cc.ctx.Done():
                         return
@@ -653,99 +446,287 @@ func (cc *ClientConn) scWatcher() {
         }
 }
 
-// resetAddrConn creates an addrConn for addr and adds it to cc.conns.
-// If there is an old addrConn for addr, it will be torn down, using tearDownErr as the reason.
-// If tearDownErr is nil, errConnDrain will be used instead.
-//
-// We should never need to replace an addrConn with a new one. This function is only used
-// as newAddrConn to create new addrConn.
-// TODO rename this function and clean up the code.
-func (cc *ClientConn) resetAddrConn(addr Address, block bool, tearDownErr error) error {
-        ac := &addrConn{
-                cc:    cc,
-                addr:  addr,
-                dopts: cc.dopts,
+// waitForResolvedAddrs blocks until the resolver has provided addresses or the
+// context expires.  Returns nil unless the context expires first; otherwise
+// returns a status error based on the context.
+func (cc *ClientConn) waitForResolvedAddrs(ctx context.Context) error {
+        // This is on the RPC path, so we use a fast path to avoid the
+        // more-expensive "select" below after the resolver has returned once.
+        if cc.firstResolveEvent.HasFired() {
+                return nil
         }
-        ac.ctx, ac.cancel = context.WithCancel(cc.ctx)
-        ac.csEvltr = cc.csEvltr
-        if EnableTracing {
-                ac.events = trace.NewEventLog("grpc.ClientConn", ac.addr.Addr)
+        select {
+        case <-cc.firstResolveEvent.Done():
+                return nil
+        case <-ctx.Done():
+                return status.FromContextError(ctx.Err()).Err()
+        case <-cc.ctx.Done():
+                return ErrClientConnClosing
         }
-        if !ac.dopts.insecure {
-                if ac.dopts.copts.TransportCredentials == nil {
-                        return errNoTransportSecurity
-                }
-        } else {
-                if ac.dopts.copts.TransportCredentials != nil {
-                        return errCredentialsConflict
+}
+
+func (cc *ClientConn) handleResolvedAddrs(addrs []resolver.Address, err error) {
+        cc.mu.Lock()
+        defer cc.mu.Unlock()
+        if cc.conns == nil {
+                // cc was closed.
+                return
+        }
+
+        if reflect.DeepEqual(cc.curAddresses, addrs) {
+                return
+        }
+
+        cc.curAddresses = addrs
+        cc.firstResolveEvent.Fire()
+
+        if cc.dopts.balancerBuilder == nil {
+                // Only look at balancer types and switch balancer if balancer dial
+                // option is not set.
+                var isGRPCLB bool
+                for _, a := range addrs {
+                        if a.Type == resolver.GRPCLB {
+                                isGRPCLB = true
+                                break
+                        }
                 }
-                for _, cd := range ac.dopts.copts.PerRPCCredentials {
-                        if cd.RequireTransportSecurity() {
-                                return errTransportCredentialsMissing
+                var newBalancerName string
+                if isGRPCLB {
+                        newBalancerName = grpclbName
+                } else {
+                        // Address list doesn't contain grpclb address. Try to pick a
+                        // non-grpclb balancer.
+                        newBalancerName = cc.curBalancerName
+                        // If current balancer is grpclb, switch to the previous one.
+                        if newBalancerName == grpclbName {
+                                newBalancerName = cc.preBalancerName
+                        }
+                        // The following could be true in two cases:
+                        // - the first time handling resolved addresses
+                        //   (curBalancerName="")
+                        // - the first time handling non-grpclb addresses
+                        //   (curBalancerName="grpclb", preBalancerName="")
+                        if newBalancerName == "" {
+                                newBalancerName = PickFirstBalancerName
                         }
                 }
+                cc.switchBalancer(newBalancerName)
+        } else if cc.balancerWrapper == nil {
+                // Balancer dial option was set, and this is the first time handling
+                // resolved addresses. Build a balancer with dopts.balancerBuilder.
+                cc.balancerWrapper = newCCBalancerWrapper(cc, cc.dopts.balancerBuilder, cc.balancerBuildOpts)
         }
+
+        cc.balancerWrapper.handleResolvedAddrs(addrs, nil)
+}
+
+// switchBalancer starts the switching from current balancer to the balancer
+// with the given name.
+//
+// It will NOT send the current address list to the new balancer. If needed,
+// caller of this function should send address list to the new balancer after
+// this function returns.
+//
+// Caller must hold cc.mu.
+func (cc *ClientConn) switchBalancer(name string) {
+        if cc.conns == nil {
+                return
+        }
+
+        if strings.ToLower(cc.curBalancerName) == strings.ToLower(name) {
+                return
+        }
+
+        grpclog.Infof("ClientConn switching balancer to %q", name)
+        if cc.dopts.balancerBuilder != nil {
+                grpclog.Infoln("ignoring balancer switching: Balancer DialOption used instead")
+                return
+        }
+        // TODO(bar switching) change this to two steps: drain and close.
+        // Keep track of sc in wrapper.
+        if cc.balancerWrapper != nil {
+                cc.balancerWrapper.close()
+        }
+
+        builder := balancer.Get(name)
+        // TODO(yuxuanli): If user send a service config that does not contain a valid balancer name, should
+        // we reuse previous one?
+        if channelz.IsOn() {
+                if builder == nil {
+                        channelz.AddTraceEvent(cc.channelzID, &channelz.TraceEventDesc{
+                                Desc:     fmt.Sprintf("Channel switches to new LB policy %q due to fallback from invalid balancer name", PickFirstBalancerName),
+                                Severity: channelz.CtWarning,
+                        })
+                } else {
+                        channelz.AddTraceEvent(cc.channelzID, &channelz.TraceEventDesc{
+                                Desc:     fmt.Sprintf("Channel switches to new LB policy %q", name),
+                                Severity: channelz.CtINFO,
+                        })
+                }
+        }
+        if builder == nil {
+                grpclog.Infof("failed to get balancer builder for: %v, using pick_first instead", name)
+                builder = newPickfirstBuilder()
+        }
+
+        cc.preBalancerName = cc.curBalancerName
+        cc.curBalancerName = builder.Name()
+        cc.balancerWrapper = newCCBalancerWrapper(cc, builder, cc.balancerBuildOpts)
+}
+
+func (cc *ClientConn) handleSubConnStateChange(sc balancer.SubConn, s connectivity.State) {
+        cc.mu.Lock()
+        if cc.conns == nil {
+                cc.mu.Unlock()
+                return
+        }
+        // TODO(bar switching) send updates to all balancer wrappers when balancer
+        // gracefully switching is supported.
+        cc.balancerWrapper.handleSubConnStateChange(sc, s)
+        cc.mu.Unlock()
+}
+
+// newAddrConn creates an addrConn for addrs and adds it to cc.conns.
+//
+// Caller needs to make sure len(addrs) > 0.
+func (cc *ClientConn) newAddrConn(addrs []resolver.Address, opts balancer.NewSubConnOptions) (*addrConn, error) {
+        ac := &addrConn{
+                cc:           cc,
+                addrs:        addrs,
+                scopts:       opts,
+                dopts:        cc.dopts,
+                czData:       new(channelzData),
+                resetBackoff: make(chan struct{}),
+        }
+        ac.ctx, ac.cancel = context.WithCancel(cc.ctx)
         // Track ac in cc. This needs to be done before any getTransport(...) is called.
         cc.mu.Lock()
         if cc.conns == nil {
                 cc.mu.Unlock()
-                return ErrClientConnClosing
+                return nil, ErrClientConnClosing
+        }
+        if channelz.IsOn() {
+                ac.channelzID = channelz.RegisterSubChannel(ac, cc.channelzID, "")
+                channelz.AddTraceEvent(ac.channelzID, &channelz.TraceEventDesc{
+                        Desc:     "Subchannel Created",
+                        Severity: channelz.CtINFO,
+                        Parent: &channelz.TraceEventDesc{
+                                Desc:     fmt.Sprintf("Subchannel(id:%d) created", ac.channelzID),
+                                Severity: channelz.CtINFO,
+                        },
+                })
         }
-        stale := cc.conns[ac.addr]
-        cc.conns[ac.addr] = ac
+        cc.conns[ac] = struct{}{}
         cc.mu.Unlock()
-        if stale != nil {
-                // There is an addrConn alive on ac.addr already. This could be due to
-                // a buggy Balancer that reports duplicated Addresses.
-                if tearDownErr == nil {
-                        // tearDownErr is nil if resetAddrConn is called by
-                        // 1) Dial
-                        // 2) lbWatcher
-                        // In both cases, the stale ac should drain, not close.
-                        stale.tearDown(errConnDrain)
-                } else {
-                        stale.tearDown(tearDownErr)
-                }
+        return ac, nil
+}
+
+// removeAddrConn removes the addrConn in the subConn from clientConn.
+// It also tears down the ac with the given error.
+func (cc *ClientConn) removeAddrConn(ac *addrConn, err error) {
+        cc.mu.Lock()
+        if cc.conns == nil {
+                cc.mu.Unlock()
+                return
         }
-        if block {
-                if err := ac.resetTransport(false); err != nil {
-                        if err != errConnClosing {
-                                // Tear down ac and delete it from cc.conns.
-                                cc.mu.Lock()
-                                delete(cc.conns, ac.addr)
-                                cc.mu.Unlock()
-                                ac.tearDown(err)
-                        }
-                        if e, ok := err.(transport.ConnectionError); ok && !e.Temporary() {
-                                return e.Origin()
-                        }
-                        return err
-                }
-                // Start to monitor the error status of transport.
-                go ac.transportMonitor()
-        } else {
-                // Start a goroutine connecting to the server asynchronously.
-                go func() {
-                        if err := ac.resetTransport(false); err != nil {
-                                grpclog.Warningf("Failed to dial %s: %v; please retry.", ac.addr.Addr, err)
-                                if err != errConnClosing {
-                                        // Keep this ac in cc.conns, to get the reason it's torn down.
-                                        ac.tearDown(err)
-                                }
-                                return
-                        }
-                        ac.transportMonitor()
-                }()
+        delete(cc.conns, ac)
+        cc.mu.Unlock()
+        ac.tearDown(err)
+}
+
+func (cc *ClientConn) channelzMetric() *channelz.ChannelInternalMetric {
+        return &channelz.ChannelInternalMetric{
+                State:                    cc.GetState(),
+                Target:                   cc.target,
+                CallsStarted:             atomic.LoadInt64(&cc.czData.callsStarted),
+                CallsSucceeded:           atomic.LoadInt64(&cc.czData.callsSucceeded),
+                CallsFailed:              atomic.LoadInt64(&cc.czData.callsFailed),
+                LastCallStartedTimestamp: time.Unix(0, atomic.LoadInt64(&cc.czData.lastCallStartedTime)),
+        }
+}
+
+// Target returns the target string of the ClientConn.
+// This is an EXPERIMENTAL API.
+func (cc *ClientConn) Target() string {
+        return cc.target
+}
+
+func (cc *ClientConn) incrCallsStarted() {
+        atomic.AddInt64(&cc.czData.callsStarted, 1)
+        atomic.StoreInt64(&cc.czData.lastCallStartedTime, time.Now().UnixNano())
+}
+
+func (cc *ClientConn) incrCallsSucceeded() {
+        atomic.AddInt64(&cc.czData.callsSucceeded, 1)
+}
+
+func (cc *ClientConn) incrCallsFailed() {
+        atomic.AddInt64(&cc.czData.callsFailed, 1)
+}
+
+// connect starts creating a transport.
+// It does nothing if the ac is not IDLE.
+// TODO(bar) Move this to the addrConn section.
+func (ac *addrConn) connect() error {
+        ac.mu.Lock()
+        if ac.state == connectivity.Shutdown {
+                ac.mu.Unlock()
+                return errConnClosing
+        }
+        if ac.state != connectivity.Idle {
+                ac.mu.Unlock()
+                return nil
         }
+        ac.updateConnectivityState(connectivity.Connecting)
+        ac.mu.Unlock()
+
+        // Start a goroutine connecting to the server asynchronously.
+        go ac.resetTransport()
         return nil
 }
 
+// tryUpdateAddrs tries to update ac.addrs with the new addresses list.
+//
+// It checks whether current connected address of ac is in the new addrs list.
+//  - If true, it updates ac.addrs and returns true. The ac will keep using
+//    the existing connection.
+//  - If false, it does nothing and returns false.
+func (ac *addrConn) tryUpdateAddrs(addrs []resolver.Address) bool {
+        ac.mu.Lock()
+        defer ac.mu.Unlock()
+        grpclog.Infof("addrConn: tryUpdateAddrs curAddr: %v, addrs: %v", ac.curAddr, addrs)
+        if ac.state == connectivity.Shutdown {
+                ac.addrs = addrs
+                return true
+        }
+
+        // Unless we're busy reconnecting already, let's reconnect from the top of
+        // the list.
+        if ac.state != connectivity.Ready {
+                return false
+        }
+
+        var curAddrFound bool
+        for _, a := range addrs {
+                if reflect.DeepEqual(ac.curAddr, a) {
+                        curAddrFound = true
+                        break
+                }
+        }
+        grpclog.Infof("addrConn: tryUpdateAddrs curAddrFound: %v", curAddrFound)
+        if curAddrFound {
+                ac.addrs = addrs
+        }
+
+        return curAddrFound
+}
+
 // GetMethodConfig gets the method config of the input method.
 // If there's an exact match for input method (i.e. /service/method), we return
 // the corresponding MethodConfig.
 // If there isn't an exact match for the input method, we look for the default config
 // under the service (i.e /service/). If there is a default MethodConfig for
-// the serivce, we return it.
+// the service, we return it.
 // Otherwise, we return an empty MethodConfig.
 func (cc *ClientConn) GetMethodConfig(method string) MethodConfig {
         // TODO: Avoid the locking here.
@@ -754,68 +735,122 @@ func (cc *ClientConn) GetMethodConfig(method string) MethodConfig {
         m, ok := cc.sc.Methods[method]
         if !ok {
                 i := strings.LastIndex(method, "/")
-                m, _ = cc.sc.Methods[method[:i+1]]
+                m = cc.sc.Methods[method[:i+1]]
         }
         return m
 }
 
-func (cc *ClientConn) getTransport(ctx context.Context, opts BalancerGetOptions) (transport.ClientTransport, func(), error) {
-        var (
-                ac  *addrConn
-                ok  bool
-                put func()
-        )
-        if cc.dopts.balancer == nil {
-                // If balancer is nil, there should be only one addrConn available.
-                cc.mu.RLock()
-                if cc.conns == nil {
-                        cc.mu.RUnlock()
-                        return nil, nil, toRPCErr(ErrClientConnClosing)
-                }
-                for _, ac = range cc.conns {
-                        // Break after the first iteration to get the first addrConn.
-                        ok = true
-                        break
+func (cc *ClientConn) healthCheckConfig() *healthCheckConfig {
+        cc.mu.RLock()
+        defer cc.mu.RUnlock()
+        return cc.sc.healthCheckConfig
+}
+
+func (cc *ClientConn) getTransport(ctx context.Context, failfast bool, method string) (transport.ClientTransport, func(balancer.DoneInfo), error) {
+        hdr, _ := metadata.FromOutgoingContext(ctx)
+        t, done, err := cc.blockingpicker.pick(ctx, failfast, balancer.PickOptions{
+                FullMethodName: method,
+                Header:         hdr,
+        })
+        if err != nil {
+                return nil, nil, toRPCErr(err)
+        }
+        return t, done, nil
+}
+
+// handleServiceConfig parses the service config string in JSON format to Go native
+// struct ServiceConfig, and store both the struct and the JSON string in ClientConn.
+func (cc *ClientConn) handleServiceConfig(js string) error {
+        if cc.dopts.disableServiceConfig {
+                return nil
+        }
+        if cc.scRaw == js {
+                return nil
+        }
+        if channelz.IsOn() {
+                channelz.AddTraceEvent(cc.channelzID, &channelz.TraceEventDesc{
+                        // The special formatting of \"%s\" instead of %q is to provide nice printing of service config
+                        // for human consumption.
+                        Desc:     fmt.Sprintf("Channel has a new service config \"%s\"", js),
+                        Severity: channelz.CtINFO,
+                })
+        }
+        sc, err := parseServiceConfig(js)
+        if err != nil {
+                return err
+        }
+        cc.mu.Lock()
+        // Check if the ClientConn is already closed. Some fields (e.g.
+        // balancerWrapper) are set to nil when closing the ClientConn, and could
+        // cause nil pointer panic if we don't have this check.
+        if cc.conns == nil {
+                cc.mu.Unlock()
+                return nil
+        }
+        cc.scRaw = js
+        cc.sc = sc
+
+        if sc.retryThrottling != nil {
+                newThrottler := &retryThrottler{
+                        tokens: sc.retryThrottling.MaxTokens,
+                        max:    sc.retryThrottling.MaxTokens,
+                        thresh: sc.retryThrottling.MaxTokens / 2,
+                        ratio:  sc.retryThrottling.TokenRatio,
                 }
-                cc.mu.RUnlock()
+                cc.retryThrottler.Store(newThrottler)
         } else {
-                var (
-                        addr Address
-                        err  error
-                )
-                addr, put, err = cc.dopts.balancer.Get(ctx, opts)
-                if err != nil {
-                        return nil, nil, toRPCErr(err)
-                }
-                cc.mu.RLock()
-                if cc.conns == nil {
-                        cc.mu.RUnlock()
-                        return nil, nil, toRPCErr(ErrClientConnClosing)
-                }
-                ac, ok = cc.conns[addr]
-                cc.mu.RUnlock()
+                cc.retryThrottler.Store((*retryThrottler)(nil))
         }
-        if !ok {
-                if put != nil {
-                        updateRPCInfoInContext(ctx, rpcInfo{bytesSent: false, bytesReceived: false})
-                        put()
+
+        if sc.LB != nil && *sc.LB != grpclbName { // "grpclb" is not a valid balancer option in service config.
+                if cc.curBalancerName == grpclbName {
+                        // If current balancer is grpclb, there's at least one grpclb
+                        // balancer address in the resolved list. Don't switch the balancer,
+                        // but change the previous balancer name, so if a new resolved
+                        // address list doesn't contain grpclb address, balancer will be
+                        // switched to *sc.LB.
+                        cc.preBalancerName = *sc.LB
+                } else {
+                        cc.switchBalancer(*sc.LB)
+                        cc.balancerWrapper.handleResolvedAddrs(cc.curAddresses, nil)
                 }
-                return nil, nil, errConnClosing
         }
-        t, err := ac.wait(ctx, cc.dopts.balancer != nil, !opts.BlockingWait)
-        if err != nil {
-                if put != nil {
-                        updateRPCInfoInContext(ctx, rpcInfo{bytesSent: false, bytesReceived: false})
-                        put()
-                }
-                return nil, nil, err
+
+        cc.mu.Unlock()
+        return nil
+}
+
+func (cc *ClientConn) resolveNow(o resolver.ResolveNowOption) {
+        cc.mu.RLock()
+        r := cc.resolverWrapper
+        cc.mu.RUnlock()
+        if r == nil {
+                return
+        }
+        go r.resolveNow(o)
+}
+
+// ResetConnectBackoff wakes up all subchannels in transient failure and causes
+// them to attempt another connection immediately.  It also resets the backoff
+// times used for subsequent attempts regardless of the current state.
+//
+// In general, this function should not be used.  Typical service or network
+// outages result in a reasonable client reconnection strategy by default.
+// However, if a previously unavailable network becomes available, this may be
+// used to trigger an immediate reconnect.
+//
+// This API is EXPERIMENTAL.
+func (cc *ClientConn) ResetConnectBackoff() {
+        cc.mu.Lock()
+        defer cc.mu.Unlock()
+        for ac := range cc.conns {
+                ac.resetConnectBackoff()
         }
-        return t, put, nil
 }
 
 // Close tears down the ClientConn and all underlying connections.
 func (cc *ClientConn) Close() error {
-        cc.cancel()
+        defer cc.cancel()
 
         cc.mu.Lock()
         if cc.conns == nil {
@@ -825,13 +860,41 @@ func (cc *ClientConn) Close() error {
         conns := cc.conns
         cc.conns = nil
         cc.csMgr.updateState(connectivity.Shutdown)
+
+        rWrapper := cc.resolverWrapper
+        cc.resolverWrapper = nil
+        bWrapper := cc.balancerWrapper
+        cc.balancerWrapper = nil
         cc.mu.Unlock()
-        if cc.dopts.balancer != nil {
-                cc.dopts.balancer.Close()
+
+        cc.blockingpicker.close()
+
+        if rWrapper != nil {
+                rWrapper.close()
         }
-        for _, ac := range conns {
+        if bWrapper != nil {
+                bWrapper.close()
+        }
+
+        for ac := range conns {
                 ac.tearDown(ErrClientConnClosing)
         }
+        if channelz.IsOn() {
+                ted := &channelz.TraceEventDesc{
+                        Desc:     "Channel Deleted",
+                        Severity: channelz.CtINFO,
+                }
+                if cc.dopts.channelzParentID != 0 {
+                        ted.Parent = &channelz.TraceEventDesc{
+                                Desc:     fmt.Sprintf("Nested channel(id:%d) deleted", cc.channelzID),
+                                Severity: channelz.CtINFO,
+                        }
+                }
+                channelz.AddTraceEvent(cc.channelzID, ted)
+                // TraceEvent needs to be called before RemoveEntry, as TraceEvent may add trace reference to
+                // the entity beng deleted, and thus prevent it from being deleted right away.
+                channelz.RemoveEntry(cc.channelzID)
+        }
         return nil
 }
 
@@ -841,29 +904,56 @@ type addrConn struct {
         cancel context.CancelFunc
 
         cc     *ClientConn
-        addr   Address
         dopts  dialOptions
-        events trace.EventLog
+        acbw   balancer.SubConn
+        scopts balancer.NewSubConnOptions
+
+        // transport is set when there's a viable transport (note: ac state may not be READY as LB channel
+        // health checking may require server to report healthy to set ac to READY), and is reset
+        // to nil when the current transport should no longer be used to create a stream (e.g. after GoAway
+        // is received, transport is closed, ac has been torn down).
+        transport transport.ClientTransport // The current transport.
 
-        csEvltr *connectivityStateEvaluator
+        mu      sync.Mutex
+        curAddr resolver.Address   // The current address.
+        addrs   []resolver.Address // All addresses that the resolver resolved to.
 
-        mu    sync.Mutex
+        // Use updateConnectivityState for updating addrConn's connectivity state.
         state connectivity.State
-        down  func(error) // the handler called when a connection is down.
-        // ready is closed and becomes nil when a new transport is up or failed
-        // due to timeout.
-        ready     chan struct{}
-        transport transport.ClientTransport
-
-        // The reason this addrConn is torn down.
-        tearDownErr error
+
+        tearDownErr error // The reason this addrConn is torn down.
+
+        backoffIdx   int // Needs to be stateful for resetConnectBackoff.
+        resetBackoff chan struct{}
+
+        channelzID         int64 // channelz unique identification number.
+        czData             *channelzData
+        healthCheckEnabled bool
+}
+
+// Note: this requires a lock on ac.mu.
+func (ac *addrConn) updateConnectivityState(s connectivity.State) {
+        if ac.state == s {
+                return
+        }
+
+        updateMsg := fmt.Sprintf("Subchannel Connectivity change to %v", s)
+        grpclog.Infof(updateMsg)
+        ac.state = s
+        if channelz.IsOn() {
+                channelz.AddTraceEvent(ac.channelzID, &channelz.TraceEventDesc{
+                        Desc:     updateMsg,
+                        Severity: channelz.CtINFO,
+                })
+        }
+        ac.cc.handleSubConnStateChange(ac.acbw, s)
 }
 
 // adjustParams updates parameters used to create transports upon
 // receiving a GoAway.
 func (ac *addrConn) adjustParams(r transport.GoAwayReason) {
         switch r {
-        case transport.TooManyPings:
+        case transport.GoAwayTooManyPings:
                 v := 2 * ac.dopts.copts.KeepaliveParams.Time
                 ac.cc.mu.Lock()
                 if v > ac.cc.mkp.Time {
@@ -873,246 +963,359 @@ func (ac *addrConn) adjustParams(r transport.GoAwayReason) {
         }
 }
 
-// printf records an event in ac's event log, unless ac has been closed.
-// REQUIRES ac.mu is held.
-func (ac *addrConn) printf(format string, a ...interface{}) {
-        if ac.events != nil {
-                ac.events.Printf(format, a...)
-        }
-}
+func (ac *addrConn) resetTransport() {
+        for i := 0; ; i++ {
+                tryNextAddrFromStart := grpcsync.NewEvent()
 
-// errorf records an error in ac's event log, unless ac has been closed.
-// REQUIRES ac.mu is held.
-func (ac *addrConn) errorf(format string, a ...interface{}) {
-        if ac.events != nil {
-                ac.events.Errorf(format, a...)
-        }
-}
-
-// resetTransport recreates a transport to the address for ac.
-// For the old transport:
-// - if drain is true, it will be gracefully closed.
-// - otherwise, it will be closed.
-func (ac *addrConn) resetTransport(drain bool) error {
-        ac.mu.Lock()
-        if ac.state == connectivity.Shutdown {
-                ac.mu.Unlock()
-                return errConnClosing
-        }
-        ac.printf("connecting")
-        if ac.down != nil {
-                ac.down(downErrorf(false, true, "%v", errNetworkIO))
-                ac.down = nil
-        }
-        oldState := ac.state
-        ac.state = connectivity.Connecting
-        ac.csEvltr.recordTransition(oldState, ac.state)
-        t := ac.transport
-        ac.transport = nil
-        ac.mu.Unlock()
-        if t != nil && !drain {
-                t.Close()
-        }
-        ac.cc.mu.RLock()
-        ac.dopts.copts.KeepaliveParams = ac.cc.mkp
-        ac.cc.mu.RUnlock()
-        for retries := 0; ; retries++ {
                 ac.mu.Lock()
-                if ac.state == connectivity.Shutdown {
-                        // ac.tearDown(...) has been invoked.
-                        ac.mu.Unlock()
-                        return errConnClosing
+                if i > 0 {
+                        ac.cc.resolveNow(resolver.ResolveNowOption{})
                 }
+                addrs := ac.addrs
+                backoffFor := ac.dopts.bs.Backoff(ac.backoffIdx)
                 ac.mu.Unlock()
-                sleepTime := ac.dopts.bs.backoff(retries)
-                timeout := minConnectTimeout
-                if timeout < sleepTime {
-                        timeout = sleepTime
-                }
-                ctx, cancel := context.WithTimeout(ac.ctx, timeout)
-                connectTime := time.Now()
-                sinfo := transport.TargetInfo{
-                        Addr:     ac.addr.Addr,
-                        Metadata: ac.addr.Metadata,
-                }
-                newTransport, err := transport.NewClientTransport(ctx, sinfo, ac.dopts.copts)
-                // Don't call cancel in success path due to a race in Go 1.6:
-                // https://github.com/golang/go/issues/15078.
-                if err != nil {
-                        cancel()
 
-                        if e, ok := err.(transport.ConnectionError); ok && !e.Temporary() {
-                                return err
+        addrLoop:
+                for _, addr := range addrs {
+                        ac.mu.Lock()
+
+                        if ac.state == connectivity.Shutdown {
+                                ac.mu.Unlock()
+                                return
+                        }
+                        ac.updateConnectivityState(connectivity.Connecting)
+                        ac.transport = nil
+                        ac.mu.Unlock()
+
+                        // This will be the duration that dial gets to finish.
+                        dialDuration := getMinConnectTimeout()
+                        if dialDuration < backoffFor {
+                                // Give dial more time as we keep failing to connect.
+                                dialDuration = backoffFor
                         }
-                        grpclog.Warningf("grpc: addrConn.resetTransport failed to create client transport: %v; Reconnecting to %v", err, ac.addr)
+                        connectDeadline := time.Now().Add(dialDuration)
+
                         ac.mu.Lock()
+                        ac.cc.mu.RLock()
+                        ac.dopts.copts.KeepaliveParams = ac.cc.mkp
+                        ac.cc.mu.RUnlock()
+
                         if ac.state == connectivity.Shutdown {
-                                // ac.tearDown(...) has been invoked.
                                 ac.mu.Unlock()
-                                return errConnClosing
+                                return
                         }
-                        ac.errorf("transient failure: %v", err)
-                        oldState = ac.state
-                        ac.state = connectivity.TransientFailure
-                        ac.csEvltr.recordTransition(oldState, ac.state)
-                        if ac.ready != nil {
-                                close(ac.ready)
-                                ac.ready = nil
+
+                        copts := ac.dopts.copts
+                        if ac.scopts.CredsBundle != nil {
+                                copts.CredsBundle = ac.scopts.CredsBundle
                         }
+                        hctx, hcancel := context.WithCancel(ac.ctx)
+                        defer hcancel()
                         ac.mu.Unlock()
-                        timer := time.NewTimer(sleepTime - time.Since(connectTime))
-                        select {
-                        case <-timer.C:
-                        case <-ac.ctx.Done():
-                                timer.Stop()
-                                return ac.ctx.Err()
+
+                        if channelz.IsOn() {
+                                channelz.AddTraceEvent(ac.channelzID, &channelz.TraceEventDesc{
+                                        Desc:     fmt.Sprintf("Subchannel picks a new address %q to connect", addr.Addr),
+                                        Severity: channelz.CtINFO,
+                                })
+                        }
+
+                        reconnect := grpcsync.NewEvent()
+                        prefaceReceived := make(chan struct{})
+                        newTr, err := ac.createTransport(addr, copts, connectDeadline, reconnect, prefaceReceived)
+                        if err == nil {
+                                ac.mu.Lock()
+                                ac.curAddr = addr
+                                ac.transport = newTr
+                                ac.mu.Unlock()
+
+                                healthCheckConfig := ac.cc.healthCheckConfig()
+                                // LB channel health checking is only enabled when all the four requirements below are met:
+                                // 1. it is not disabled by the user with the WithDisableHealthCheck DialOption,
+                                // 2. the internal.HealthCheckFunc is set by importing the grpc/healthcheck package,
+                                // 3. a service config with non-empty healthCheckConfig field is provided,
+                                // 4. the current load balancer allows it.
+                                healthcheckManagingState := false
+                                if !ac.cc.dopts.disableHealthCheck && healthCheckConfig != nil && ac.scopts.HealthCheckEnabled {
+                                        if ac.cc.dopts.healthCheckFunc == nil {
+                                                // TODO: add a link to the health check doc in the error message.
+                                                grpclog.Error("the client side LB channel health check function has not been set.")
+                                        } else {
+                                                // TODO(deklerk) refactor to just return transport
+                                                go ac.startHealthCheck(hctx, newTr, addr, healthCheckConfig.ServiceName)
+                                                healthcheckManagingState = true
+                                        }
+                                }
+                                if !healthcheckManagingState {
+                                        ac.mu.Lock()
+                                        ac.updateConnectivityState(connectivity.Ready)
+                                        ac.mu.Unlock()
+                                }
+                        } else {
+                                hcancel()
+                                if err == errConnClosing {
+                                        return
+                                }
+
+                                if tryNextAddrFromStart.HasFired() {
+                                        break addrLoop
+                                }
+                                continue
+                        }
+
+                        ac.mu.Lock()
+                        reqHandshake := ac.dopts.reqHandshake
+                        ac.mu.Unlock()
+
+                        <-reconnect.Done()
+                        hcancel()
+
+                        if reqHandshake == envconfig.RequireHandshakeHybrid {
+                                // In RequireHandshakeHybrid mode, we must check to see whether
+                                // server preface has arrived yet to decide whether to start
+                                // reconnecting at the top of the list (server preface received)
+                                // or continue with the next addr in the list as if the
+                                // connection were not successful (server preface not received).
+                                select {
+                                case <-prefaceReceived:
+                                        // We received a server preface - huzzah! We consider this
+                                        // a success and restart from the top of the addr list.
+                                        ac.mu.Lock()
+                                        ac.backoffIdx = 0
+                                        ac.mu.Unlock()
+                                        break addrLoop
+                                default:
+                                        // Despite having set state to READY, in hybrid mode we
+                                        // consider this a failure and continue connecting at the
+                                        // next addr in the list.
+                                        ac.mu.Lock()
+                                        if ac.state == connectivity.Shutdown {
+                                                ac.mu.Unlock()
+                                                return
+                                        }
+
+                                        ac.updateConnectivityState(connectivity.TransientFailure)
+                                        ac.mu.Unlock()
+
+                                        if tryNextAddrFromStart.HasFired() {
+                                                break addrLoop
+                                        }
+                                }
+                        } else {
+                                // In RequireHandshakeOn mode, we would have already waited for
+                                // the server preface, so we consider this a success and restart
+                                // from the top of the addr list. In RequireHandshakeOff mode,
+                                // we don't care to wait for the server preface before
+                                // considering this a success, so we also restart from the top
+                                // of the addr list.
+                                ac.mu.Lock()
+                                ac.backoffIdx = 0
+                                ac.mu.Unlock()
+                                break addrLoop
                         }
-                        timer.Stop()
-                        continue
                 }
+
+                // After exhausting all addresses, or after need to reconnect after a
+                // READY, the addrConn enters TRANSIENT_FAILURE.
                 ac.mu.Lock()
-                ac.printf("ready")
                 if ac.state == connectivity.Shutdown {
-                        // ac.tearDown(...) has been invoked.
                         ac.mu.Unlock()
-                        newTransport.Close()
-                        return errConnClosing
-                }
-                oldState = ac.state
-                ac.state = connectivity.Ready
-                ac.csEvltr.recordTransition(oldState, ac.state)
-                ac.transport = newTransport
-                if ac.ready != nil {
-                        close(ac.ready)
-                        ac.ready = nil
-                }
-                if ac.cc.dopts.balancer != nil {
-                        ac.down = ac.cc.dopts.balancer.Up(ac.addr)
+                        return
                 }
+                ac.updateConnectivityState(connectivity.TransientFailure)
+
+                // Backoff.
+                b := ac.resetBackoff
+                timer := time.NewTimer(backoffFor)
+                acctx := ac.ctx
                 ac.mu.Unlock()
-                return nil
+
+                select {
+                case <-timer.C:
+                        ac.mu.Lock()
+                        ac.backoffIdx++
+                        ac.mu.Unlock()
+                case <-b:
+                        timer.Stop()
+                case <-acctx.Done():
+                        timer.Stop()
+                        return
+                }
         }
 }
 
-// Run in a goroutine to track the error in transport and create the
-// new transport if an error happens. It returns when the channel is closing.
-func (ac *addrConn) transportMonitor() {
-        for {
+// createTransport creates a connection to one of the backends in addrs. It
+// sets ac.transport in the success case, or it returns an error if it was
+// unable to successfully create a transport.
+//
+// If waitForHandshake is enabled, it blocks until server preface arrives.
+func (ac *addrConn) createTransport(addr resolver.Address, copts transport.ConnectOptions, connectDeadline time.Time, reconnect *grpcsync.Event, prefaceReceived chan struct{}) (transport.ClientTransport, error) {
+        onCloseCalled := make(chan struct{})
+
+        target := transport.TargetInfo{
+                Addr:      addr.Addr,
+                Metadata:  addr.Metadata,
+                Authority: ac.cc.authority,
+        }
+
+        prefaceTimer := time.NewTimer(connectDeadline.Sub(time.Now()))
+
+        onGoAway := func(r transport.GoAwayReason) {
                 ac.mu.Lock()
-                t := ac.transport
+                ac.adjustParams(r)
                 ac.mu.Unlock()
-                select {
-                // This is needed to detect the teardown when
-                // the addrConn is idle (i.e., no RPC in flight).
-                case <-ac.ctx.Done():
-                        select {
-                        case <-t.Error():
-                                t.Close()
-                        default:
-                        }
-                        return
-                case <-t.GoAway():
-                        ac.adjustParams(t.GetGoAwayReason())
-                        // If GoAway happens without any network I/O error, the underlying transport
-                        // will be gracefully closed, and a new transport will be created.
-                        // (The transport will be closed when all the pending RPCs finished or failed.)
-                        // If GoAway and some network I/O error happen concurrently, the underlying transport
-                        // will be closed, and a new transport will be created.
-                        var drain bool
+                reconnect.Fire()
+        }
+
+        onClose := func() {
+                close(onCloseCalled)
+                prefaceTimer.Stop()
+                reconnect.Fire()
+        }
+
+        onPrefaceReceipt := func() {
+                close(prefaceReceived)
+                prefaceTimer.Stop()
+        }
+
+        connectCtx, cancel := context.WithDeadline(ac.ctx, connectDeadline)
+        defer cancel()
+        if channelz.IsOn() {
+                copts.ChannelzParentID = ac.channelzID
+        }
+
+        newTr, err := transport.NewClientTransport(connectCtx, ac.cc.ctx, target, copts, onPrefaceReceipt, onGoAway, onClose)
+
+        if err == nil {
+                if ac.dopts.reqHandshake == envconfig.RequireHandshakeOn {
                         select {
-                        case <-t.Error():
-                        default:
-                                drain = true
-                        }
-                        if err := ac.resetTransport(drain); err != nil {
-                                grpclog.Infof("get error from resetTransport %v, transportMonitor returning", err)
-                                if err != errConnClosing {
-                                        // Keep this ac in cc.conns, to get the reason it's torn down.
-                                        ac.tearDown(err)
-                                }
-                                return
+                        case <-prefaceTimer.C:
+                                // We didn't get the preface in time.
+                                newTr.Close()
+                                err = errors.New("timed out waiting for server handshake")
+                        case <-prefaceReceived:
+                                // We got the preface - huzzah! things are good.
+                        case <-onCloseCalled:
+                                // The transport has already closed - noop.
+                                return nil, errors.New("connection closed")
                         }
-                case <-t.Error():
-                        select {
-                        case <-ac.ctx.Done():
-                                t.Close()
-                                return
-                        case <-t.GoAway():
-                                ac.adjustParams(t.GetGoAwayReason())
-                                if err := ac.resetTransport(false); err != nil {
-                                        grpclog.Infof("get error from resetTransport %v, transportMonitor returning", err)
-                                        if err != errConnClosing {
-                                                // Keep this ac in cc.conns, to get the reason it's torn down.
-                                                ac.tearDown(err)
-                                        }
-                                        return
+                } else if ac.dopts.reqHandshake == envconfig.RequireHandshakeHybrid {
+                        go func() {
+                                select {
+                                case <-prefaceTimer.C:
+                                        // We didn't get the preface in time.
+                                        newTr.Close()
+                                case <-prefaceReceived:
+                                        // We got the preface just in the nick of time - huzzah!
+                                case <-onCloseCalled:
+                                        // The transport has already closed - noop.
                                 }
-                        default:
-                        }
-                        ac.mu.Lock()
-                        if ac.state == connectivity.Shutdown {
-                                // ac has been shutdown.
-                                ac.mu.Unlock()
-                                return
-                        }
-                        oldState := ac.state
-                        ac.state = connectivity.TransientFailure
-                        ac.csEvltr.recordTransition(oldState, ac.state)
-                        ac.mu.Unlock()
-                        if err := ac.resetTransport(false); err != nil {
-                                grpclog.Infof("get error from resetTransport %v, transportMonitor returning", err)
-                                ac.mu.Lock()
-                                ac.printf("transport exiting: %v", err)
-                                ac.mu.Unlock()
-                                grpclog.Warningf("grpc: addrConn.transportMonitor exits due to: %v", err)
-                                if err != errConnClosing {
-                                        // Keep this ac in cc.conns, to get the reason it's torn down.
-                                        ac.tearDown(err)
-                                }
-                                return
-                        }
+                        }()
                 }
         }
-}
 
-// wait blocks until i) the new transport is up or ii) ctx is done or iii) ac is closed or
-// iv) transport is in connectivity.TransientFailure and there is a balancer/failfast is true.
-func (ac *addrConn) wait(ctx context.Context, hasBalancer, failfast bool) (transport.ClientTransport, error) {
-        for {
+        if err != nil {
+                // newTr is either nil, or closed.
+                ac.cc.blockingpicker.updateConnectionError(err)
                 ac.mu.Lock()
-                switch {
-                case ac.state == connectivity.Shutdown:
-                        if failfast || !hasBalancer {
-                                // RPC is failfast or balancer is nil. This RPC should fail with ac.tearDownErr.
-                                err := ac.tearDownErr
-                                ac.mu.Unlock()
-                                return nil, err
-                        }
+                if ac.state == connectivity.Shutdown {
+                        // ac.tearDown(...) has been invoked.
                         ac.mu.Unlock()
+
                         return nil, errConnClosing
-                case ac.state == connectivity.Ready:
-                        ct := ac.transport
-                        ac.mu.Unlock()
-                        return ct, nil
-                case ac.state == connectivity.TransientFailure:
-                        if failfast || hasBalancer {
-                                ac.mu.Unlock()
-                                return nil, errConnUnavailable
+                }
+                ac.mu.Unlock()
+                grpclog.Warningf("grpc: addrConn.createTransport failed to connect to %v. Err :%v. Reconnecting...", addr, err)
+                return nil, err
+        }
+
+        // Now there is a viable transport to be use, so set ac.transport to reflect the new viable transport.
+        ac.mu.Lock()
+        if ac.state == connectivity.Shutdown {
+                ac.mu.Unlock()
+                newTr.Close()
+                return nil, errConnClosing
+        }
+        ac.mu.Unlock()
+
+        // Now there is a viable transport to be use, so set ac.transport to reflect the new viable transport.
+        ac.mu.Lock()
+        if ac.state == connectivity.Shutdown {
+                ac.mu.Unlock()
+                newTr.Close()
+                return nil, errConnClosing
+        }
+        ac.mu.Unlock()
+
+        return newTr, nil
+}
+
+func (ac *addrConn) startHealthCheck(ctx context.Context, newTr transport.ClientTransport, addr resolver.Address, serviceName string) {
+        // Set up the health check helper functions
+        newStream := func() (interface{}, error) {
+                return ac.newClientStream(ctx, &StreamDesc{ServerStreams: true}, "/grpc.health.v1.Health/Watch", newTr)
+        }
+        firstReady := true
+        reportHealth := func(ok bool) {
+                ac.mu.Lock()
+                defer ac.mu.Unlock()
+                if ac.transport != newTr {
+                        return
+                }
+                if ok {
+                        if firstReady {
+                                firstReady = false
+                                ac.curAddr = addr
                         }
+                        ac.updateConnectivityState(connectivity.Ready)
+                } else {
+                        ac.updateConnectivityState(connectivity.TransientFailure)
                 }
-                ready := ac.ready
-                if ready == nil {
-                        ready = make(chan struct{})
-                        ac.ready = ready
+        }
+        err := ac.cc.dopts.healthCheckFunc(ctx, newStream, reportHealth, serviceName)
+        if err != nil {
+                if status.Code(err) == codes.Unimplemented {
+                        if channelz.IsOn() {
+                                channelz.AddTraceEvent(ac.channelzID, &channelz.TraceEventDesc{
+                                        Desc:     "Subchannel health check is unimplemented at server side, thus health check is disabled",
+                                        Severity: channelz.CtError,
+                                })
+                        }
+                        grpclog.Error("Subchannel health check is unimplemented at server side, thus health check is disabled")
+                } else {
+                        grpclog.Errorf("HealthCheckFunc exits with unexpected error %v", err)
                 }
+        }
+}
+
+func (ac *addrConn) resetConnectBackoff() {
+        ac.mu.Lock()
+        close(ac.resetBackoff)
+        ac.backoffIdx = 0
+        ac.resetBackoff = make(chan struct{})
+        ac.mu.Unlock()
+}
+
+// getReadyTransport returns the transport if ac's state is READY.
+// Otherwise it returns nil, false.
+// If ac's state is IDLE, it will trigger ac to connect.
+func (ac *addrConn) getReadyTransport() (transport.ClientTransport, bool) {
+        ac.mu.Lock()
+        if ac.state == connectivity.Ready && ac.transport != nil {
+                t := ac.transport
                 ac.mu.Unlock()
-                select {
-                case <-ctx.Done():
-                        return nil, toRPCErr(ctx.Err())
-                // Wait until the new transport is ready or failed.
-                case <-ready:
-                }
+                return t, true
+        }
+        var idle bool
+        if ac.state == connectivity.Idle {
+                idle = true
         }
+        ac.mu.Unlock()
+        // Trigger idle ac to connect.
+        if idle {
+                ac.connect()
+        }
+        return nil, false
 }
 
 // tearDown starts to tear down the addrConn.
@@ -1121,38 +1324,126 @@ func (ac *addrConn) wait(ctx context.Context, hasBalancer, failfast bool) (trans
 // tight loop.
 // tearDown doesn't remove ac from ac.cc.conns.
 func (ac *addrConn) tearDown(err error) {
-        ac.cancel()
-
         ac.mu.Lock()
-        defer ac.mu.Unlock()
-        if ac.down != nil {
-                ac.down(downErrorf(false, false, "%v", err))
-                ac.down = nil
+        if ac.state == connectivity.Shutdown {
+                ac.mu.Unlock()
+                return
         }
-        if err == errConnDrain && ac.transport != nil {
+        curTr := ac.transport
+        ac.transport = nil
+        // We have to set the state to Shutdown before anything else to prevent races
+        // between setting the state and logic that waits on context cancelation / etc.
+        ac.updateConnectivityState(connectivity.Shutdown)
+        ac.cancel()
+        ac.tearDownErr = err
+        ac.curAddr = resolver.Address{}
+        if err == errConnDrain && curTr != nil {
                 // GracefulClose(...) may be executed multiple times when
                 // i) receiving multiple GoAway frames from the server; or
                 // ii) there are concurrent name resolver/Balancer triggered
                 // address removal and GoAway.
-                ac.transport.GracefulClose()
+                // We have to unlock and re-lock here because GracefulClose => Close => onClose, which requires locking ac.mu.
+                ac.mu.Unlock()
+                curTr.GracefulClose()
+                ac.mu.Lock()
         }
-        if ac.state == connectivity.Shutdown {
-                return
+        if channelz.IsOn() {
+                channelz.AddTraceEvent(ac.channelzID, &channelz.TraceEventDesc{
+                        Desc:     "Subchannel Deleted",
+                        Severity: channelz.CtINFO,
+                        Parent: &channelz.TraceEventDesc{
+                                Desc:     fmt.Sprintf("Subchanel(id:%d) deleted", ac.channelzID),
+                                Severity: channelz.CtINFO,
+                        },
+                })
+                // TraceEvent needs to be called before RemoveEntry, as TraceEvent may add trace reference to
+                // the entity beng deleted, and thus prevent it from being deleted right away.
+                channelz.RemoveEntry(ac.channelzID)
         }
-        oldState := ac.state
-        ac.state = connectivity.Shutdown
-        ac.tearDownErr = err
-        ac.csEvltr.recordTransition(oldState, ac.state)
-        if ac.events != nil {
-                ac.events.Finish()
-                ac.events = nil
+        ac.mu.Unlock()
+}
+
+func (ac *addrConn) getState() connectivity.State {
+        ac.mu.Lock()
+        defer ac.mu.Unlock()
+        return ac.state
+}
+
+func (ac *addrConn) ChannelzMetric() *channelz.ChannelInternalMetric {
+        ac.mu.Lock()
+        addr := ac.curAddr.Addr
+        ac.mu.Unlock()
+        return &channelz.ChannelInternalMetric{
+                State:                    ac.getState(),
+                Target:                   addr,
+                CallsStarted:             atomic.LoadInt64(&ac.czData.callsStarted),
+                CallsSucceeded:           atomic.LoadInt64(&ac.czData.callsSucceeded),
+                CallsFailed:              atomic.LoadInt64(&ac.czData.callsFailed),
+                LastCallStartedTimestamp: time.Unix(0, atomic.LoadInt64(&ac.czData.lastCallStartedTime)),
+        }
+}
+
+func (ac *addrConn) incrCallsStarted() {
+        atomic.AddInt64(&ac.czData.callsStarted, 1)
+        atomic.StoreInt64(&ac.czData.lastCallStartedTime, time.Now().UnixNano())
+}
+
+func (ac *addrConn) incrCallsSucceeded() {
+        atomic.AddInt64(&ac.czData.callsSucceeded, 1)
+}
+
+func (ac *addrConn) incrCallsFailed() {
+        atomic.AddInt64(&ac.czData.callsFailed, 1)
+}
+
+type retryThrottler struct {
+        max    float64
+        thresh float64
+        ratio  float64
+
+        mu     sync.Mutex
+        tokens float64 // TODO(dfawley): replace with atomic and remove lock.
+}
+
+// throttle subtracts a retry token from the pool and returns whether a retry
+// should be throttled (disallowed) based upon the retry throttling policy in
+// the service config.
+func (rt *retryThrottler) throttle() bool {
+        if rt == nil {
+                return false
+        }
+        rt.mu.Lock()
+        defer rt.mu.Unlock()
+        rt.tokens--
+        if rt.tokens < 0 {
+                rt.tokens = 0
         }
-        if ac.ready != nil {
-                close(ac.ready)
-                ac.ready = nil
+        return rt.tokens <= rt.thresh
+}
+
+func (rt *retryThrottler) successfulRPC() {
+        if rt == nil {
+                return
         }
-        if ac.transport != nil && err != errConnDrain {
-                ac.transport.Close()
+        rt.mu.Lock()
+        defer rt.mu.Unlock()
+        rt.tokens += rt.ratio
+        if rt.tokens > rt.max {
+                rt.tokens = rt.max
         }
-        return
 }
+
+type channelzChannel struct {
+        cc *ClientConn
+}
+
+func (c *channelzChannel) ChannelzMetric() *channelz.ChannelInternalMetric {
+        return c.cc.channelzMetric()
+}
+
+// ErrClientConnTimeout indicates that the ClientConn cannot establish the
+// underlying connections within the specified timeout.
+//
+// Deprecated: This error is never returned by grpc and should not be
+// referenced by users.
+var ErrClientConnTimeout = errors.New("grpc: timed out when dialing")
diff --git a/vendor/google.golang.org/grpc/codec.go b/vendor/google.golang.org/grpc/codec.go
index 905b048..1297765 100644
--- a/vendor/google.golang.org/grpc/codec.go
+++ b/vendor/google.golang.org/grpc/codec.go
@@ -19,86 +19,32 @@
 package grpc
 
 import (
-        "math"
-        "sync"
-
-        "github.com/golang/protobuf/proto"
+        "google.golang.org/grpc/encoding"
+        _ "google.golang.org/grpc/encoding/proto" // to register the Codec for "proto"
 )
 
+// baseCodec contains the functionality of both Codec and encoding.Codec, but
+// omits the name/string, which vary between the two and are not needed for
+// anything besides the registry in the encoding package.
+type baseCodec interface {
+        Marshal(v interface{}) ([]byte, error)
+        Unmarshal(data []byte, v interface{}) error
+}
+
+var _ baseCodec = Codec(nil)
+var _ baseCodec = encoding.Codec(nil)
+
 // Codec defines the interface gRPC uses to encode and decode messages.
 // Note that implementations of this interface must be thread safe;
 // a Codec's methods can be called from concurrent goroutines.
+//
+// Deprecated: use encoding.Codec instead.
 type Codec interface {
         // Marshal returns the wire format of v.
         Marshal(v interface{}) ([]byte, error)
         // Unmarshal parses the wire format into v.
         Unmarshal(data []byte, v interface{}) error
-        // String returns the name of the Codec implementation. The returned
-        // string will be used as part of content type in transmission.
+        // String returns the name of the Codec implementation.  This is unused by
+        // gRPC.
         String() string
 }
-
-// protoCodec is a Codec implementation with protobuf. It is the default codec for gRPC.
-type protoCodec struct {
-}
-
-type cachedProtoBuffer struct {
-        lastMarshaledSize uint32
-        proto.Buffer
-}
-
-func capToMaxInt32(val int) uint32 {
-        if val > math.MaxInt32 {
-                return uint32(math.MaxInt32)
-        }
-        return uint32(val)
-}
-
-func (p protoCodec) marshal(v interface{}, cb *cachedProtoBuffer) ([]byte, error) {
-        protoMsg := v.(proto.Message)
-        newSlice := make([]byte, 0, cb.lastMarshaledSize)
-
-        cb.SetBuf(newSlice)
-        cb.Reset()
-        if err := cb.Marshal(protoMsg); err != nil {
-                return nil, err
-        }
-        out := cb.Bytes()
-        cb.lastMarshaledSize = capToMaxInt32(len(out))
-        return out, nil
-}
-
-func (p protoCodec) Marshal(v interface{}) ([]byte, error) {
-        cb := protoBufferPool.Get().(*cachedProtoBuffer)
-        out, err := p.marshal(v, cb)
-
-        // put back buffer and lose the ref to the slice
-        cb.SetBuf(nil)
-        protoBufferPool.Put(cb)
-        return out, err
-}
-
-func (p protoCodec) Unmarshal(data []byte, v interface{}) error {
-        cb := protoBufferPool.Get().(*cachedProtoBuffer)
-        cb.SetBuf(data)
-        v.(proto.Message).Reset()
-        err := cb.Unmarshal(v.(proto.Message))
-        cb.SetBuf(nil)
-        protoBufferPool.Put(cb)
-        return err
-}
-
-func (protoCodec) String() string {
-        return "proto"
-}
-
-var (
-        protoBufferPool = &sync.Pool{
-                New: func() interface{} {
-                        return &cachedProtoBuffer{
-                                Buffer:            proto.Buffer{},
-                                lastMarshaledSize: 16,
-                        }
-                },
-        }
-)
diff --git a/vendor/google.golang.org/grpc/codes/code_string.go b/vendor/google.golang.org/grpc/codes/code_string.go
index e6762d0..0b206a5 100644
--- a/vendor/google.golang.org/grpc/codes/code_string.go
+++ b/vendor/google.golang.org/grpc/codes/code_string.go
@@ -1,16 +1,62 @@
-// generated by stringer -type=Code; DO NOT EDIT
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
 
 package codes
 
-import "fmt"
+import "strconv"
 
-const _Code_name = "OKCanceledUnknownInvalidArgumentDeadlineExceededNotFoundAlreadyExistsPermissionDeniedResourceExhaustedFailedPreconditionAbortedOutOfRangeUnimplementedInternalUnavailableDataLossUnauthenticated"
-
-var _Code_index = [...]uint8{0, 2, 10, 17, 32, 48, 56, 69, 85, 102, 120, 127, 137, 150, 158, 169, 177, 192}
-
-func (i Code) String() string {
-        if i+1 >= Code(len(_Code_index)) {
-                return fmt.Sprintf("Code(%d)", i)
+func (c Code) String() string {
+        switch c {
+        case OK:
+                return "OK"
+        case Canceled:
+                return "Canceled"
+        case Unknown:
+                return "Unknown"
+        case InvalidArgument:
+                return "InvalidArgument"
+        case DeadlineExceeded:
+                return "DeadlineExceeded"
+        case NotFound:
+                return "NotFound"
+        case AlreadyExists:
+                return "AlreadyExists"
+        case PermissionDenied:
+                return "PermissionDenied"
+        case ResourceExhausted:
+                return "ResourceExhausted"
+        case FailedPrecondition:
+                return "FailedPrecondition"
+        case Aborted:
+                return "Aborted"
+        case OutOfRange:
+                return "OutOfRange"
+        case Unimplemented:
+                return "Unimplemented"
+        case Internal:
+                return "Internal"
+        case Unavailable:
+                return "Unavailable"
+        case DataLoss:
+                return "DataLoss"
+        case Unauthenticated:
+                return "Unauthenticated"
+        default:
+                return "Code(" + strconv.FormatInt(int64(c), 10) + ")"
         }
-        return _Code_name[_Code_index[i]:_Code_index[i+1]]
 }
diff --git a/vendor/google.golang.org/grpc/codes/codes.go b/vendor/google.golang.org/grpc/codes/codes.go
index 21e7733..d9b9d57 100644
--- a/vendor/google.golang.org/grpc/codes/codes.go
+++ b/vendor/google.golang.org/grpc/codes/codes.go
@@ -20,11 +20,14 @@
 // consistent across various languages.
 package codes // import "google.golang.org/grpc/codes"
 
+import (
+        "fmt"
+        "strconv"
+)
+
 // A Code is an unsigned 32-bit error code as defined in the gRPC spec.
 type Code uint32
 
-//go:generate stringer -type=Code
-
 const (
         // OK is returned on success.
         OK Code = 0
@@ -32,9 +35,9 @@ const (
         // Canceled indicates the operation was canceled (typically by the caller).
         Canceled Code = 1
 
-        // Unknown error.  An example of where this error may be returned is
+        // Unknown error. An example of where this error may be returned is
         // if a Status value received from another address space belongs to
-        // an error-space that is not known in this address space.  Also
+        // an error-space that is not known in this address space. Also
         // errors raised by APIs that do not return enough error information
         // may be converted to this error.
         Unknown Code = 2
@@ -63,15 +66,11 @@ const (
         // PermissionDenied indicates the caller does not have permission to
         // execute the specified operation. It must not be used for rejections
         // caused by exhausting some resource (use ResourceExhausted
-        // instead for those errors).  It must not be
+        // instead for those errors). It must not be
         // used if the caller cannot be identified (use Unauthenticated
         // instead for those errors).
         PermissionDenied Code = 7
 
-        // Unauthenticated indicates the request does not have valid
-        // authentication credentials for the operation.
-        Unauthenticated Code = 16
-
         // ResourceExhausted indicates some resource has been exhausted, perhaps
         // a per-user quota, or perhaps the entire file system is out of space.
         ResourceExhausted Code = 8
@@ -87,7 +86,7 @@ const (
         //  (b) Use Aborted if the client should retry at a higher-level
         //      (e.g., restarting a read-modify-write sequence).
         //  (c) Use FailedPrecondition if the client should not retry until
-        //      the system state has been explicitly fixed.  E.g., if an "rmdir"
+        //      the system state has been explicitly fixed. E.g., if an "rmdir"
         //      fails because the directory is non-empty, FailedPrecondition
         //      should be returned since the client should not retry unless
         //      they have first fixed up the directory by deleting files from it.
@@ -116,7 +115,7 @@ const (
         // file size.
         //
         // There is a fair bit of overlap between FailedPrecondition and
-        // OutOfRange.  We recommend using OutOfRange (the more specific
+        // OutOfRange. We recommend using OutOfRange (the more specific
         // error) when it applies so that callers who are iterating through
         // a space can easily look for an OutOfRange error to detect when
         // they are done.
@@ -126,8 +125,8 @@ const (
         // supported/enabled in this service.
         Unimplemented Code = 12
 
-        // Internal errors.  Means some invariants expected by underlying
-        // system has been broken.  If you see one of these errors,
+        // Internal errors. Means some invariants expected by underlying
+        // system has been broken. If you see one of these errors,
         // something is very broken.
         Internal Code = 13
 
@@ -141,4 +140,58 @@ const (
 
         // DataLoss indicates unrecoverable data loss or corruption.
         DataLoss Code = 15
+
+        // Unauthenticated indicates the request does not have valid
+        // authentication credentials for the operation.
+        Unauthenticated Code = 16
+
+        _maxCode = 17
 )
+
+var strToCode = map[string]Code{
+        `"OK"`: OK,
+        `"CANCELLED"`:/* [sic] */ Canceled,
+        `"UNKNOWN"`:             Unknown,
+        `"INVALID_ARGUMENT"`:    InvalidArgument,
+        `"DEADLINE_EXCEEDED"`:   DeadlineExceeded,
+        `"NOT_FOUND"`:           NotFound,
+        `"ALREADY_EXISTS"`:      AlreadyExists,
+        `"PERMISSION_DENIED"`:   PermissionDenied,
+        `"RESOURCE_EXHAUSTED"`:  ResourceExhausted,
+        `"FAILED_PRECONDITION"`: FailedPrecondition,
+        `"ABORTED"`:             Aborted,
+        `"OUT_OF_RANGE"`:        OutOfRange,
+        `"UNIMPLEMENTED"`:       Unimplemented,
+        `"INTERNAL"`:            Internal,
+        `"UNAVAILABLE"`:         Unavailable,
+        `"DATA_LOSS"`:           DataLoss,
+        `"UNAUTHENTICATED"`:     Unauthenticated,
+}
+
+// UnmarshalJSON unmarshals b into the Code.
+func (c *Code) UnmarshalJSON(b []byte) error {
+        // From json.Unmarshaler: By convention, to approximate the behavior of
+        // Unmarshal itself, Unmarshalers implement UnmarshalJSON([]byte("null")) as
+        // a no-op.
+        if string(b) == "null" {
+                return nil
+        }
+        if c == nil {
+                return fmt.Errorf("nil receiver passed to UnmarshalJSON")
+        }
+
+        if ci, err := strconv.ParseUint(string(b), 10, 32); err == nil {
+                if ci >= _maxCode {
+                        return fmt.Errorf("invalid code: %q", ci)
+                }
+
+                *c = Code(ci)
+                return nil
+        }
+
+        if jc, ok := strToCode[string(b)]; ok {
+                *c = jc
+                return nil
+        }
+        return fmt.Errorf("invalid code: %q", string(b))
+}
diff --git a/vendor/google.golang.org/grpc/connectivity/connectivity.go b/vendor/google.golang.org/grpc/connectivity/connectivity.go
index 568ef5d..b1d7dbc 100644
--- a/vendor/google.golang.org/grpc/connectivity/connectivity.go
+++ b/vendor/google.golang.org/grpc/connectivity/connectivity.go
@@ -22,7 +22,8 @@
 package connectivity
 
 import (
-        "golang.org/x/net/context"
+        "context"
+
         "google.golang.org/grpc/grpclog"
 )
 
diff --git a/vendor/google.golang.org/grpc/coverage.sh b/vendor/google.golang.org/grpc/coverage.sh
deleted file mode 100644
index b85f918..0000000
--- a/vendor/google.golang.org/grpc/coverage.sh
+++ /dev/null
@@ -1,48 +0,0 @@
-#!/usr/bin/env bash
-
-
-set -e
-
-workdir=.cover
-profile="$workdir/cover.out"
-mode=set
-end2endtest="google.golang.org/grpc/test"
-
-generate_cover_data() {
-    rm -rf "$workdir"
-    mkdir "$workdir"
-
-    for pkg in "$@"; do
-        if [ $pkg == "google.golang.org/grpc" -o $pkg == "google.golang.org/grpc/transport" -o $pkg == "google.golang.org/grpc/metadata" -o $pkg == "google.golang.org/grpc/credentials" ]
-            then
-                f="$workdir/$(echo $pkg | tr / -)"
-                go test -covermode="$mode" -coverprofile="$f.cover" "$pkg"
-                go test -covermode="$mode" -coverpkg "$pkg" -coverprofile="$f.e2e.cover" "$end2endtest"
-        fi
-    done
-
-    echo "mode: $mode" >"$profile"
-    grep -h -v "^mode:" "$workdir"/*.cover >>"$profile"
-}
-
-show_cover_report() {
-    go tool cover -${1}="$profile"
-}
-
-push_to_coveralls() {
-    goveralls -coverprofile="$profile"
-}
-
-generate_cover_data $(go list ./...)
-show_cover_report func
-case "$1" in
-"")
-    ;;
---html)
-    show_cover_report html ;;
---coveralls)
-    push_to_coveralls ;;
-*)
-    echo >&2 "error: invalid option: $1" ;;
-esac
-rm -rf "$workdir"
diff --git a/vendor/google.golang.org/grpc/credentials/credentials.go b/vendor/google.golang.org/grpc/credentials/credentials.go
index 2475fe8..a851560 100644
--- a/vendor/google.golang.org/grpc/credentials/credentials.go
+++ b/vendor/google.golang.org/grpc/credentials/credentials.go
@@ -23,6 +23,7 @@
 package credentials // import "google.golang.org/grpc/credentials"
 
 import (
+        "context"
         "crypto/tls"
         "crypto/x509"
         "errors"
@@ -31,13 +32,12 @@ import (
         "net"
         "strings"
 
-        "golang.org/x/net/context"
+        "github.com/golang/protobuf/proto"
+        "google.golang.org/grpc/credentials/internal"
 )
 
-var (
-        // alpnProtoStr are the specified application level protocols for gRPC.
-        alpnProtoStr = []string{"h2"}
-)
+// alpnProtoStr are the specified application level protocols for gRPC.
+var alpnProtoStr = []string{"h2"}
 
 // PerRPCCredentials defines the common interface for the credentials which need to
 // attach security information to every RPC (e.g., oauth2).
@@ -45,8 +45,9 @@ type PerRPCCredentials interface {
         // GetRequestMetadata gets the current request metadata, refreshing
         // tokens if required. This should be called by the transport layer on
         // each request, and the data should be populated in headers or other
-        // context. uri is the URI of the entry point for the request. When
-        // supported by the underlying implementation, ctx can be used for
+        // context. If a status code is returned, it will be used as the status
+        // for the RPC. uri is the URI of the entry point for the request.
+        // When supported by the underlying implementation, ctx can be used for
         // timeout and cancellation.
         // TODO(zhaoq): Define the set of the qualified keys instead of leaving
         // it as an arbitrary string.
@@ -74,11 +75,9 @@ type AuthInfo interface {
         AuthType() string
 }
 
-var (
-        // ErrConnDispatched indicates that rawConn has been dispatched out of gRPC
-        // and the caller should not close rawConn.
-        ErrConnDispatched = errors.New("credentials: rawConn is dispatched out of gRPC")
-)
+// ErrConnDispatched indicates that rawConn has been dispatched out of gRPC
+// and the caller should not close rawConn.
+var ErrConnDispatched = errors.New("credentials: rawConn is dispatched out of gRPC")
 
 // TransportCredentials defines the common interface for all the live gRPC wire
 // protocols and supported transport security protocols (e.g., TLS, SSL).
@@ -91,10 +90,14 @@ type TransportCredentials interface {
         // (io.EOF, context.DeadlineExceeded or err.Temporary() == true).
         // If the returned error is a wrapper error, implementations should make sure that
         // the error implements Temporary() to have the correct retry behaviors.
+        //
+        // If the returned net.Conn is closed, it MUST close the net.Conn provided.
         ClientHandshake(context.Context, string, net.Conn) (net.Conn, AuthInfo, error)
         // ServerHandshake does the authentication handshake for servers. It returns
         // the authenticated connection and the corresponding auth information about
         // the connection.
+        //
+        // If the returned net.Conn is closed, it MUST close the net.Conn provided.
         ServerHandshake(net.Conn) (net.Conn, AuthInfo, error)
         // Info provides the ProtocolInfo of this TransportCredentials.
         Info() ProtocolInfo
@@ -106,6 +109,25 @@ type TransportCredentials interface {
         OverrideServerName(string) error
 }
 
+// Bundle is a combination of TransportCredentials and PerRPCCredentials.
+//
+// It also contains a mode switching method, so it can be used as a combination
+// of different credential policies.
+//
+// Bundle cannot be used together with individual TransportCredentials.
+// PerRPCCredentials from Bundle will be appended to other PerRPCCredentials.
+//
+// This API is experimental.
+type Bundle interface {
+        TransportCredentials() TransportCredentials
+        PerRPCCredentials() PerRPCCredentials
+        // NewWithMode should make a copy of Bundle, and switch mode. Modifying the
+        // existing Bundle may cause races.
+        //
+        // NewWithMode returns nil if the requested mode is not supported.
+        NewWithMode(mode string) (Bundle, error)
+}
+
 // TLSInfo contains the auth information for a TLS authenticated connection.
 // It implements the AuthInfo interface.
 type TLSInfo struct {
@@ -117,6 +139,18 @@ func (t TLSInfo) AuthType() string {
         return "tls"
 }
 
+// GetSecurityValue returns security info requested by channelz.
+func (t TLSInfo) GetSecurityValue() ChannelzSecurityValue {
+        v := &TLSChannelzSecurityValue{
+                StandardName: cipherSuiteLookup[t.State.CipherSuite],
+        }
+        // Currently there's no way to get LocalCertificate info from tls package.
+        if len(t.State.PeerCertificates) > 0 {
+                v.RemoteCertificate = t.State.PeerCertificates[0].Raw
+        }
+        return v
+}
+
 // tlsCreds is the credentials required for authenticating a connection using TLS.
 type tlsCreds struct {
         // TLS configuration
@@ -131,15 +165,15 @@ func (c tlsCreds) Info() ProtocolInfo {
         }
 }
 
-func (c *tlsCreds) ClientHandshake(ctx context.Context, addr string, rawConn net.Conn) (_ net.Conn, _ AuthInfo, err error) {
+func (c *tlsCreds) ClientHandshake(ctx context.Context, authority string, rawConn net.Conn) (_ net.Conn, _ AuthInfo, err error) {
         // use local cfg to avoid clobbering ServerName if using multiple endpoints
         cfg := cloneTLSConfig(c.config)
         if cfg.ServerName == "" {
-                colonPos := strings.LastIndex(addr, ":")
+                colonPos := strings.LastIndex(authority, ":")
                 if colonPos == -1 {
-                        colonPos = len(addr)
+                        colonPos = len(authority)
                 }
-                cfg.ServerName = addr[:colonPos]
+                cfg.ServerName = authority[:colonPos]
         }
         conn := tls.Client(rawConn, cfg)
         errChannel := make(chan error, 1)
@@ -154,7 +188,7 @@ func (c *tlsCreds) ClientHandshake(ctx context.Context, addr string, rawConn net
         case <-ctx.Done():
                 return nil, nil, ctx.Err()
         }
-        return conn, TLSInfo{conn.ConnectionState()}, nil
+        return internal.WrapSyscallConn(rawConn, conn), TLSInfo{conn.ConnectionState()}, nil
 }
 
 func (c *tlsCreds) ServerHandshake(rawConn net.Conn) (net.Conn, AuthInfo, error) {
@@ -162,7 +196,7 @@ func (c *tlsCreds) ServerHandshake(rawConn net.Conn) (net.Conn, AuthInfo, error)
         if err := conn.Handshake(); err != nil {
                 return nil, nil, err
         }
-        return conn, TLSInfo{conn.ConnectionState()}, nil
+        return internal.WrapSyscallConn(rawConn, conn), TLSInfo{conn.ConnectionState()}, nil
 }
 
 func (c *tlsCreds) Clone() TransportCredentials {
@@ -217,3 +251,78 @@ func NewServerTLSFromFile(certFile, keyFile string) (TransportCredentials, error
         }
         return NewTLS(&tls.Config{Certificates: []tls.Certificate{cert}}), nil
 }
+
+// ChannelzSecurityInfo defines the interface that security protocols should implement
+// in order to provide security info to channelz.
+type ChannelzSecurityInfo interface {
+        GetSecurityValue() ChannelzSecurityValue
+}
+
+// ChannelzSecurityValue defines the interface that GetSecurityValue() return value
+// should satisfy. This interface should only be satisfied by *TLSChannelzSecurityValue
+// and *OtherChannelzSecurityValue.
+type ChannelzSecurityValue interface {
+        isChannelzSecurityValue()
+}
+
+// TLSChannelzSecurityValue defines the struct that TLS protocol should return
+// from GetSecurityValue(), containing security info like cipher and certificate used.
+type TLSChannelzSecurityValue struct {
+        StandardName      string
+        LocalCertificate  []byte
+        RemoteCertificate []byte
+}
+
+func (*TLSChannelzSecurityValue) isChannelzSecurityValue() {}
+
+// OtherChannelzSecurityValue defines the struct that non-TLS protocol should return
+// from GetSecurityValue(), which contains protocol specific security info. Note
+// the Value field will be sent to users of channelz requesting channel info, and
+// thus sensitive info should better be avoided.
+type OtherChannelzSecurityValue struct {
+        Name  string
+        Value proto.Message
+}
+
+func (*OtherChannelzSecurityValue) isChannelzSecurityValue() {}
+
+var cipherSuiteLookup = map[uint16]string{
+        tls.TLS_RSA_WITH_RC4_128_SHA:                "TLS_RSA_WITH_RC4_128_SHA",
+        tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA:           "TLS_RSA_WITH_3DES_EDE_CBC_SHA",
+        tls.TLS_RSA_WITH_AES_128_CBC_SHA:            "TLS_RSA_WITH_AES_128_CBC_SHA",
+        tls.TLS_RSA_WITH_AES_256_CBC_SHA:            "TLS_RSA_WITH_AES_256_CBC_SHA",
+        tls.TLS_RSA_WITH_AES_128_GCM_SHA256:         "TLS_RSA_WITH_AES_128_GCM_SHA256",
+        tls.TLS_RSA_WITH_AES_256_GCM_SHA384:         "TLS_RSA_WITH_AES_256_GCM_SHA384",
+        tls.TLS_ECDHE_ECDSA_WITH_RC4_128_SHA:        "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA",
+        tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA:    "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA",
+        tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA:    "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA",
+        tls.TLS_ECDHE_RSA_WITH_RC4_128_SHA:          "TLS_ECDHE_RSA_WITH_RC4_128_SHA",
+        tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA:     "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA",
+        tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA:      "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA",
+        tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA:      "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA",
+        tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256:   "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
+        tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256: "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
+        tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384:   "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
+        tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384: "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
+        tls.TLS_FALLBACK_SCSV:                       "TLS_FALLBACK_SCSV",
+        tls.TLS_RSA_WITH_AES_128_CBC_SHA256:         "TLS_RSA_WITH_AES_128_CBC_SHA256",
+        tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256: "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
+        tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256:   "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
+        tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305:    "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305",
+        tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305:  "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305",
+}
+
+// cloneTLSConfig returns a shallow clone of the exported
+// fields of cfg, ignoring the unexported sync.Once, which
+// contains a mutex and must not be copied.
+//
+// If cfg is nil, a new zero tls.Config is returned.
+//
+// TODO: inline this function if possible.
+func cloneTLSConfig(cfg *tls.Config) *tls.Config {
+        if cfg == nil {
+                return &tls.Config{}
+        }
+
+        return cfg.Clone()
+}
diff --git a/vendor/google.golang.org/grpc/credentials/credentials_util_go17.go b/vendor/google.golang.org/grpc/credentials/credentials_util_go17.go
deleted file mode 100644
index 60409aa..0000000
--- a/vendor/google.golang.org/grpc/credentials/credentials_util_go17.go
+++ /dev/null
@@ -1,60 +0,0 @@
-// +build go1.7
-// +build !go1.8
-
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package credentials
-
-import (
-        "crypto/tls"
-)
-
-// cloneTLSConfig returns a shallow clone of the exported
-// fields of cfg, ignoring the unexported sync.Once, which
-// contains a mutex and must not be copied.
-//
-// If cfg is nil, a new zero tls.Config is returned.
-func cloneTLSConfig(cfg *tls.Config) *tls.Config {
-        if cfg == nil {
-                return &tls.Config{}
-        }
-        return &tls.Config{
-                Rand:                        cfg.Rand,
-                Time:                        cfg.Time,
-                Certificates:                cfg.Certificates,
-                NameToCertificate:           cfg.NameToCertificate,
-                GetCertificate:              cfg.GetCertificate,
-                RootCAs:                     cfg.RootCAs,
-                NextProtos:                  cfg.NextProtos,
-                ServerName:                  cfg.ServerName,
-                ClientAuth:                  cfg.ClientAuth,
-                ClientCAs:                   cfg.ClientCAs,
-                InsecureSkipVerify:          cfg.InsecureSkipVerify,
-                CipherSuites:                cfg.CipherSuites,
-                PreferServerCipherSuites:    cfg.PreferServerCipherSuites,
-                SessionTicketsDisabled:      cfg.SessionTicketsDisabled,
-                SessionTicketKey:            cfg.SessionTicketKey,
-                ClientSessionCache:          cfg.ClientSessionCache,
-                MinVersion:                  cfg.MinVersion,
-                MaxVersion:                  cfg.MaxVersion,
-                CurvePreferences:            cfg.CurvePreferences,
-                DynamicRecordSizingDisabled: cfg.DynamicRecordSizingDisabled,
-                Renegotiation:               cfg.Renegotiation,
-        }
-}
diff --git a/vendor/google.golang.org/grpc/credentials/credentials_util_pre_go17.go b/vendor/google.golang.org/grpc/credentials/credentials_util_pre_go17.go
deleted file mode 100644
index d6bbcc9..0000000
--- a/vendor/google.golang.org/grpc/credentials/credentials_util_pre_go17.go
+++ /dev/null
@@ -1,57 +0,0 @@
-// +build !go1.7
-
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package credentials
-
-import (
-        "crypto/tls"
-)
-
-// cloneTLSConfig returns a shallow clone of the exported
-// fields of cfg, ignoring the unexported sync.Once, which
-// contains a mutex and must not be copied.
-//
-// If cfg is nil, a new zero tls.Config is returned.
-func cloneTLSConfig(cfg *tls.Config) *tls.Config {
-        if cfg == nil {
-                return &tls.Config{}
-        }
-        return &tls.Config{
-                Rand:                     cfg.Rand,
-                Time:                     cfg.Time,
-                Certificates:             cfg.Certificates,
-                NameToCertificate:        cfg.NameToCertificate,
-                GetCertificate:           cfg.GetCertificate,
-                RootCAs:                  cfg.RootCAs,
-                NextProtos:               cfg.NextProtos,
-                ServerName:               cfg.ServerName,
-                ClientAuth:               cfg.ClientAuth,
-                ClientCAs:                cfg.ClientCAs,
-                InsecureSkipVerify:       cfg.InsecureSkipVerify,
-                CipherSuites:             cfg.CipherSuites,
-                PreferServerCipherSuites: cfg.PreferServerCipherSuites,
-                SessionTicketsDisabled:   cfg.SessionTicketsDisabled,
-                SessionTicketKey:         cfg.SessionTicketKey,
-                ClientSessionCache:       cfg.ClientSessionCache,
-                MinVersion:               cfg.MinVersion,
-                MaxVersion:               cfg.MaxVersion,
-                CurvePreferences:         cfg.CurvePreferences,
-        }
-}
diff --git a/vendor/google.golang.org/grpc/credentials/internal/syscallconn.go b/vendor/google.golang.org/grpc/credentials/internal/syscallconn.go
new file mode 100644
index 0000000..2f4472b
--- /dev/null
+++ b/vendor/google.golang.org/grpc/credentials/internal/syscallconn.go
@@ -0,0 +1,61 @@
+// +build !appengine
+
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package internal contains credentials-internal code.
+package internal
+
+import (
+        "net"
+        "syscall"
+)
+
+type sysConn = syscall.Conn
+
+// syscallConn keeps reference of rawConn to support syscall.Conn for channelz.
+// SyscallConn() (the method in interface syscall.Conn) is explicitly
+// implemented on this type,
+//
+// Interface syscall.Conn is implemented by most net.Conn implementations (e.g.
+// TCPConn, UnixConn), but is not part of net.Conn interface. So wrapper conns
+// that embed net.Conn don't implement syscall.Conn. (Side note: tls.Conn
+// doesn't embed net.Conn, so even if syscall.Conn is part of net.Conn, it won't
+// help here).
+type syscallConn struct {
+        net.Conn
+        // sysConn is a type alias of syscall.Conn. It's necessary because the name
+        // `Conn` collides with `net.Conn`.
+        sysConn
+}
+
+// WrapSyscallConn tries to wrap rawConn and newConn into a net.Conn that
+// implements syscall.Conn. rawConn will be used to support syscall, and newConn
+// will be used for read/write.
+//
+// This function returns newConn if rawConn doesn't implement syscall.Conn.
+func WrapSyscallConn(rawConn, newConn net.Conn) net.Conn {
+        sysConn, ok := rawConn.(syscall.Conn)
+        if !ok {
+                return newConn
+        }
+        return &syscallConn{
+                Conn:    newConn,
+                sysConn: sysConn,
+        }
+}
diff --git a/vendor/google.golang.org/grpc/naming/go17.go b/vendor/google.golang.org/grpc/credentials/internal/syscallconn_appengine.go
index a537b08..d4346e9 100644
--- a/vendor/google.golang.org/grpc/naming/go17.go
+++ b/vendor/google.golang.org/grpc/credentials/internal/syscallconn_appengine.go
@@ -1,8 +1,8 @@
-// +build go1.6, !go1.8
+// +build appengine
 
 /*
  *
- * Copyright 2017 gRPC authors.
+ * Copyright 2018 gRPC authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,17 +18,13 @@
  *
  */
 
-package naming
+package internal
 
 import (
         "net"
-
-        "golang.org/x/net/context"
 )
 
-var (
-        lookupHost = func(ctx context.Context, host string) ([]string, error) { return net.LookupHost(host) }
-        lookupSRV  = func(ctx context.Context, service, proto, name string) (string, []*net.SRV, error) {
-                return net.LookupSRV(service, proto, name)
-        }
-)
+// WrapSyscallConn returns newConn on appengine.
+func WrapSyscallConn(rawConn, newConn net.Conn) net.Conn {
+        return newConn
+}
diff --git a/vendor/google.golang.org/grpc/dialoptions.go b/vendor/google.golang.org/grpc/dialoptions.go
new file mode 100644
index 0000000..f286462
--- /dev/null
+++ b/vendor/google.golang.org/grpc/dialoptions.go
@@ -0,0 +1,492 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package grpc
+
+import (
+        "context"
+        "fmt"
+        "net"
+        "time"
+
+        "google.golang.org/grpc/balancer"
+        "google.golang.org/grpc/credentials"
+        "google.golang.org/grpc/internal"
+        "google.golang.org/grpc/internal/backoff"
+        "google.golang.org/grpc/internal/envconfig"
+        "google.golang.org/grpc/internal/transport"
+        "google.golang.org/grpc/keepalive"
+        "google.golang.org/grpc/resolver"
+        "google.golang.org/grpc/stats"
+)
+
+// dialOptions configure a Dial call. dialOptions are set by the DialOption
+// values passed to Dial.
+type dialOptions struct {
+        unaryInt    UnaryClientInterceptor
+        streamInt   StreamClientInterceptor
+        cp          Compressor
+        dc          Decompressor
+        bs          backoff.Strategy
+        block       bool
+        insecure    bool
+        timeout     time.Duration
+        scChan      <-chan ServiceConfig
+        authority   string
+        copts       transport.ConnectOptions
+        callOptions []CallOption
+        // This is used by v1 balancer dial option WithBalancer to support v1
+        // balancer, and also by WithBalancerName dial option.
+        balancerBuilder balancer.Builder
+        // This is to support grpclb.
+        resolverBuilder      resolver.Builder
+        reqHandshake         envconfig.RequireHandshakeSetting
+        channelzParentID     int64
+        disableServiceConfig bool
+        disableRetry         bool
+        disableHealthCheck   bool
+        healthCheckFunc      internal.HealthChecker
+}
+
+// DialOption configures how we set up the connection.
+type DialOption interface {
+        apply(*dialOptions)
+}
+
+// EmptyDialOption does not alter the dial configuration. It can be embedded in
+// another structure to build custom dial options.
+//
+// This API is EXPERIMENTAL.
+type EmptyDialOption struct{}
+
+func (EmptyDialOption) apply(*dialOptions) {}
+
+// funcDialOption wraps a function that modifies dialOptions into an
+// implementation of the DialOption interface.
+type funcDialOption struct {
+        f func(*dialOptions)
+}
+
+func (fdo *funcDialOption) apply(do *dialOptions) {
+        fdo.f(do)
+}
+
+func newFuncDialOption(f func(*dialOptions)) *funcDialOption {
+        return &funcDialOption{
+                f: f,
+        }
+}
+
+// WithWaitForHandshake blocks until the initial settings frame is received from
+// the server before assigning RPCs to the connection.
+//
+// Deprecated: this is the default behavior, and this option will be removed
+// after the 1.18 release.
+func WithWaitForHandshake() DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.reqHandshake = envconfig.RequireHandshakeOn
+        })
+}
+
+// WithWriteBufferSize determines how much data can be batched before doing a
+// write on the wire. The corresponding memory allocation for this buffer will
+// be twice the size to keep syscalls low. The default value for this buffer is
+// 32KB.
+//
+// Zero will disable the write buffer such that each write will be on underlying
+// connection. Note: A Send call may not directly translate to a write.
+func WithWriteBufferSize(s int) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.copts.WriteBufferSize = s
+        })
+}
+
+// WithReadBufferSize lets you set the size of read buffer, this determines how
+// much data can be read at most for each read syscall.
+//
+// The default value for this buffer is 32KB. Zero will disable read buffer for
+// a connection so data framer can access the underlying conn directly.
+func WithReadBufferSize(s int) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.copts.ReadBufferSize = s
+        })
+}
+
+// WithInitialWindowSize returns a DialOption which sets the value for initial
+// window size on a stream. The lower bound for window size is 64K and any value
+// smaller than that will be ignored.
+func WithInitialWindowSize(s int32) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.copts.InitialWindowSize = s
+        })
+}
+
+// WithInitialConnWindowSize returns a DialOption which sets the value for
+// initial window size on a connection. The lower bound for window size is 64K
+// and any value smaller than that will be ignored.
+func WithInitialConnWindowSize(s int32) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.copts.InitialConnWindowSize = s
+        })
+}
+
+// WithMaxMsgSize returns a DialOption which sets the maximum message size the
+// client can receive.
+//
+// Deprecated: use WithDefaultCallOptions(MaxCallRecvMsgSize(s)) instead.
+func WithMaxMsgSize(s int) DialOption {
+        return WithDefaultCallOptions(MaxCallRecvMsgSize(s))
+}
+
+// WithDefaultCallOptions returns a DialOption which sets the default
+// CallOptions for calls over the connection.
+func WithDefaultCallOptions(cos ...CallOption) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.callOptions = append(o.callOptions, cos...)
+        })
+}
+
+// WithCodec returns a DialOption which sets a codec for message marshaling and
+// unmarshaling.
+//
+// Deprecated: use WithDefaultCallOptions(CallCustomCodec(c)) instead.
+func WithCodec(c Codec) DialOption {
+        return WithDefaultCallOptions(CallCustomCodec(c))
+}
+
+// WithCompressor returns a DialOption which sets a Compressor to use for
+// message compression. It has lower priority than the compressor set by the
+// UseCompressor CallOption.
+//
+// Deprecated: use UseCompressor instead.
+func WithCompressor(cp Compressor) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.cp = cp
+        })
+}
+
+// WithDecompressor returns a DialOption which sets a Decompressor to use for
+// incoming message decompression.  If incoming response messages are encoded
+// using the decompressor's Type(), it will be used.  Otherwise, the message
+// encoding will be used to look up the compressor registered via
+// encoding.RegisterCompressor, which will then be used to decompress the
+// message.  If no compressor is registered for the encoding, an Unimplemented
+// status error will be returned.
+//
+// Deprecated: use encoding.RegisterCompressor instead.
+func WithDecompressor(dc Decompressor) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.dc = dc
+        })
+}
+
+// WithBalancer returns a DialOption which sets a load balancer with the v1 API.
+// Name resolver will be ignored if this DialOption is specified.
+//
+// Deprecated: use the new balancer APIs in balancer package and
+// WithBalancerName.
+func WithBalancer(b Balancer) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.balancerBuilder = &balancerWrapperBuilder{
+                        b: b,
+                }
+        })
+}
+
+// WithBalancerName sets the balancer that the ClientConn will be initialized
+// with. Balancer registered with balancerName will be used. This function
+// panics if no balancer was registered by balancerName.
+//
+// The balancer cannot be overridden by balancer option specified by service
+// config.
+//
+// This is an EXPERIMENTAL API.
+func WithBalancerName(balancerName string) DialOption {
+        builder := balancer.Get(balancerName)
+        if builder == nil {
+                panic(fmt.Sprintf("grpc.WithBalancerName: no balancer is registered for name %v", balancerName))
+        }
+        return newFuncDialOption(func(o *dialOptions) {
+                o.balancerBuilder = builder
+        })
+}
+
+// withResolverBuilder is only for grpclb.
+func withResolverBuilder(b resolver.Builder) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.resolverBuilder = b
+        })
+}
+
+// WithServiceConfig returns a DialOption which has a channel to read the
+// service configuration.
+//
+// Deprecated: service config should be received through name resolver, as
+// specified here.
+// https://github.com/grpc/grpc/blob/master/doc/service_config.md
+func WithServiceConfig(c <-chan ServiceConfig) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.scChan = c
+        })
+}
+
+// WithBackoffMaxDelay configures the dialer to use the provided maximum delay
+// when backing off after failed connection attempts.
+func WithBackoffMaxDelay(md time.Duration) DialOption {
+        return WithBackoffConfig(BackoffConfig{MaxDelay: md})
+}
+
+// WithBackoffConfig configures the dialer to use the provided backoff
+// parameters after connection failures.
+//
+// Use WithBackoffMaxDelay until more parameters on BackoffConfig are opened up
+// for use.
+func WithBackoffConfig(b BackoffConfig) DialOption {
+        return withBackoff(backoff.Exponential{
+                MaxDelay: b.MaxDelay,
+        })
+}
+
+// withBackoff sets the backoff strategy used for connectRetryNum after a failed
+// connection attempt.
+//
+// This can be exported if arbitrary backoff strategies are allowed by gRPC.
+func withBackoff(bs backoff.Strategy) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.bs = bs
+        })
+}
+
+// WithBlock returns a DialOption which makes caller of Dial blocks until the
+// underlying connection is up. Without this, Dial returns immediately and
+// connecting the server happens in background.
+func WithBlock() DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.block = true
+        })
+}
+
+// WithInsecure returns a DialOption which disables transport security for this
+// ClientConn. Note that transport security is required unless WithInsecure is
+// set.
+func WithInsecure() DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.insecure = true
+        })
+}
+
+// WithTransportCredentials returns a DialOption which configures a connection
+// level security credentials (e.g., TLS/SSL). This should not be used together
+// with WithCredentialsBundle.
+func WithTransportCredentials(creds credentials.TransportCredentials) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.copts.TransportCredentials = creds
+        })
+}
+
+// WithPerRPCCredentials returns a DialOption which sets credentials and places
+// auth state on each outbound RPC.
+func WithPerRPCCredentials(creds credentials.PerRPCCredentials) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.copts.PerRPCCredentials = append(o.copts.PerRPCCredentials, creds)
+        })
+}
+
+// WithCredentialsBundle returns a DialOption to set a credentials bundle for
+// the ClientConn.WithCreds. This should not be used together with
+// WithTransportCredentials.
+//
+// This API is experimental.
+func WithCredentialsBundle(b credentials.Bundle) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.copts.CredsBundle = b
+        })
+}
+
+// WithTimeout returns a DialOption that configures a timeout for dialing a
+// ClientConn initially. This is valid if and only if WithBlock() is present.
+//
+// Deprecated: use DialContext and context.WithTimeout instead.
+func WithTimeout(d time.Duration) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.timeout = d
+        })
+}
+
+func withContextDialer(f func(context.Context, string) (net.Conn, error)) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.copts.Dialer = f
+        })
+}
+
+func init() {
+        internal.WithContextDialer = withContextDialer
+        internal.WithResolverBuilder = withResolverBuilder
+        internal.WithHealthCheckFunc = withHealthCheckFunc
+}
+
+// WithDialer returns a DialOption that specifies a function to use for dialing
+// network addresses. If FailOnNonTempDialError() is set to true, and an error
+// is returned by f, gRPC checks the error's Temporary() method to decide if it
+// should try to reconnect to the network address.
+func WithDialer(f func(string, time.Duration) (net.Conn, error)) DialOption {
+        return withContextDialer(
+                func(ctx context.Context, addr string) (net.Conn, error) {
+                        if deadline, ok := ctx.Deadline(); ok {
+                                return f(addr, deadline.Sub(time.Now()))
+                        }
+                        return f(addr, 0)
+                })
+}
+
+// WithStatsHandler returns a DialOption that specifies the stats handler for
+// all the RPCs and underlying network connections in this ClientConn.
+func WithStatsHandler(h stats.Handler) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.copts.StatsHandler = h
+        })
+}
+
+// FailOnNonTempDialError returns a DialOption that specifies if gRPC fails on
+// non-temporary dial errors. If f is true, and dialer returns a non-temporary
+// error, gRPC will fail the connection to the network address and won't try to
+// reconnect. The default value of FailOnNonTempDialError is false.
+//
+// FailOnNonTempDialError only affects the initial dial, and does not do
+// anything useful unless you are also using WithBlock().
+//
+// This is an EXPERIMENTAL API.
+func FailOnNonTempDialError(f bool) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.copts.FailOnNonTempDialError = f
+        })
+}
+
+// WithUserAgent returns a DialOption that specifies a user agent string for all
+// the RPCs.
+func WithUserAgent(s string) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.copts.UserAgent = s
+        })
+}
+
+// WithKeepaliveParams returns a DialOption that specifies keepalive parameters
+// for the client transport.
+func WithKeepaliveParams(kp keepalive.ClientParameters) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.copts.KeepaliveParams = kp
+        })
+}
+
+// WithUnaryInterceptor returns a DialOption that specifies the interceptor for
+// unary RPCs.
+func WithUnaryInterceptor(f UnaryClientInterceptor) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.unaryInt = f
+        })
+}
+
+// WithStreamInterceptor returns a DialOption that specifies the interceptor for
+// streaming RPCs.
+func WithStreamInterceptor(f StreamClientInterceptor) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.streamInt = f
+        })
+}
+
+// WithAuthority returns a DialOption that specifies the value to be used as the
+// :authority pseudo-header. This value only works with WithInsecure and has no
+// effect if TransportCredentials are present.
+func WithAuthority(a string) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.authority = a
+        })
+}
+
+// WithChannelzParentID returns a DialOption that specifies the channelz ID of
+// current ClientConn's parent. This function is used in nested channel creation
+// (e.g. grpclb dial).
+func WithChannelzParentID(id int64) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.channelzParentID = id
+        })
+}
+
+// WithDisableServiceConfig returns a DialOption that causes grpc to ignore any
+// service config provided by the resolver and provides a hint to the resolver
+// to not fetch service configs.
+func WithDisableServiceConfig() DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.disableServiceConfig = true
+        })
+}
+
+// WithDisableRetry returns a DialOption that disables retries, even if the
+// service config enables them.  This does not impact transparent retries, which
+// will happen automatically if no data is written to the wire or if the RPC is
+// unprocessed by the remote server.
+//
+// Retry support is currently disabled by default, but will be enabled by
+// default in the future.  Until then, it may be enabled by setting the
+// environment variable "GRPC_GO_RETRY" to "on".
+//
+// This API is EXPERIMENTAL.
+func WithDisableRetry() DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.disableRetry = true
+        })
+}
+
+// WithMaxHeaderListSize returns a DialOption that specifies the maximum
+// (uncompressed) size of header list that the client is prepared to accept.
+func WithMaxHeaderListSize(s uint32) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.copts.MaxHeaderListSize = &s
+        })
+}
+
+// WithDisableHealthCheck disables the LB channel health checking for all SubConns of this ClientConn.
+//
+// This API is EXPERIMENTAL.
+func WithDisableHealthCheck() DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.disableHealthCheck = true
+        })
+}
+
+// withHealthCheckFunc replaces the default health check function with the provided one. It makes
+// tests easier to change the health check function.
+//
+// For testing purpose only.
+func withHealthCheckFunc(f internal.HealthChecker) DialOption {
+        return newFuncDialOption(func(o *dialOptions) {
+                o.healthCheckFunc = f
+        })
+}
+
+func defaultDialOptions() dialOptions {
+        return dialOptions{
+                disableRetry:    !envconfig.Retry,
+                reqHandshake:    envconfig.RequireHandshake,
+                healthCheckFunc: internal.HealthCheckFunc,
+                copts: transport.ConnectOptions{
+                        WriteBufferSize: defaultWriteBufSize,
+                        ReadBufferSize:  defaultReadBufSize,
+                },
+        }
+}
diff --git a/vendor/google.golang.org/grpc/encoding/encoding.go b/vendor/google.golang.org/grpc/encoding/encoding.go
new file mode 100644
index 0000000..ade8b7c
--- /dev/null
+++ b/vendor/google.golang.org/grpc/encoding/encoding.go
@@ -0,0 +1,118 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package encoding defines the interface for the compressor and codec, and
+// functions to register and retrieve compressors and codecs.
+//
+// This package is EXPERIMENTAL.
+package encoding
+
+import (
+        "io"
+        "strings"
+)
+
+// Identity specifies the optional encoding for uncompressed streams.
+// It is intended for grpc internal use only.
+const Identity = "identity"
+
+// Compressor is used for compressing and decompressing when sending or
+// receiving messages.
+type Compressor interface {
+        // Compress writes the data written to wc to w after compressing it.  If an
+        // error occurs while initializing the compressor, that error is returned
+        // instead.
+        Compress(w io.Writer) (io.WriteCloser, error)
+        // Decompress reads data from r, decompresses it, and provides the
+        // uncompressed data via the returned io.Reader.  If an error occurs while
+        // initializing the decompressor, that error is returned instead.
+        Decompress(r io.Reader) (io.Reader, error)
+        // Name is the name of the compression codec and is used to set the content
+        // coding header.  The result must be static; the result cannot change
+        // between calls.
+        Name() string
+}
+
+var registeredCompressor = make(map[string]Compressor)
+
+// RegisterCompressor registers the compressor with gRPC by its name.  It can
+// be activated when sending an RPC via grpc.UseCompressor().  It will be
+// automatically accessed when receiving a message based on the content coding
+// header.  Servers also use it to send a response with the same encoding as
+// the request.
+//
+// NOTE: this function must only be called during initialization time (i.e. in
+// an init() function), and is not thread-safe.  If multiple Compressors are
+// registered with the same name, the one registered last will take effect.
+func RegisterCompressor(c Compressor) {
+        registeredCompressor[c.Name()] = c
+}
+
+// GetCompressor returns Compressor for the given compressor name.
+func GetCompressor(name string) Compressor {
+        return registeredCompressor[name]
+}
+
+// Codec defines the interface gRPC uses to encode and decode messages.  Note
+// that implementations of this interface must be thread safe; a Codec's
+// methods can be called from concurrent goroutines.
+type Codec interface {
+        // Marshal returns the wire format of v.
+        Marshal(v interface{}) ([]byte, error)
+        // Unmarshal parses the wire format into v.
+        Unmarshal(data []byte, v interface{}) error
+        // Name returns the name of the Codec implementation. The returned string
+        // will be used as part of content type in transmission.  The result must be
+        // static; the result cannot change between calls.
+        Name() string
+}
+
+var registeredCodecs = make(map[string]Codec)
+
+// RegisterCodec registers the provided Codec for use with all gRPC clients and
+// servers.
+//
+// The Codec will be stored and looked up by result of its Name() method, which
+// should match the content-subtype of the encoding handled by the Codec.  This
+// is case-insensitive, and is stored and looked up as lowercase.  If the
+// result of calling Name() is an empty string, RegisterCodec will panic. See
+// Content-Type on
+// https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#requests for
+// more details.
+//
+// NOTE: this function must only be called during initialization time (i.e. in
+// an init() function), and is not thread-safe.  If multiple Compressors are
+// registered with the same name, the one registered last will take effect.
+func RegisterCodec(codec Codec) {
+        if codec == nil {
+                panic("cannot register a nil Codec")
+        }
+        contentSubtype := strings.ToLower(codec.Name())
+        if contentSubtype == "" {
+                panic("cannot register Codec with empty string result for String()")
+        }
+        registeredCodecs[contentSubtype] = codec
+}
+
+// GetCodec gets a registered Codec by content-subtype, or nil if no Codec is
+// registered for the content-subtype.
+//
+// The content-subtype is expected to be lowercase.
+func GetCodec(contentSubtype string) Codec {
+        return registeredCodecs[contentSubtype]
+}
diff --git a/vendor/google.golang.org/grpc/encoding/proto/proto.go b/vendor/google.golang.org/grpc/encoding/proto/proto.go
new file mode 100644
index 0000000..66b97a6
--- /dev/null
+++ b/vendor/google.golang.org/grpc/encoding/proto/proto.go
@@ -0,0 +1,110 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package proto defines the protobuf codec. Importing this package will
+// register the codec.
+package proto
+
+import (
+        "math"
+        "sync"
+
+        "github.com/golang/protobuf/proto"
+        "google.golang.org/grpc/encoding"
+)
+
+// Name is the name registered for the proto compressor.
+const Name = "proto"
+
+func init() {
+        encoding.RegisterCodec(codec{})
+}
+
+// codec is a Codec implementation with protobuf. It is the default codec for gRPC.
+type codec struct{}
+
+type cachedProtoBuffer struct {
+        lastMarshaledSize uint32
+        proto.Buffer
+}
+
+func capToMaxInt32(val int) uint32 {
+        if val > math.MaxInt32 {
+                return uint32(math.MaxInt32)
+        }
+        return uint32(val)
+}
+
+func marshal(v interface{}, cb *cachedProtoBuffer) ([]byte, error) {
+        protoMsg := v.(proto.Message)
+        newSlice := make([]byte, 0, cb.lastMarshaledSize)
+
+        cb.SetBuf(newSlice)
+        cb.Reset()
+        if err := cb.Marshal(protoMsg); err != nil {
+                return nil, err
+        }
+        out := cb.Bytes()
+        cb.lastMarshaledSize = capToMaxInt32(len(out))
+        return out, nil
+}
+
+func (codec) Marshal(v interface{}) ([]byte, error) {
+        if pm, ok := v.(proto.Marshaler); ok {
+                // object can marshal itself, no need for buffer
+                return pm.Marshal()
+        }
+
+        cb := protoBufferPool.Get().(*cachedProtoBuffer)
+        out, err := marshal(v, cb)
+
+        // put back buffer and lose the ref to the slice
+        cb.SetBuf(nil)
+        protoBufferPool.Put(cb)
+        return out, err
+}
+
+func (codec) Unmarshal(data []byte, v interface{}) error {
+        protoMsg := v.(proto.Message)
+        protoMsg.Reset()
+
+        if pu, ok := protoMsg.(proto.Unmarshaler); ok {
+                // object can unmarshal itself, no need for buffer
+                return pu.Unmarshal(data)
+        }
+
+        cb := protoBufferPool.Get().(*cachedProtoBuffer)
+        cb.SetBuf(data)
+        err := cb.Unmarshal(protoMsg)
+        cb.SetBuf(nil)
+        protoBufferPool.Put(cb)
+        return err
+}
+
+func (codec) Name() string {
+        return Name
+}
+
+var protoBufferPool = &sync.Pool{
+        New: func() interface{} {
+                return &cachedProtoBuffer{
+                        Buffer:            proto.Buffer{},
+                        lastMarshaledSize: 16,
+                }
+        },
+}
diff --git a/vendor/google.golang.org/grpc/go.mod b/vendor/google.golang.org/grpc/go.mod
new file mode 100644
index 0000000..f296dcf
--- /dev/null
+++ b/vendor/google.golang.org/grpc/go.mod
@@ -0,0 +1,20 @@
+module google.golang.org/grpc
+
+require (
+        cloud.google.com/go v0.26.0 // indirect
+        github.com/client9/misspell v0.3.4
+        github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b
+        github.com/golang/mock v1.1.1
+        github.com/golang/protobuf v1.2.0
+        github.com/kisielk/gotool v1.0.0 // indirect
+        golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3
+        golang.org/x/net v0.0.0-20180826012351-8a410e7b638d
+        golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be
+        golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f // indirect
+        golang.org/x/sys v0.0.0-20180830151530-49385e6e1522
+        golang.org/x/text v0.3.0 // indirect
+        golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52
+        google.golang.org/appengine v1.1.0 // indirect
+        google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8
+        honnef.co/go/tools v0.0.0-20180728063816-88497007e858
+)
diff --git a/vendor/google.golang.org/grpc/go.sum b/vendor/google.golang.org/grpc/go.sum
new file mode 100644
index 0000000..bfb6bb7
--- /dev/null
+++ b/vendor/google.golang.org/grpc/go.sum
@@ -0,0 +1,32 @@
+cloud.google.com/go v0.26.0 h1:e0WKqKTd5BnrG8aKH3J3h+QvEIQtSUcf2n5UZ5ZgLtQ=
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+github.com/client9/misspell v0.3.4 h1:ta993UF76GwbvJcIo3Y68y/M3WxlpEHPWIGDkJYwzJI=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/mock v1.1.1 h1:G5FRp8JnTd7RQH5kemVNlMeyXQAztQ3mOWV95KxsXH8=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/kisielk/gotool v1.0.0 h1:AV2c/EiW3KqPNT9ZKl07ehoAGi4C5/01Cfbblndcapg=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3 h1:x/bBzNauLQAlE3fLku/xy92Y8QwKX5HZymrMz2IiKFc=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d h1:g9qWBGx4puODJTMVyoPrpoxPFgVGd+z1DZwjfRu4d0I=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be h1:vEDujvNQGv4jgYKudGeI/+DAX4Jffq6hpD55MmoEvKs=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522 h1:Ve1ORMCxvRmSXBwJK+t3Oy+V2vRW2OetUQBq4rJIkZE=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52 h1:JG/0uqcGdTNgq7FdU+61l5Pdmb8putNZlXb65bJBROs=
+golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+google.golang.org/appengine v1.1.0 h1:igQkv0AAhEIvTEpD5LIpAfav2eeVO9HBTjvKHVJPRSs=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8 h1:Nw54tB0rB7hY/N0NQvRW8DG4Yk3Q6T9cu9RcFQDu1tc=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+honnef.co/go/tools v0.0.0-20180728063816-88497007e858 h1:wN+eVZ7U+gqdqkec6C6VXR1OFf9a5Ul9ETzeYsYv20g=
+honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
diff --git a/vendor/google.golang.org/grpc/go16.go b/vendor/google.golang.org/grpc/go16.go
deleted file mode 100644
index f3dbf21..0000000
--- a/vendor/google.golang.org/grpc/go16.go
+++ /dev/null
@@ -1,98 +0,0 @@
-// +build go1.6,!go1.7
-
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package grpc
-
-import (
-        "fmt"
-        "io"
-        "net"
-        "net/http"
-        "os"
-
-        "golang.org/x/net/context"
-        "google.golang.org/grpc/codes"
-        "google.golang.org/grpc/status"
-        "google.golang.org/grpc/transport"
-)
-
-// dialContext connects to the address on the named network.
-func dialContext(ctx context.Context, network, address string) (net.Conn, error) {
-        return (&net.Dialer{Cancel: ctx.Done()}).Dial(network, address)
-}
-
-func sendHTTPRequest(ctx context.Context, req *http.Request, conn net.Conn) error {
-        req.Cancel = ctx.Done()
-        if err := req.Write(conn); err != nil {
-                return fmt.Errorf("failed to write the HTTP request: %v", err)
-        }
-        return nil
-}
-
-// toRPCErr converts an error into an error from the status package.
-func toRPCErr(err error) error {
-        if _, ok := status.FromError(err); ok {
-                return err
-        }
-        switch e := err.(type) {
-        case transport.StreamError:
-                return status.Error(e.Code, e.Desc)
-        case transport.ConnectionError:
-                return status.Error(codes.Unavailable, e.Desc)
-        default:
-                switch err {
-                case context.DeadlineExceeded:
-                        return status.Error(codes.DeadlineExceeded, err.Error())
-                case context.Canceled:
-                        return status.Error(codes.Canceled, err.Error())
-                case ErrClientConnClosing:
-                        return status.Error(codes.FailedPrecondition, err.Error())
-                }
-        }
-        return status.Error(codes.Unknown, err.Error())
-}
-
-// convertCode converts a standard Go error into its canonical code. Note that
-// this is only used to translate the error returned by the server applications.
-func convertCode(err error) codes.Code {
-        switch err {
-        case nil:
-                return codes.OK
-        case io.EOF:
-                return codes.OutOfRange
-        case io.ErrClosedPipe, io.ErrNoProgress, io.ErrShortBuffer, io.ErrShortWrite, io.ErrUnexpectedEOF:
-                return codes.FailedPrecondition
-        case os.ErrInvalid:
-                return codes.InvalidArgument
-        case context.Canceled:
-                return codes.Canceled
-        case context.DeadlineExceeded:
-                return codes.DeadlineExceeded
-        }
-        switch {
-        case os.IsExist(err):
-                return codes.AlreadyExists
-        case os.IsNotExist(err):
-                return codes.NotFound
-        case os.IsPermission(err):
-                return codes.PermissionDenied
-        }
-        return codes.Unknown
-}
diff --git a/vendor/google.golang.org/grpc/go17.go b/vendor/google.golang.org/grpc/go17.go
deleted file mode 100644
index a3421d9..0000000
--- a/vendor/google.golang.org/grpc/go17.go
+++ /dev/null
@@ -1,98 +0,0 @@
-// +build go1.7
-
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package grpc
-
-import (
-        "context"
-        "io"
-        "net"
-        "net/http"
-        "os"
-
-        netctx "golang.org/x/net/context"
-        "google.golang.org/grpc/codes"
-        "google.golang.org/grpc/status"
-        "google.golang.org/grpc/transport"
-)
-
-// dialContext connects to the address on the named network.
-func dialContext(ctx context.Context, network, address string) (net.Conn, error) {
-        return (&net.Dialer{}).DialContext(ctx, network, address)
-}
-
-func sendHTTPRequest(ctx context.Context, req *http.Request, conn net.Conn) error {
-        req = req.WithContext(ctx)
-        if err := req.Write(conn); err != nil {
-                return err
-        }
-        return nil
-}
-
-// toRPCErr converts an error into an error from the status package.
-func toRPCErr(err error) error {
-        if _, ok := status.FromError(err); ok {
-                return err
-        }
-        switch e := err.(type) {
-        case transport.StreamError:
-                return status.Error(e.Code, e.Desc)
-        case transport.ConnectionError:
-                return status.Error(codes.Unavailable, e.Desc)
-        default:
-                switch err {
-                case context.DeadlineExceeded, netctx.DeadlineExceeded:
-                        return status.Error(codes.DeadlineExceeded, err.Error())
-                case context.Canceled, netctx.Canceled:
-                        return status.Error(codes.Canceled, err.Error())
-                case ErrClientConnClosing:
-                        return status.Error(codes.FailedPrecondition, err.Error())
-                }
-        }
-        return status.Error(codes.Unknown, err.Error())
-}
-
-// convertCode converts a standard Go error into its canonical code. Note that
-// this is only used to translate the error returned by the server applications.
-func convertCode(err error) codes.Code {
-        switch err {
-        case nil:
-                return codes.OK
-        case io.EOF:
-                return codes.OutOfRange
-        case io.ErrClosedPipe, io.ErrNoProgress, io.ErrShortBuffer, io.ErrShortWrite, io.ErrUnexpectedEOF:
-                return codes.FailedPrecondition
-        case os.ErrInvalid:
-                return codes.InvalidArgument
-        case context.Canceled, netctx.Canceled:
-                return codes.Canceled
-        case context.DeadlineExceeded, netctx.DeadlineExceeded:
-                return codes.DeadlineExceeded
-        }
-        switch {
-        case os.IsExist(err):
-                return codes.AlreadyExists
-        case os.IsNotExist(err):
-                return codes.NotFound
-        case os.IsPermission(err):
-                return codes.PermissionDenied
-        }
-        return codes.Unknown
-}
diff --git a/vendor/google.golang.org/grpc/grpclb.go b/vendor/google.golang.org/grpc/grpclb.go
deleted file mode 100644
index f7b6b7d..0000000
--- a/vendor/google.golang.org/grpc/grpclb.go
+++ /dev/null
@@ -1,737 +0,0 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package grpc
-
-import (
-        "errors"
-        "fmt"
-        "math/rand"
-        "net"
-        "sync"
-        "time"
-
-        "golang.org/x/net/context"
-        "google.golang.org/grpc/codes"
-        lbpb "google.golang.org/grpc/grpclb/grpc_lb_v1"
-        "google.golang.org/grpc/grpclog"
-        "google.golang.org/grpc/metadata"
-        "google.golang.org/grpc/naming"
-)
-
-// Client API for LoadBalancer service.
-// Mostly copied from generated pb.go file.
-// To avoid circular dependency.
-type loadBalancerClient struct {
-        cc *ClientConn
-}
-
-func (c *loadBalancerClient) BalanceLoad(ctx context.Context, opts ...CallOption) (*balanceLoadClientStream, error) {
-        desc := &StreamDesc{
-                StreamName:    "BalanceLoad",
-                ServerStreams: true,
-                ClientStreams: true,
-        }
-        stream, err := NewClientStream(ctx, desc, c.cc, "/grpc.lb.v1.LoadBalancer/BalanceLoad", opts...)
-        if err != nil {
-                return nil, err
-        }
-        x := &balanceLoadClientStream{stream}
-        return x, nil
-}
-
-type balanceLoadClientStream struct {
-        ClientStream
-}
-
-func (x *balanceLoadClientStream) Send(m *lbpb.LoadBalanceRequest) error {
-        return x.ClientStream.SendMsg(m)
-}
-
-func (x *balanceLoadClientStream) Recv() (*lbpb.LoadBalanceResponse, error) {
-        m := new(lbpb.LoadBalanceResponse)
-        if err := x.ClientStream.RecvMsg(m); err != nil {
-                return nil, err
-        }
-        return m, nil
-}
-
-// NewGRPCLBBalancer creates a grpclb load balancer.
-func NewGRPCLBBalancer(r naming.Resolver) Balancer {
-        return &balancer{
-                r: r,
-        }
-}
-
-type remoteBalancerInfo struct {
-        addr string
-        // the server name used for authentication with the remote LB server.
-        name string
-}
-
-// grpclbAddrInfo consists of the information of a backend server.
-type grpclbAddrInfo struct {
-        addr      Address
-        connected bool
-        // dropForRateLimiting indicates whether this particular request should be
-        // dropped by the client for rate limiting.
-        dropForRateLimiting bool
-        // dropForLoadBalancing indicates whether this particular request should be
-        // dropped by the client for load balancing.
-        dropForLoadBalancing bool
-}
-
-type balancer struct {
-        r        naming.Resolver
-        target   string
-        mu       sync.Mutex
-        seq      int // a sequence number to make sure addrCh does not get stale addresses.
-        w        naming.Watcher
-        addrCh   chan []Address
-        rbs      []remoteBalancerInfo
-        addrs    []*grpclbAddrInfo
-        next     int
-        waitCh   chan struct{}
-        done     bool
-        expTimer *time.Timer
-        rand     *rand.Rand
-
-        clientStats lbpb.ClientStats
-}
-
-func (b *balancer) watchAddrUpdates(w naming.Watcher, ch chan []remoteBalancerInfo) error {
-        updates, err := w.Next()
-        if err != nil {
-                grpclog.Warningf("grpclb: failed to get next addr update from watcher: %v", err)
-                return err
-        }
-        b.mu.Lock()
-        defer b.mu.Unlock()
-        if b.done {
-                return ErrClientConnClosing
-        }
-        for _, update := range updates {
-                switch update.Op {
-                case naming.Add:
-                        var exist bool
-                        for _, v := range b.rbs {
-                                // TODO: Is the same addr with different server name a different balancer?
-                                if update.Addr == v.addr {
-                                        exist = true
-                                        break
-                                }
-                        }
-                        if exist {
-                                continue
-                        }
-                        md, ok := update.Metadata.(*naming.AddrMetadataGRPCLB)
-                        if !ok {
-                                // TODO: Revisit the handling here and may introduce some fallback mechanism.
-                                grpclog.Errorf("The name resolution contains unexpected metadata %v", update.Metadata)
-                                continue
-                        }
-                        switch md.AddrType {
-                        case naming.Backend:
-                                // TODO: Revisit the handling here and may introduce some fallback mechanism.
-                                grpclog.Errorf("The name resolution does not give grpclb addresses")
-                                continue
-                        case naming.GRPCLB:
-                                b.rbs = append(b.rbs, remoteBalancerInfo{
-                                        addr: update.Addr,
-                                        name: md.ServerName,
-                                })
-                        default:
-                                grpclog.Errorf("Received unknow address type %d", md.AddrType)
-                                continue
-                        }
-                case naming.Delete:
-                        for i, v := range b.rbs {
-                                if update.Addr == v.addr {
-                                        copy(b.rbs[i:], b.rbs[i+1:])
-                                        b.rbs = b.rbs[:len(b.rbs)-1]
-                                        break
-                                }
-                        }
-                default:
-                        grpclog.Errorf("Unknown update.Op %v", update.Op)
-                }
-        }
-        // TODO: Fall back to the basic round-robin load balancing if the resulting address is
-        // not a load balancer.
-        select {
-        case <-ch:
-        default:
-        }
-        ch <- b.rbs
-        return nil
-}
-
-func (b *balancer) serverListExpire(seq int) {
-        b.mu.Lock()
-        defer b.mu.Unlock()
-        // TODO: gRPC interanls do not clear the connections when the server list is stale.
-        // This means RPCs will keep using the existing server list until b receives new
-        // server list even though the list is expired. Revisit this behavior later.
-        if b.done || seq < b.seq {
-                return
-        }
-        b.next = 0
-        b.addrs = nil
-        // Ask grpc internals to close all the corresponding connections.
-        b.addrCh <- nil
-}
-
-func convertDuration(d *lbpb.Duration) time.Duration {
-        if d == nil {
-                return 0
-        }
-        return time.Duration(d.Seconds)*time.Second + time.Duration(d.Nanos)*time.Nanosecond
-}
-
-func (b *balancer) processServerList(l *lbpb.ServerList, seq int) {
-        if l == nil {
-                return
-        }
-        servers := l.GetServers()
-        expiration := convertDuration(l.GetExpirationInterval())
-        var (
-                sl    []*grpclbAddrInfo
-                addrs []Address
-        )
-        for _, s := range servers {
-                md := metadata.Pairs("lb-token", s.LoadBalanceToken)
-                ip := net.IP(s.IpAddress)
-                ipStr := ip.String()
-                if ip.To4() == nil {
-                        // Add square brackets to ipv6 addresses, otherwise net.Dial() and
-                        // net.SplitHostPort() will return too many colons error.
-                        ipStr = fmt.Sprintf("[%s]", ipStr)
-                }
-                addr := Address{
-                        Addr:     fmt.Sprintf("%s:%d", ipStr, s.Port),
-                        Metadata: &md,
-                }
-                sl = append(sl, &grpclbAddrInfo{
-                        addr:                 addr,
-                        dropForRateLimiting:  s.DropForRateLimiting,
-                        dropForLoadBalancing: s.DropForLoadBalancing,
-                })
-                addrs = append(addrs, addr)
-        }
-        b.mu.Lock()
-        defer b.mu.Unlock()
-        if b.done || seq < b.seq {
-                return
-        }
-        if len(sl) > 0 {
-                // reset b.next to 0 when replacing the server list.
-                b.next = 0
-                b.addrs = sl
-                b.addrCh <- addrs
-                if b.expTimer != nil {
-                        b.expTimer.Stop()
-                        b.expTimer = nil
-                }
-                if expiration > 0 {
-                        b.expTimer = time.AfterFunc(expiration, func() {
-                                b.serverListExpire(seq)
-                        })
-                }
-        }
-        return
-}
-
-func (b *balancer) sendLoadReport(s *balanceLoadClientStream, interval time.Duration, done <-chan struct{}) {
-        ticker := time.NewTicker(interval)
-        defer ticker.Stop()
-        for {
-                select {
-                case <-ticker.C:
-                case <-done:
-                        return
-                }
-                b.mu.Lock()
-                stats := b.clientStats
-                b.clientStats = lbpb.ClientStats{} // Clear the stats.
-                b.mu.Unlock()
-                t := time.Now()
-                stats.Timestamp = &lbpb.Timestamp{
-                        Seconds: t.Unix(),
-                        Nanos:   int32(t.Nanosecond()),
-                }
-                if err := s.Send(&lbpb.LoadBalanceRequest{
-                        LoadBalanceRequestType: &lbpb.LoadBalanceRequest_ClientStats{
-                                ClientStats: &stats,
-                        },
-                }); err != nil {
-                        grpclog.Errorf("grpclb: failed to send load report: %v", err)
-                        return
-                }
-        }
-}
-
-func (b *balancer) callRemoteBalancer(lbc *loadBalancerClient, seq int) (retry bool) {
-        ctx, cancel := context.WithCancel(context.Background())
-        defer cancel()
-        stream, err := lbc.BalanceLoad(ctx)
-        if err != nil {
-                grpclog.Errorf("grpclb: failed to perform RPC to the remote balancer %v", err)
-                return
-        }
-        b.mu.Lock()
-        if b.done {
-                b.mu.Unlock()
-                return
-        }
-        b.mu.Unlock()
-        initReq := &lbpb.LoadBalanceRequest{
-                LoadBalanceRequestType: &lbpb.LoadBalanceRequest_InitialRequest{
-                        InitialRequest: &lbpb.InitialLoadBalanceRequest{
-                                Name: b.target,
-                        },
-                },
-        }
-        if err := stream.Send(initReq); err != nil {
-                grpclog.Errorf("grpclb: failed to send init request: %v", err)
-                // TODO: backoff on retry?
-                return true
-        }
-        reply, err := stream.Recv()
-        if err != nil {
-                grpclog.Errorf("grpclb: failed to recv init response: %v", err)
-                // TODO: backoff on retry?
-                return true
-        }
-        initResp := reply.GetInitialResponse()
-        if initResp == nil {
-                grpclog.Errorf("grpclb: reply from remote balancer did not include initial response.")
-                return
-        }
-        // TODO: Support delegation.
-        if initResp.LoadBalancerDelegate != "" {
-                // delegation
-                grpclog.Errorf("TODO: Delegation is not supported yet.")
-                return
-        }
-        streamDone := make(chan struct{})
-        defer close(streamDone)
-        b.mu.Lock()
-        b.clientStats = lbpb.ClientStats{} // Clear client stats.
-        b.mu.Unlock()
-        if d := convertDuration(initResp.ClientStatsReportInterval); d > 0 {
-                go b.sendLoadReport(stream, d, streamDone)
-        }
-        // Retrieve the server list.
-        for {
-                reply, err := stream.Recv()
-                if err != nil {
-                        grpclog.Errorf("grpclb: failed to recv server list: %v", err)
-                        break
-                }
-                b.mu.Lock()
-                if b.done || seq < b.seq {
-                        b.mu.Unlock()
-                        return
-                }
-                b.seq++ // tick when receiving a new list of servers.
-                seq = b.seq
-                b.mu.Unlock()
-                if serverList := reply.GetServerList(); serverList != nil {
-                        b.processServerList(serverList, seq)
-                }
-        }
-        return true
-}
-
-func (b *balancer) Start(target string, config BalancerConfig) error {
-        b.rand = rand.New(rand.NewSource(time.Now().Unix()))
-        // TODO: Fall back to the basic direct connection if there is no name resolver.
-        if b.r == nil {
-                return errors.New("there is no name resolver installed")
-        }
-        b.target = target
-        b.mu.Lock()
-        if b.done {
-                b.mu.Unlock()
-                return ErrClientConnClosing
-        }
-        b.addrCh = make(chan []Address)
-        w, err := b.r.Resolve(target)
-        if err != nil {
-                b.mu.Unlock()
-                grpclog.Errorf("grpclb: failed to resolve address: %v, err: %v", target, err)
-                return err
-        }
-        b.w = w
-        b.mu.Unlock()
-        balancerAddrsCh := make(chan []remoteBalancerInfo, 1)
-        // Spawn a goroutine to monitor the name resolution of remote load balancer.
-        go func() {
-                for {
-                        if err := b.watchAddrUpdates(w, balancerAddrsCh); err != nil {
-                                grpclog.Warningf("grpclb: the naming watcher stops working due to %v.\n", err)
-                                close(balancerAddrsCh)
-                                return
-                        }
-                }
-        }()
-        // Spawn a goroutine to talk to the remote load balancer.
-        go func() {
-                var (
-                        cc *ClientConn
-                        // ccError is closed when there is an error in the current cc.
-                        // A new rb should be picked from rbs and connected.
-                        ccError chan struct{}
-                        rb      *remoteBalancerInfo
-                        rbs     []remoteBalancerInfo
-                        rbIdx   int
-                )
-
-                defer func() {
-                        if ccError != nil {
-                                select {
-                                case <-ccError:
-                                default:
-                                        close(ccError)
-                                }
-                        }
-                        if cc != nil {
-                                cc.Close()
-                        }
-                }()
-
-                for {
-                        var ok bool
-                        select {
-                        case rbs, ok = <-balancerAddrsCh:
-                                if !ok {
-                                        return
-                                }
-                                foundIdx := -1
-                                if rb != nil {
-                                        for i, trb := range rbs {
-                                                if trb == *rb {
-                                                        foundIdx = i
-                                                        break
-                                                }
-                                        }
-                                }
-                                if foundIdx >= 0 {
-                                        if foundIdx >= 1 {
-                                                // Move the address in use to the beginning of the list.
-                                                b.rbs[0], b.rbs[foundIdx] = b.rbs[foundIdx], b.rbs[0]
-                                                rbIdx = 0
-                                        }
-                                        continue // If found, don't dial new cc.
-                                } else if len(rbs) > 0 {
-                                        // Pick a random one from the list, instead of always using the first one.
-                                        if l := len(rbs); l > 1 && rb != nil {
-                                                tmpIdx := b.rand.Intn(l - 1)
-                                                b.rbs[0], b.rbs[tmpIdx] = b.rbs[tmpIdx], b.rbs[0]
-                                        }
-                                        rbIdx = 0
-                                        rb = &rbs[0]
-                                } else {
-                                        // foundIdx < 0 && len(rbs) <= 0.
-                                        rb = nil
-                                }
-                        case <-ccError:
-                                ccError = nil
-                                if rbIdx < len(rbs)-1 {
-                                        rbIdx++
-                                        rb = &rbs[rbIdx]
-                                } else {
-                                        rb = nil
-                                }
-                        }
-
-                        if rb == nil {
-                                continue
-                        }
-
-                        if cc != nil {
-                                cc.Close()
-                        }
-                        // Talk to the remote load balancer to get the server list.
-                        var (
-                                err   error
-                                dopts []DialOption
-                        )
-                        if creds := config.DialCreds; creds != nil {
-                                if rb.name != "" {
-                                        if err := creds.OverrideServerName(rb.name); err != nil {
-                                                grpclog.Warningf("grpclb: failed to override the server name in the credentials: %v", err)
-                                                continue
-                                        }
-                                }
-                                dopts = append(dopts, WithTransportCredentials(creds))
-                        } else {
-                                dopts = append(dopts, WithInsecure())
-                        }
-                        if dialer := config.Dialer; dialer != nil {
-                                // WithDialer takes a different type of function, so we instead use a special DialOption here.
-                                dopts = append(dopts, func(o *dialOptions) { o.copts.Dialer = dialer })
-                        }
-                        ccError = make(chan struct{})
-                        cc, err = Dial(rb.addr, dopts...)
-                        if err != nil {
-                                grpclog.Warningf("grpclb: failed to setup a connection to the remote balancer %v: %v", rb.addr, err)
-                                close(ccError)
-                                continue
-                        }
-                        b.mu.Lock()
-                        b.seq++ // tick when getting a new balancer address
-                        seq := b.seq
-                        b.next = 0
-                        b.mu.Unlock()
-                        go func(cc *ClientConn, ccError chan struct{}) {
-                                lbc := &loadBalancerClient{cc}
-                                b.callRemoteBalancer(lbc, seq)
-                                cc.Close()
-                                select {
-                                case <-ccError:
-                                default:
-                                        close(ccError)
-                                }
-                        }(cc, ccError)
-                }
-        }()
-        return nil
-}
-
-func (b *balancer) down(addr Address, err error) {
-        b.mu.Lock()
-        defer b.mu.Unlock()
-        for _, a := range b.addrs {
-                if addr == a.addr {
-                        a.connected = false
-                        break
-                }
-        }
-}
-
-func (b *balancer) Up(addr Address) func(error) {
-        b.mu.Lock()
-        defer b.mu.Unlock()
-        if b.done {
-                return nil
-        }
-        var cnt int
-        for _, a := range b.addrs {
-                if a.addr == addr {
-                        if a.connected {
-                                return nil
-                        }
-                        a.connected = true
-                }
-                if a.connected && !a.dropForRateLimiting && !a.dropForLoadBalancing {
-                        cnt++
-                }
-        }
-        // addr is the only one which is connected. Notify the Get() callers who are blocking.
-        if cnt == 1 && b.waitCh != nil {
-                close(b.waitCh)
-                b.waitCh = nil
-        }
-        return func(err error) {
-                b.down(addr, err)
-        }
-}
-
-func (b *balancer) Get(ctx context.Context, opts BalancerGetOptions) (addr Address, put func(), err error) {
-        var ch chan struct{}
-        b.mu.Lock()
-        if b.done {
-                b.mu.Unlock()
-                err = ErrClientConnClosing
-                return
-        }
-        seq := b.seq
-
-        defer func() {
-                if err != nil {
-                        return
-                }
-                put = func() {
-                        s, ok := rpcInfoFromContext(ctx)
-                        if !ok {
-                                return
-                        }
-                        b.mu.Lock()
-                        defer b.mu.Unlock()
-                        if b.done || seq < b.seq {
-                                return
-                        }
-                        b.clientStats.NumCallsFinished++
-                        if !s.bytesSent {
-                                b.clientStats.NumCallsFinishedWithClientFailedToSend++
-                        } else if s.bytesReceived {
-                                b.clientStats.NumCallsFinishedKnownReceived++
-                        }
-                }
-        }()
-
-        b.clientStats.NumCallsStarted++
-        if len(b.addrs) > 0 {
-                if b.next >= len(b.addrs) {
-                        b.next = 0
-                }
-                next := b.next
-                for {
-                        a := b.addrs[next]
-                        next = (next + 1) % len(b.addrs)
-                        if a.connected {
-                                if !a.dropForRateLimiting && !a.dropForLoadBalancing {
-                                        addr = a.addr
-                                        b.next = next
-                                        b.mu.Unlock()
-                                        return
-                                }
-                                if !opts.BlockingWait {
-                                        b.next = next
-                                        if a.dropForLoadBalancing {
-                                                b.clientStats.NumCallsFinished++
-                                                b.clientStats.NumCallsFinishedWithDropForLoadBalancing++
-                                        } else if a.dropForRateLimiting {
-                                                b.clientStats.NumCallsFinished++
-                                                b.clientStats.NumCallsFinishedWithDropForRateLimiting++
-                                        }
-                                        b.mu.Unlock()
-                                        err = Errorf(codes.Unavailable, "%s drops requests", a.addr.Addr)
-                                        return
-                                }
-                        }
-                        if next == b.next {
-                                // Has iterated all the possible address but none is connected.
-                                break
-                        }
-                }
-        }
-        if !opts.BlockingWait {
-                if len(b.addrs) == 0 {
-                        b.clientStats.NumCallsFinished++
-                        b.clientStats.NumCallsFinishedWithClientFailedToSend++
-                        b.mu.Unlock()
-                        err = Errorf(codes.Unavailable, "there is no address available")
-                        return
-                }
-                // Returns the next addr on b.addrs for a failfast RPC.
-                addr = b.addrs[b.next].addr
-                b.next++
-                b.mu.Unlock()
-                return
-        }
-        // Wait on b.waitCh for non-failfast RPCs.
-        if b.waitCh == nil {
-                ch = make(chan struct{})
-                b.waitCh = ch
-        } else {
-                ch = b.waitCh
-        }
-        b.mu.Unlock()
-        for {
-                select {
-                case <-ctx.Done():
-                        b.mu.Lock()
-                        b.clientStats.NumCallsFinished++
-                        b.clientStats.NumCallsFinishedWithClientFailedToSend++
-                        b.mu.Unlock()
-                        err = ctx.Err()
-                        return
-                case <-ch:
-                        b.mu.Lock()
-                        if b.done {
-                                b.clientStats.NumCallsFinished++
-                                b.clientStats.NumCallsFinishedWithClientFailedToSend++
-                                b.mu.Unlock()
-                                err = ErrClientConnClosing
-                                return
-                        }
-
-                        if len(b.addrs) > 0 {
-                                if b.next >= len(b.addrs) {
-                                        b.next = 0
-                                }
-                                next := b.next
-                                for {
-                                        a := b.addrs[next]
-                                        next = (next + 1) % len(b.addrs)
-                                        if a.connected {
-                                                if !a.dropForRateLimiting && !a.dropForLoadBalancing {
-                                                        addr = a.addr
-                                                        b.next = next
-                                                        b.mu.Unlock()
-                                                        return
-                                                }
-                                                if !opts.BlockingWait {
-                                                        b.next = next
-                                                        if a.dropForLoadBalancing {
-                                                                b.clientStats.NumCallsFinished++
-                                                                b.clientStats.NumCallsFinishedWithDropForLoadBalancing++
-                                                        } else if a.dropForRateLimiting {
-                                                                b.clientStats.NumCallsFinished++
-                                                                b.clientStats.NumCallsFinishedWithDropForRateLimiting++
-                                                        }
-                                                        b.mu.Unlock()
-                                                        err = Errorf(codes.Unavailable, "drop requests for the addreess %s", a.addr.Addr)
-                                                        return
-                                                }
-                                        }
-                                        if next == b.next {
-                                                // Has iterated all the possible address but none is connected.
-                                                break
-                                        }
-                                }
-                        }
-                        // The newly added addr got removed by Down() again.
-                        if b.waitCh == nil {
-                                ch = make(chan struct{})
-                                b.waitCh = ch
-                        } else {
-                                ch = b.waitCh
-                        }
-                        b.mu.Unlock()
-                }
-        }
-}
-
-func (b *balancer) Notify() <-chan []Address {
-        return b.addrCh
-}
-
-func (b *balancer) Close() error {
-        b.mu.Lock()
-        defer b.mu.Unlock()
-        if b.done {
-                return errBalancerClosed
-        }
-        b.done = true
-        if b.expTimer != nil {
-                b.expTimer.Stop()
-        }
-        if b.waitCh != nil {
-                close(b.waitCh)
-        }
-        if b.addrCh != nil {
-                close(b.addrCh)
-        }
-        if b.w != nil {
-                b.w.Close()
-        }
-        return nil
-}
diff --git a/vendor/google.golang.org/grpc/grpclb/grpc_lb_v1/grpclb.pb.go b/vendor/google.golang.org/grpc/grpclb/grpc_lb_v1/grpclb.pb.go
deleted file mode 100644
index f63941b..0000000
--- a/vendor/google.golang.org/grpc/grpclb/grpc_lb_v1/grpclb.pb.go
+++ /dev/null
@@ -1,629 +0,0 @@
-// Code generated by protoc-gen-go.
-// source: grpclb.proto
-// DO NOT EDIT!
-
-/*
-Package grpc_lb_v1 is a generated protocol buffer package.
-
-It is generated from these files:
-        grpclb.proto
-
-It has these top-level messages:
-        Duration
-        Timestamp
-        LoadBalanceRequest
-        InitialLoadBalanceRequest
-        ClientStats
-        LoadBalanceResponse
-        InitialLoadBalanceResponse
-        ServerList
-        Server
-*/
-package grpc_lb_v1
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-type Duration struct {
-        // Signed seconds of the span of time. Must be from -315,576,000,000
-        // to +315,576,000,000 inclusive.
-        Seconds int64 `protobuf:"varint,1,opt,name=seconds" json:"seconds,omitempty"`
-        // Signed fractions of a second at nanosecond resolution of the span
-        // of time. Durations less than one second are represented with a 0
-        // `seconds` field and a positive or negative `nanos` field. For durations
-        // of one second or more, a non-zero value for the `nanos` field must be
-        // of the same sign as the `seconds` field. Must be from -999,999,999
-        // to +999,999,999 inclusive.
-        Nanos int32 `protobuf:"varint,2,opt,name=nanos" json:"nanos,omitempty"`
-}
-
-func (m *Duration) Reset()                    { *m = Duration{} }
-func (m *Duration) String() string            { return proto.CompactTextString(m) }
-func (*Duration) ProtoMessage()               {}
-func (*Duration) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
-
-func (m *Duration) GetSeconds() int64 {
-        if m != nil {
-                return m.Seconds
-        }
-        return 0
-}
-
-func (m *Duration) GetNanos() int32 {
-        if m != nil {
-                return m.Nanos
-        }
-        return 0
-}
-
-type Timestamp struct {
-        // Represents seconds of UTC time since Unix epoch
-        // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
-        // 9999-12-31T23:59:59Z inclusive.
-        Seconds int64 `protobuf:"varint,1,opt,name=seconds" json:"seconds,omitempty"`
-        // Non-negative fractions of a second at nanosecond resolution. Negative
-        // second values with fractions must still have non-negative nanos values
-        // that count forward in time. Must be from 0 to 999,999,999
-        // inclusive.
-        Nanos int32 `protobuf:"varint,2,opt,name=nanos" json:"nanos,omitempty"`
-}
-
-func (m *Timestamp) Reset()                    { *m = Timestamp{} }
-func (m *Timestamp) String() string            { return proto.CompactTextString(m) }
-func (*Timestamp) ProtoMessage()               {}
-func (*Timestamp) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
-
-func (m *Timestamp) GetSeconds() int64 {
-        if m != nil {
-                return m.Seconds
-        }
-        return 0
-}
-
-func (m *Timestamp) GetNanos() int32 {
-        if m != nil {
-                return m.Nanos
-        }
-        return 0
-}
-
-type LoadBalanceRequest struct {
-        // Types that are valid to be assigned to LoadBalanceRequestType:
-        //      *LoadBalanceRequest_InitialRequest
-        //      *LoadBalanceRequest_ClientStats
-        LoadBalanceRequestType isLoadBalanceRequest_LoadBalanceRequestType `protobuf_oneof:"load_balance_request_type"`
-}
-
-func (m *LoadBalanceRequest) Reset()                    { *m = LoadBalanceRequest{} }
-func (m *LoadBalanceRequest) String() string            { return proto.CompactTextString(m) }
-func (*LoadBalanceRequest) ProtoMessage()               {}
-func (*LoadBalanceRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
-
-type isLoadBalanceRequest_LoadBalanceRequestType interface {
-        isLoadBalanceRequest_LoadBalanceRequestType()
-}
-
-type LoadBalanceRequest_InitialRequest struct {
-        InitialRequest *InitialLoadBalanceRequest `protobuf:"bytes,1,opt,name=initial_request,json=initialRequest,oneof"`
-}
-type LoadBalanceRequest_ClientStats struct {
-        ClientStats *ClientStats `protobuf:"bytes,2,opt,name=client_stats,json=clientStats,oneof"`
-}
-
-func (*LoadBalanceRequest_InitialRequest) isLoadBalanceRequest_LoadBalanceRequestType() {}
-func (*LoadBalanceRequest_ClientStats) isLoadBalanceRequest_LoadBalanceRequestType()    {}
-
-func (m *LoadBalanceRequest) GetLoadBalanceRequestType() isLoadBalanceRequest_LoadBalanceRequestType {
-        if m != nil {
-                return m.LoadBalanceRequestType
-        }
-        return nil
-}
-
-func (m *LoadBalanceRequest) GetInitialRequest() *InitialLoadBalanceRequest {
-        if x, ok := m.GetLoadBalanceRequestType().(*LoadBalanceRequest_InitialRequest); ok {
-                return x.InitialRequest
-        }
-        return nil
-}
-
-func (m *LoadBalanceRequest) GetClientStats() *ClientStats {
-        if x, ok := m.GetLoadBalanceRequestType().(*LoadBalanceRequest_ClientStats); ok {
-                return x.ClientStats
-        }
-        return nil
-}
-
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*LoadBalanceRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
-        return _LoadBalanceRequest_OneofMarshaler, _LoadBalanceRequest_OneofUnmarshaler, _LoadBalanceRequest_OneofSizer, []interface{}{
-                (*LoadBalanceRequest_InitialRequest)(nil),
-                (*LoadBalanceRequest_ClientStats)(nil),
-        }
-}
-
-func _LoadBalanceRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
-        m := msg.(*LoadBalanceRequest)
-        // load_balance_request_type
-        switch x := m.LoadBalanceRequestType.(type) {
-        case *LoadBalanceRequest_InitialRequest:
-                b.EncodeVarint(1<<3 | proto.WireBytes)
-                if err := b.EncodeMessage(x.InitialRequest); err != nil {
-                        return err
-                }
-        case *LoadBalanceRequest_ClientStats:
-                b.EncodeVarint(2<<3 | proto.WireBytes)
-                if err := b.EncodeMessage(x.ClientStats); err != nil {
-                        return err
-                }
-        case nil:
-        default:
-                return fmt.Errorf("LoadBalanceRequest.LoadBalanceRequestType has unexpected type %T", x)
-        }
-        return nil
-}
-
-func _LoadBalanceRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
-        m := msg.(*LoadBalanceRequest)
-        switch tag {
-        case 1: // load_balance_request_type.initial_request
-                if wire != proto.WireBytes {
-                        return true, proto.ErrInternalBadWireType
-                }
-                msg := new(InitialLoadBalanceRequest)
-                err := b.DecodeMessage(msg)
-                m.LoadBalanceRequestType = &LoadBalanceRequest_InitialRequest{msg}
-                return true, err
-        case 2: // load_balance_request_type.client_stats
-                if wire != proto.WireBytes {
-                        return true, proto.ErrInternalBadWireType
-                }
-                msg := new(ClientStats)
-                err := b.DecodeMessage(msg)
-                m.LoadBalanceRequestType = &LoadBalanceRequest_ClientStats{msg}
-                return true, err
-        default:
-                return false, nil
-        }
-}
-
-func _LoadBalanceRequest_OneofSizer(msg proto.Message) (n int) {
-        m := msg.(*LoadBalanceRequest)
-        // load_balance_request_type
-        switch x := m.LoadBalanceRequestType.(type) {
-        case *LoadBalanceRequest_InitialRequest:
-                s := proto.Size(x.InitialRequest)
-                n += proto.SizeVarint(1<<3 | proto.WireBytes)
-                n += proto.SizeVarint(uint64(s))
-                n += s
-        case *LoadBalanceRequest_ClientStats:
-                s := proto.Size(x.ClientStats)
-                n += proto.SizeVarint(2<<3 | proto.WireBytes)
-                n += proto.SizeVarint(uint64(s))
-                n += s
-        case nil:
-        default:
-                panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
-        }
-        return n
-}
-
-type InitialLoadBalanceRequest struct {
-        // Name of load balanced service (IE, balancer.service.com)
-        // length should be less than 256 bytes.
-        Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-}
-
-func (m *InitialLoadBalanceRequest) Reset()                    { *m = InitialLoadBalanceRequest{} }
-func (m *InitialLoadBalanceRequest) String() string            { return proto.CompactTextString(m) }
-func (*InitialLoadBalanceRequest) ProtoMessage()               {}
-func (*InitialLoadBalanceRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
-
-func (m *InitialLoadBalanceRequest) GetName() string {
-        if m != nil {
-                return m.Name
-        }
-        return ""
-}
-
-// Contains client level statistics that are useful to load balancing. Each
-// count except the timestamp should be reset to zero after reporting the stats.
-type ClientStats struct {
-        // The timestamp of generating the report.
-        Timestamp *Timestamp `protobuf:"bytes,1,opt,name=timestamp" json:"timestamp,omitempty"`
-        // The total number of RPCs that started.
-        NumCallsStarted int64 `protobuf:"varint,2,opt,name=num_calls_started,json=numCallsStarted" json:"num_calls_started,omitempty"`
-        // The total number of RPCs that finished.
-        NumCallsFinished int64 `protobuf:"varint,3,opt,name=num_calls_finished,json=numCallsFinished" json:"num_calls_finished,omitempty"`
-        // The total number of RPCs that were dropped by the client because of rate
-        // limiting.
-        NumCallsFinishedWithDropForRateLimiting int64 `protobuf:"varint,4,opt,name=num_calls_finished_with_drop_for_rate_limiting,json=numCallsFinishedWithDropForRateLimiting" json:"num_calls_finished_with_drop_for_rate_limiting,omitempty"`
-        // The total number of RPCs that were dropped by the client because of load
-        // balancing.
-        NumCallsFinishedWithDropForLoadBalancing int64 `protobuf:"varint,5,opt,name=num_calls_finished_with_drop_for_load_balancing,json=numCallsFinishedWithDropForLoadBalancing" json:"num_calls_finished_with_drop_for_load_balancing,omitempty"`
-        // The total number of RPCs that failed to reach a server except dropped RPCs.
-        NumCallsFinishedWithClientFailedToSend int64 `protobuf:"varint,6,opt,name=num_calls_finished_with_client_failed_to_send,json=numCallsFinishedWithClientFailedToSend" json:"num_calls_finished_with_client_failed_to_send,omitempty"`
-        // The total number of RPCs that finished and are known to have been received
-        // by a server.
-        NumCallsFinishedKnownReceived int64 `protobuf:"varint,7,opt,name=num_calls_finished_known_received,json=numCallsFinishedKnownReceived" json:"num_calls_finished_known_received,omitempty"`
-}
-
-func (m *ClientStats) Reset()                    { *m = ClientStats{} }
-func (m *ClientStats) String() string            { return proto.CompactTextString(m) }
-func (*ClientStats) ProtoMessage()               {}
-func (*ClientStats) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
-
-func (m *ClientStats) GetTimestamp() *Timestamp {
-        if m != nil {
-                return m.Timestamp
-        }
-        return nil
-}
-
-func (m *ClientStats) GetNumCallsStarted() int64 {
-        if m != nil {
-                return m.NumCallsStarted
-        }
-        return 0
-}
-
-func (m *ClientStats) GetNumCallsFinished() int64 {
-        if m != nil {
-                return m.NumCallsFinished
-        }
-        return 0
-}
-
-func (m *ClientStats) GetNumCallsFinishedWithDropForRateLimiting() int64 {
-        if m != nil {
-                return m.NumCallsFinishedWithDropForRateLimiting
-        }
-        return 0
-}
-
-func (m *ClientStats) GetNumCallsFinishedWithDropForLoadBalancing() int64 {
-        if m != nil {
-                return m.NumCallsFinishedWithDropForLoadBalancing
-        }
-        return 0
-}
-
-func (m *ClientStats) GetNumCallsFinishedWithClientFailedToSend() int64 {
-        if m != nil {
-                return m.NumCallsFinishedWithClientFailedToSend
-        }
-        return 0
-}
-
-func (m *ClientStats) GetNumCallsFinishedKnownReceived() int64 {
-        if m != nil {
-                return m.NumCallsFinishedKnownReceived
-        }
-        return 0
-}
-
-type LoadBalanceResponse struct {
-        // Types that are valid to be assigned to LoadBalanceResponseType:
-        //      *LoadBalanceResponse_InitialResponse
-        //      *LoadBalanceResponse_ServerList
-        LoadBalanceResponseType isLoadBalanceResponse_LoadBalanceResponseType `protobuf_oneof:"load_balance_response_type"`
-}
-
-func (m *LoadBalanceResponse) Reset()                    { *m = LoadBalanceResponse{} }
-func (m *LoadBalanceResponse) String() string            { return proto.CompactTextString(m) }
-func (*LoadBalanceResponse) ProtoMessage()               {}
-func (*LoadBalanceResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
-
-type isLoadBalanceResponse_LoadBalanceResponseType interface {
-        isLoadBalanceResponse_LoadBalanceResponseType()
-}
-
-type LoadBalanceResponse_InitialResponse struct {
-        InitialResponse *InitialLoadBalanceResponse `protobuf:"bytes,1,opt,name=initial_response,json=initialResponse,oneof"`
-}
-type LoadBalanceResponse_ServerList struct {
-        ServerList *ServerList `protobuf:"bytes,2,opt,name=server_list,json=serverList,oneof"`
-}
-
-func (*LoadBalanceResponse_InitialResponse) isLoadBalanceResponse_LoadBalanceResponseType() {}
-func (*LoadBalanceResponse_ServerList) isLoadBalanceResponse_LoadBalanceResponseType()      {}
-
-func (m *LoadBalanceResponse) GetLoadBalanceResponseType() isLoadBalanceResponse_LoadBalanceResponseType {
-        if m != nil {
-                return m.LoadBalanceResponseType
-        }
-        return nil
-}
-
-func (m *LoadBalanceResponse) GetInitialResponse() *InitialLoadBalanceResponse {
-        if x, ok := m.GetLoadBalanceResponseType().(*LoadBalanceResponse_InitialResponse); ok {
-                return x.InitialResponse
-        }
-        return nil
-}
-
-func (m *LoadBalanceResponse) GetServerList() *ServerList {
-        if x, ok := m.GetLoadBalanceResponseType().(*LoadBalanceResponse_ServerList); ok {
-                return x.ServerList
-        }
-        return nil
-}
-
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*LoadBalanceResponse) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
-        return _LoadBalanceResponse_OneofMarshaler, _LoadBalanceResponse_OneofUnmarshaler, _LoadBalanceResponse_OneofSizer, []interface{}{
-                (*LoadBalanceResponse_InitialResponse)(nil),
-                (*LoadBalanceResponse_ServerList)(nil),
-        }
-}
-
-func _LoadBalanceResponse_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
-        m := msg.(*LoadBalanceResponse)
-        // load_balance_response_type
-        switch x := m.LoadBalanceResponseType.(type) {
-        case *LoadBalanceResponse_InitialResponse:
-                b.EncodeVarint(1<<3 | proto.WireBytes)
-                if err := b.EncodeMessage(x.InitialResponse); err != nil {
-                        return err
-                }
-        case *LoadBalanceResponse_ServerList:
-                b.EncodeVarint(2<<3 | proto.WireBytes)
-                if err := b.EncodeMessage(x.ServerList); err != nil {
-                        return err
-                }
-        case nil:
-        default:
-                return fmt.Errorf("LoadBalanceResponse.LoadBalanceResponseType has unexpected type %T", x)
-        }
-        return nil
-}
-
-func _LoadBalanceResponse_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
-        m := msg.(*LoadBalanceResponse)
-        switch tag {
-        case 1: // load_balance_response_type.initial_response
-                if wire != proto.WireBytes {
-                        return true, proto.ErrInternalBadWireType
-                }
-                msg := new(InitialLoadBalanceResponse)
-                err := b.DecodeMessage(msg)
-                m.LoadBalanceResponseType = &LoadBalanceResponse_InitialResponse{msg}
-                return true, err
-        case 2: // load_balance_response_type.server_list
-                if wire != proto.WireBytes {
-                        return true, proto.ErrInternalBadWireType
-                }
-                msg := new(ServerList)
-                err := b.DecodeMessage(msg)
-                m.LoadBalanceResponseType = &LoadBalanceResponse_ServerList{msg}
-                return true, err
-        default:
-                return false, nil
-        }
-}
-
-func _LoadBalanceResponse_OneofSizer(msg proto.Message) (n int) {
-        m := msg.(*LoadBalanceResponse)
-        // load_balance_response_type
-        switch x := m.LoadBalanceResponseType.(type) {
-        case *LoadBalanceResponse_InitialResponse:
-                s := proto.Size(x.InitialResponse)
-                n += proto.SizeVarint(1<<3 | proto.WireBytes)
-                n += proto.SizeVarint(uint64(s))
-                n += s
-        case *LoadBalanceResponse_ServerList:
-                s := proto.Size(x.ServerList)
-                n += proto.SizeVarint(2<<3 | proto.WireBytes)
-                n += proto.SizeVarint(uint64(s))
-                n += s
-        case nil:
-        default:
-                panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
-        }
-        return n
-}
-
-type InitialLoadBalanceResponse struct {
-        // This is an application layer redirect that indicates the client should use
-        // the specified server for load balancing. When this field is non-empty in
-        // the response, the client should open a separate connection to the
-        // load_balancer_delegate and call the BalanceLoad method. Its length should
-        // be less than 64 bytes.
-        LoadBalancerDelegate string `protobuf:"bytes,1,opt,name=load_balancer_delegate,json=loadBalancerDelegate" json:"load_balancer_delegate,omitempty"`
-        // This interval defines how often the client should send the client stats
-        // to the load balancer. Stats should only be reported when the duration is
-        // positive.
-        ClientStatsReportInterval *Duration `protobuf:"bytes,2,opt,name=client_stats_report_interval,json=clientStatsReportInterval" json:"client_stats_report_interval,omitempty"`
-}
-
-func (m *InitialLoadBalanceResponse) Reset()                    { *m = InitialLoadBalanceResponse{} }
-func (m *InitialLoadBalanceResponse) String() string            { return proto.CompactTextString(m) }
-func (*InitialLoadBalanceResponse) ProtoMessage()               {}
-func (*InitialLoadBalanceResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
-
-func (m *InitialLoadBalanceResponse) GetLoadBalancerDelegate() string {
-        if m != nil {
-                return m.LoadBalancerDelegate
-        }
-        return ""
-}
-
-func (m *InitialLoadBalanceResponse) GetClientStatsReportInterval() *Duration {
-        if m != nil {
-                return m.ClientStatsReportInterval
-        }
-        return nil
-}
-
-type ServerList struct {
-        // Contains a list of servers selected by the load balancer. The list will
-        // be updated when server resolutions change or as needed to balance load
-        // across more servers. The client should consume the server list in order
-        // unless instructed otherwise via the client_config.
-        Servers []*Server `protobuf:"bytes,1,rep,name=servers" json:"servers,omitempty"`
-        // Indicates the amount of time that the client should consider this server
-        // list as valid. It may be considered stale after waiting this interval of
-        // time after receiving the list. If the interval is not positive, the
-        // client can assume the list is valid until the next list is received.
-        ExpirationInterval *Duration `protobuf:"bytes,3,opt,name=expiration_interval,json=expirationInterval" json:"expiration_interval,omitempty"`
-}
-
-func (m *ServerList) Reset()                    { *m = ServerList{} }
-func (m *ServerList) String() string            { return proto.CompactTextString(m) }
-func (*ServerList) ProtoMessage()               {}
-func (*ServerList) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
-
-func (m *ServerList) GetServers() []*Server {
-        if m != nil {
-                return m.Servers
-        }
-        return nil
-}
-
-func (m *ServerList) GetExpirationInterval() *Duration {
-        if m != nil {
-                return m.ExpirationInterval
-        }
-        return nil
-}
-
-// Contains server information. When none of the [drop_for_*] fields are true,
-// use the other fields. When drop_for_rate_limiting is true, ignore all other
-// fields. Use drop_for_load_balancing only when it is true and
-// drop_for_rate_limiting is false.
-type Server struct {
-        // A resolved address for the server, serialized in network-byte-order. It may
-        // either be an IPv4 or IPv6 address.
-        IpAddress []byte `protobuf:"bytes,1,opt,name=ip_address,json=ipAddress,proto3" json:"ip_address,omitempty"`
-        // A resolved port number for the server.
-        Port int32 `protobuf:"varint,2,opt,name=port" json:"port,omitempty"`
-        // An opaque but printable token given to the frontend for each pick. All
-        // frontend requests for that pick must include the token in its initial
-        // metadata. The token is used by the backend to verify the request and to
-        // allow the backend to report load to the gRPC LB system.
-        //
-        // Its length is variable but less than 50 bytes.
-        LoadBalanceToken string `protobuf:"bytes,3,opt,name=load_balance_token,json=loadBalanceToken" json:"load_balance_token,omitempty"`
-        // Indicates whether this particular request should be dropped by the client
-        // for rate limiting.
-        DropForRateLimiting bool `protobuf:"varint,4,opt,name=drop_for_rate_limiting,json=dropForRateLimiting" json:"drop_for_rate_limiting,omitempty"`
-        // Indicates whether this particular request should be dropped by the client
-        // for load balancing.
-        DropForLoadBalancing bool `protobuf:"varint,5,opt,name=drop_for_load_balancing,json=dropForLoadBalancing" json:"drop_for_load_balancing,omitempty"`
-}
-
-func (m *Server) Reset()                    { *m = Server{} }
-func (m *Server) String() string            { return proto.CompactTextString(m) }
-func (*Server) ProtoMessage()               {}
-func (*Server) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
-
-func (m *Server) GetIpAddress() []byte {
-        if m != nil {
-                return m.IpAddress
-        }
-        return nil
-}
-
-func (m *Server) GetPort() int32 {
-        if m != nil {
-                return m.Port
-        }
-        return 0
-}
-
-func (m *Server) GetLoadBalanceToken() string {
-        if m != nil {
-                return m.LoadBalanceToken
-        }
-        return ""
-}
-
-func (m *Server) GetDropForRateLimiting() bool {
-        if m != nil {
-                return m.DropForRateLimiting
-        }
-        return false
-}
-
-func (m *Server) GetDropForLoadBalancing() bool {
-        if m != nil {
-                return m.DropForLoadBalancing
-        }
-        return false
-}
-
-func init() {
-        proto.RegisterType((*Duration)(nil), "grpc.lb.v1.Duration")
-        proto.RegisterType((*Timestamp)(nil), "grpc.lb.v1.Timestamp")
-        proto.RegisterType((*LoadBalanceRequest)(nil), "grpc.lb.v1.LoadBalanceRequest")
-        proto.RegisterType((*InitialLoadBalanceRequest)(nil), "grpc.lb.v1.InitialLoadBalanceRequest")
-        proto.RegisterType((*ClientStats)(nil), "grpc.lb.v1.ClientStats")
-        proto.RegisterType((*LoadBalanceResponse)(nil), "grpc.lb.v1.LoadBalanceResponse")
-        proto.RegisterType((*InitialLoadBalanceResponse)(nil), "grpc.lb.v1.InitialLoadBalanceResponse")
-        proto.RegisterType((*ServerList)(nil), "grpc.lb.v1.ServerList")
-        proto.RegisterType((*Server)(nil), "grpc.lb.v1.Server")
-}
-
-func init() { proto.RegisterFile("grpclb.proto", fileDescriptor0) }
-
-var fileDescriptor0 = []byte{
-        // 733 bytes of a gzipped FileDescriptorProto
-        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0xdd, 0x4e, 0x1b, 0x39,
-        0x14, 0x66, 0x36, 0xfc, 0xe5, 0x24, 0x5a, 0x58, 0x93, 0x85, 0xc0, 0xc2, 0x2e, 0x1b, 0xa9, 0x34,
-        0xaa, 0x68, 0x68, 0x43, 0x7b, 0xd1, 0x9f, 0x9b, 0x02, 0x45, 0x41, 0xe5, 0xa2, 0x72, 0xa8, 0x7a,
-        0x55, 0x59, 0x4e, 0xc6, 0x80, 0xc5, 0xc4, 0x9e, 0xda, 0x4e, 0x68, 0x2f, 0x7b, 0xd9, 0x47, 0xe9,
-        0x63, 0x54, 0x7d, 0x86, 0xbe, 0x4f, 0x65, 0x7b, 0x26, 0x33, 0x90, 0x1f, 0xd4, 0xbb, 0xf1, 0xf1,
-        0x77, 0xbe, 0xf3, 0xf9, 0xd8, 0xdf, 0x19, 0x28, 0x5f, 0xa8, 0xb8, 0x1b, 0x75, 0x1a, 0xb1, 0x92,
-        0x46, 0x22, 0xb0, 0xab, 0x46, 0xd4, 0x69, 0x0c, 0x1e, 0xd7, 0x9e, 0xc3, 0xe2, 0x51, 0x5f, 0x51,
-        0xc3, 0xa5, 0x40, 0x55, 0x58, 0xd0, 0xac, 0x2b, 0x45, 0xa8, 0xab, 0xc1, 0x76, 0x50, 0x2f, 0xe0,
-        0x74, 0x89, 0x2a, 0x30, 0x27, 0xa8, 0x90, 0xba, 0xfa, 0xc7, 0x76, 0x50, 0x9f, 0xc3, 0x7e, 0x51,
-        0x7b, 0x01, 0xc5, 0x33, 0xde, 0x63, 0xda, 0xd0, 0x5e, 0xfc, 0xdb, 0xc9, 0xdf, 0x03, 0x40, 0xa7,
-        0x92, 0x86, 0x07, 0x34, 0xa2, 0xa2, 0xcb, 0x30, 0xfb, 0xd8, 0x67, 0xda, 0xa0, 0xb7, 0xb0, 0xc4,
-        0x05, 0x37, 0x9c, 0x46, 0x44, 0xf9, 0x90, 0xa3, 0x2b, 0x35, 0xef, 0x35, 0x32, 0xd5, 0x8d, 0x13,
-        0x0f, 0x19, 0xcd, 0x6f, 0xcd, 0xe0, 0x3f, 0x93, 0xfc, 0x94, 0xf1, 0x25, 0x94, 0xbb, 0x11, 0x67,
-        0xc2, 0x10, 0x6d, 0xa8, 0xf1, 0x2a, 0x4a, 0xcd, 0xb5, 0x3c, 0xdd, 0xa1, 0xdb, 0x6f, 0xdb, 0xed,
-        0xd6, 0x0c, 0x2e, 0x75, 0xb3, 0xe5, 0xc1, 0x3f, 0xb0, 0x1e, 0x49, 0x1a, 0x92, 0x8e, 0x2f, 0x93,
-        0x8a, 0x22, 0xe6, 0x73, 0xcc, 0x6a, 0x7b, 0xb0, 0x3e, 0x51, 0x09, 0x42, 0x30, 0x2b, 0x68, 0x8f,
-        0x39, 0xf9, 0x45, 0xec, 0xbe, 0x6b, 0x5f, 0x67, 0xa1, 0x94, 0x2b, 0x86, 0xf6, 0xa1, 0x68, 0xd2,
-        0x0e, 0x26, 0xe7, 0xfc, 0x3b, 0x2f, 0x6c, 0xd8, 0x5e, 0x9c, 0xe1, 0xd0, 0x03, 0xf8, 0x4b, 0xf4,
-        0x7b, 0xa4, 0x4b, 0xa3, 0x48, 0xdb, 0x33, 0x29, 0xc3, 0x42, 0x77, 0xaa, 0x02, 0x5e, 0x12, 0xfd,
-        0xde, 0xa1, 0x8d, 0xb7, 0x7d, 0x18, 0xed, 0x02, 0xca, 0xb0, 0xe7, 0x5c, 0x70, 0x7d, 0xc9, 0xc2,
-        0x6a, 0xc1, 0x81, 0x97, 0x53, 0xf0, 0x71, 0x12, 0x47, 0x04, 0x1a, 0xa3, 0x68, 0x72, 0xcd, 0xcd,
-        0x25, 0x09, 0x95, 0x8c, 0xc9, 0xb9, 0x54, 0x44, 0x51, 0xc3, 0x48, 0xc4, 0x7b, 0xdc, 0x70, 0x71,
-        0x51, 0x9d, 0x75, 0x4c, 0xf7, 0x6f, 0x33, 0xbd, 0xe7, 0xe6, 0xf2, 0x48, 0xc9, 0xf8, 0x58, 0x2a,
-        0x4c, 0x0d, 0x3b, 0x4d, 0xe0, 0x88, 0xc2, 0xde, 0x9d, 0x05, 0x72, 0xed, 0xb6, 0x15, 0xe6, 0x5c,
-        0x85, 0xfa, 0x94, 0x0a, 0x59, 0xef, 0x6d, 0x89, 0x0f, 0xf0, 0x70, 0x52, 0x89, 0xe4, 0x19, 0x9c,
-        0x53, 0x1e, 0xb1, 0x90, 0x18, 0x49, 0x34, 0x13, 0x61, 0x75, 0xde, 0x15, 0xd8, 0x19, 0x57, 0xc0,
-        0x5f, 0xd5, 0xb1, 0xc3, 0x9f, 0xc9, 0x36, 0x13, 0x21, 0x6a, 0xc1, 0xff, 0x63, 0xe8, 0xaf, 0x84,
-        0xbc, 0x16, 0x44, 0xb1, 0x2e, 0xe3, 0x03, 0x16, 0x56, 0x17, 0x1c, 0xe5, 0xd6, 0x6d, 0xca, 0x37,
-        0x16, 0x85, 0x13, 0x50, 0xed, 0x47, 0x00, 0x2b, 0x37, 0x9e, 0x8d, 0x8e, 0xa5, 0xd0, 0x0c, 0xb5,
-        0x61, 0x39, 0x73, 0x80, 0x8f, 0x25, 0x4f, 0x63, 0xe7, 0x2e, 0x0b, 0x78, 0x74, 0x6b, 0x06, 0x2f,
-        0x0d, 0x3d, 0x90, 0x90, 0x3e, 0x83, 0x92, 0x66, 0x6a, 0xc0, 0x14, 0x89, 0xb8, 0x36, 0x89, 0x07,
-        0x56, 0xf3, 0x7c, 0x6d, 0xb7, 0x7d, 0xca, 0x9d, 0x87, 0x40, 0x0f, 0x57, 0x07, 0x9b, 0xb0, 0x71,
-        0xcb, 0x01, 0x9e, 0xd3, 0x5b, 0xe0, 0x5b, 0x00, 0x1b, 0x93, 0xa5, 0xa0, 0x27, 0xb0, 0x9a, 0x4f,
-        0x56, 0x24, 0x64, 0x11, 0xbb, 0xa0, 0x26, 0xb5, 0x45, 0x25, 0xca, 0x92, 0xd4, 0x51, 0xb2, 0x87,
-        0xde, 0xc1, 0x66, 0xde, 0xb2, 0x44, 0xb1, 0x58, 0x2a, 0x43, 0xb8, 0x30, 0x4c, 0x0d, 0x68, 0x94,
-        0xc8, 0xaf, 0xe4, 0xe5, 0xa7, 0x43, 0x0c, 0xaf, 0xe7, 0xdc, 0x8b, 0x5d, 0xde, 0x49, 0x92, 0x56,
-        0xfb, 0x12, 0x00, 0x64, 0xc7, 0x44, 0xbb, 0x76, 0x62, 0xd9, 0x95, 0x9d, 0x58, 0x85, 0x7a, 0xa9,
-        0x89, 0x46, 0xfb, 0x81, 0x53, 0x08, 0x7a, 0x0d, 0x2b, 0xec, 0x53, 0xcc, 0x7d, 0x95, 0x4c, 0x4a,
-        0x61, 0x8a, 0x14, 0x94, 0x25, 0x0c, 0x35, 0xfc, 0x0c, 0x60, 0xde, 0x53, 0xa3, 0x2d, 0x00, 0x1e,
-        0x13, 0x1a, 0x86, 0x8a, 0x69, 0x3f, 0x34, 0xcb, 0xb8, 0xc8, 0xe3, 0x57, 0x3e, 0x60, 0xe7, 0x87,
-        0x55, 0x9f, 0x4c, 0x4d, 0xf7, 0x6d, 0xed, 0x7c, 0xe3, 0x2e, 0x8c, 0xbc, 0x62, 0xc2, 0x69, 0x28,
-        0xe2, 0xe5, 0x5c, 0x2b, 0xcf, 0x6c, 0x1c, 0xed, 0xc3, 0xea, 0x14, 0xdb, 0x2e, 0xe2, 0x95, 0x70,
-        0x8c, 0x45, 0x9f, 0xc2, 0xda, 0x34, 0x2b, 0x2e, 0xe2, 0x4a, 0x38, 0xc6, 0x76, 0xcd, 0x0e, 0x94,
-        0x73, 0xf7, 0xaf, 0x10, 0x86, 0x52, 0xf2, 0x6d, 0xc3, 0xe8, 0xdf, 0x7c, 0x83, 0x46, 0x87, 0xe5,
-        0xc6, 0x7f, 0x13, 0xf7, 0xfd, 0x43, 0xaa, 0x07, 0x8f, 0x82, 0xce, 0xbc, 0xfb, 0x7d, 0xed, 0xff,
-        0x0a, 0x00, 0x00, 0xff, 0xff, 0x64, 0xbf, 0xda, 0x5e, 0xce, 0x06, 0x00, 0x00,
-}
diff --git a/vendor/google.golang.org/grpc/grpclb/grpc_lb_v1/grpclb.proto b/vendor/google.golang.org/grpc/grpclb/grpc_lb_v1/grpclb.proto
deleted file mode 100644
index b13b343..0000000
--- a/vendor/google.golang.org/grpc/grpclb/grpc_lb_v1/grpclb.proto
+++ /dev/null
@@ -1,164 +0,0 @@
-// Copyright 2016 gRPC authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-syntax = "proto3";
-
-package grpc.lb.v1;
-
-message Duration {
-  // Signed seconds of the span of time. Must be from -315,576,000,000
-  // to +315,576,000,000 inclusive.
-  int64 seconds = 1;
-
-  // Signed fractions of a second at nanosecond resolution of the span
-  // of time. Durations less than one second are represented with a 0
-  // `seconds` field and a positive or negative `nanos` field. For durations
-  // of one second or more, a non-zero value for the `nanos` field must be
-  // of the same sign as the `seconds` field. Must be from -999,999,999
-  // to +999,999,999 inclusive.
-  int32 nanos = 2;
-}
-
-message Timestamp {
-
-  // Represents seconds of UTC time since Unix epoch
-  // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
-  // 9999-12-31T23:59:59Z inclusive.
-  int64 seconds = 1;
-
-  // Non-negative fractions of a second at nanosecond resolution. Negative
-  // second values with fractions must still have non-negative nanos values
-  // that count forward in time. Must be from 0 to 999,999,999
-  // inclusive.
-  int32 nanos = 2;
-}
-
-service LoadBalancer {
-  // Bidirectional rpc to get a list of servers.
-  rpc BalanceLoad(stream LoadBalanceRequest)
-      returns (stream LoadBalanceResponse);
-}
-
-message LoadBalanceRequest {
-  oneof load_balance_request_type {
-    // This message should be sent on the first request to the load balancer.
-    InitialLoadBalanceRequest initial_request = 1;
-
-    // The client stats should be periodically reported to the load balancer
-    // based on the duration defined in the InitialLoadBalanceResponse.
-    ClientStats client_stats = 2;
-  }
-}
-
-message InitialLoadBalanceRequest {
-  // Name of load balanced service (IE, balancer.service.com)
-  // length should be less than 256 bytes.
-  string name = 1;
-}
-
-// Contains client level statistics that are useful to load balancing. Each
-// count except the timestamp should be reset to zero after reporting the stats.
-message ClientStats {
-  // The timestamp of generating the report.
-  Timestamp timestamp = 1;
-
-  // The total number of RPCs that started.
-  int64 num_calls_started = 2;
-
-  // The total number of RPCs that finished.
-  int64 num_calls_finished = 3;
-
-  // The total number of RPCs that were dropped by the client because of rate
-  // limiting.
-  int64 num_calls_finished_with_drop_for_rate_limiting = 4;
-
-  // The total number of RPCs that were dropped by the client because of load
-  // balancing.
-  int64 num_calls_finished_with_drop_for_load_balancing = 5;
-
-  // The total number of RPCs that failed to reach a server except dropped RPCs.
-  int64 num_calls_finished_with_client_failed_to_send = 6;
-
-  // The total number of RPCs that finished and are known to have been received
-  // by a server.
-  int64 num_calls_finished_known_received = 7;
-}
-
-message LoadBalanceResponse {
-  oneof load_balance_response_type {
-    // This message should be sent on the first response to the client.
-    InitialLoadBalanceResponse initial_response = 1;
-
-    // Contains the list of servers selected by the load balancer. The client
-    // should send requests to these servers in the specified order.
-    ServerList server_list = 2;
-  }
-}
-
-message InitialLoadBalanceResponse {
-  // This is an application layer redirect that indicates the client should use
-  // the specified server for load balancing. When this field is non-empty in
-  // the response, the client should open a separate connection to the
-  // load_balancer_delegate and call the BalanceLoad method. Its length should
-  // be less than 64 bytes.
-  string load_balancer_delegate = 1;
-
-  // This interval defines how often the client should send the client stats
-  // to the load balancer. Stats should only be reported when the duration is
-  // positive.
-  Duration client_stats_report_interval = 2;
-}
-
-message ServerList {
-  // Contains a list of servers selected by the load balancer. The list will
-  // be updated when server resolutions change or as needed to balance load
-  // across more servers. The client should consume the server list in order
-  // unless instructed otherwise via the client_config.
-  repeated Server servers = 1;
-
-  // Indicates the amount of time that the client should consider this server
-  // list as valid. It may be considered stale after waiting this interval of
-  // time after receiving the list. If the interval is not positive, the
-  // client can assume the list is valid until the next list is received.
-  Duration expiration_interval = 3;
-}
-
-// Contains server information. When none of the [drop_for_*] fields are true,
-// use the other fields. When drop_for_rate_limiting is true, ignore all other
-// fields. Use drop_for_load_balancing only when it is true and
-// drop_for_rate_limiting is false.
-message Server {
-  // A resolved address for the server, serialized in network-byte-order. It may
-  // either be an IPv4 or IPv6 address.
-  bytes ip_address = 1;
-
-  // A resolved port number for the server.
-  int32 port = 2;
-
-  // An opaque but printable token given to the frontend for each pick. All
-  // frontend requests for that pick must include the token in its initial
-  // metadata. The token is used by the backend to verify the request and to
-  // allow the backend to report load to the gRPC LB system.
-  //
-  // Its length is variable but less than 50 bytes.
-  string load_balance_token = 3;
-
-  // Indicates whether this particular request should be dropped by the client
-  // for rate limiting.
-  bool drop_for_rate_limiting = 4;
-
-  // Indicates whether this particular request should be dropped by the client
-  // for load balancing.
-  bool drop_for_load_balancing = 5;
-}
diff --git a/vendor/google.golang.org/grpc/grpclog/grpclog.go b/vendor/google.golang.org/grpc/grpclog/grpclog.go
index 16a7d88..1fabb11 100644
--- a/vendor/google.golang.org/grpc/grpclog/grpclog.go
+++ b/vendor/google.golang.org/grpc/grpclog/grpclog.go
@@ -105,18 +105,21 @@ func Fatalln(args ...interface{}) {
 }
 
 // Print prints to the logger. Arguments are handled in the manner of fmt.Print.
+//
 // Deprecated: use Info.
 func Print(args ...interface{}) {
         logger.Info(args...)
 }
 
 // Printf prints to the logger. Arguments are handled in the manner of fmt.Printf.
+//
 // Deprecated: use Infof.
 func Printf(format string, args ...interface{}) {
         logger.Infof(format, args...)
 }
 
 // Println prints to the logger. Arguments are handled in the manner of fmt.Println.
+//
 // Deprecated: use Infoln.
 func Println(args ...interface{}) {
         logger.Infoln(args...)
diff --git a/vendor/google.golang.org/grpc/grpclog/logger.go b/vendor/google.golang.org/grpc/grpclog/logger.go
index d03b239..097494f 100644
--- a/vendor/google.golang.org/grpc/grpclog/logger.go
+++ b/vendor/google.golang.org/grpc/grpclog/logger.go
@@ -19,6 +19,7 @@
 package grpclog
 
 // Logger mimics golang's standard Logger as an interface.
+//
 // Deprecated: use LoggerV2.
 type Logger interface {
         Fatal(args ...interface{})
@@ -31,6 +32,7 @@ type Logger interface {
 
 // SetLogger sets the logger that is used in grpc. Call only from
 // init() functions.
+//
 // Deprecated: use SetLoggerV2.
 func SetLogger(l Logger) {
         logger = &loggerWrapper{Logger: l}
diff --git a/vendor/google.golang.org/grpc/health/client.go b/vendor/google.golang.org/grpc/health/client.go
new file mode 100644
index 0000000..e15f04c
--- /dev/null
+++ b/vendor/google.golang.org/grpc/health/client.go
@@ -0,0 +1,107 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package health
+
+import (
+        "context"
+        "fmt"
+        "io"
+        "time"
+
+        "google.golang.org/grpc"
+        "google.golang.org/grpc/codes"
+        healthpb "google.golang.org/grpc/health/grpc_health_v1"
+        "google.golang.org/grpc/internal"
+        "google.golang.org/grpc/internal/backoff"
+        "google.golang.org/grpc/status"
+)
+
+const maxDelay = 120 * time.Second
+
+var backoffStrategy = backoff.Exponential{MaxDelay: maxDelay}
+var backoffFunc = func(ctx context.Context, retries int) bool {
+        d := backoffStrategy.Backoff(retries)
+        timer := time.NewTimer(d)
+        select {
+        case <-timer.C:
+                return true
+        case <-ctx.Done():
+                timer.Stop()
+                return false
+        }
+}
+
+func init() {
+        internal.HealthCheckFunc = clientHealthCheck
+}
+
+func clientHealthCheck(ctx context.Context, newStream func() (interface{}, error), reportHealth func(bool), service string) error {
+        tryCnt := 0
+
+retryConnection:
+        for {
+                // Backs off if the connection has failed in some way without receiving a message in the previous retry.
+                if tryCnt > 0 && !backoffFunc(ctx, tryCnt-1) {
+                        return nil
+                }
+                tryCnt++
+
+                if ctx.Err() != nil {
+                        return nil
+                }
+                rawS, err := newStream()
+                if err != nil {
+                        continue retryConnection
+                }
+
+                s, ok := rawS.(grpc.ClientStream)
+                // Ideally, this should never happen. But if it happens, the server is marked as healthy for LBing purposes.
+                if !ok {
+                        reportHealth(true)
+                        return fmt.Errorf("newStream returned %v (type %T); want grpc.ClientStream", rawS, rawS)
+                }
+
+                if err = s.SendMsg(&healthpb.HealthCheckRequest{Service: service}); err != nil && err != io.EOF {
+                        // Stream should have been closed, so we can safely continue to create a new stream.
+                        continue retryConnection
+                }
+                s.CloseSend()
+
+                resp := new(healthpb.HealthCheckResponse)
+                for {
+                        err = s.RecvMsg(resp)
+
+                        // Reports healthy for the LBing purposes if health check is not implemented in the server.
+                        if status.Code(err) == codes.Unimplemented {
+                                reportHealth(true)
+                                return err
+                        }
+
+                        // Reports unhealthy if server's Watch method gives an error other than UNIMPLEMENTED.
+                        if err != nil {
+                                reportHealth(false)
+                                continue retryConnection
+                        }
+
+                        // As a message has been received, removes the need for backoff for the next retry by reseting the try count.
+                        tryCnt = 0
+                        reportHealth(resp.Status == healthpb.HealthCheckResponse_SERVING)
+                }
+        }
+}
diff --git a/vendor/google.golang.org/grpc/health/grpc_health_v1/health.pb.go b/vendor/google.golang.org/grpc/health/grpc_health_v1/health.pb.go
index 89c4d45..c2f2c77 100644
--- a/vendor/google.golang.org/grpc/health/grpc_health_v1/health.pb.go
+++ b/vendor/google.golang.org/grpc/health/grpc_health_v1/health.pb.go
@@ -1,18 +1,7 @@
-// Code generated by protoc-gen-go.
-// source: health.proto
-// DO NOT EDIT!
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: grpc/health/v1/health.proto
 
-/*
-Package grpc_health_v1 is a generated protocol buffer package.
-
-It is generated from these files:
-        health.proto
-
-It has these top-level messages:
-        HealthCheckRequest
-        HealthCheckResponse
-*/
-package grpc_health_v1
+package grpc_health_v1 // import "google.golang.org/grpc/health/grpc_health_v1"
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
@@ -37,46 +26,107 @@ const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 type HealthCheckResponse_ServingStatus int32
 
 const (
-        HealthCheckResponse_UNKNOWN     HealthCheckResponse_ServingStatus = 0
-        HealthCheckResponse_SERVING     HealthCheckResponse_ServingStatus = 1
-        HealthCheckResponse_NOT_SERVING HealthCheckResponse_ServingStatus = 2
+        HealthCheckResponse_UNKNOWN         HealthCheckResponse_ServingStatus = 0
+        HealthCheckResponse_SERVING         HealthCheckResponse_ServingStatus = 1
+        HealthCheckResponse_NOT_SERVING     HealthCheckResponse_ServingStatus = 2
+        HealthCheckResponse_SERVICE_UNKNOWN HealthCheckResponse_ServingStatus = 3
 )
 
 var HealthCheckResponse_ServingStatus_name = map[int32]string{
         0: "UNKNOWN",
         1: "SERVING",
         2: "NOT_SERVING",
+        3: "SERVICE_UNKNOWN",
 }
 var HealthCheckResponse_ServingStatus_value = map[string]int32{
-        "UNKNOWN":     0,
-        "SERVING":     1,
-        "NOT_SERVING": 2,
+        "UNKNOWN":         0,
+        "SERVING":         1,
+        "NOT_SERVING":     2,
+        "SERVICE_UNKNOWN": 3,
 }
 
 func (x HealthCheckResponse_ServingStatus) String() string {
         return proto.EnumName(HealthCheckResponse_ServingStatus_name, int32(x))
 }
 func (HealthCheckResponse_ServingStatus) EnumDescriptor() ([]byte, []int) {
-        return fileDescriptor0, []int{1, 0}
+        return fileDescriptor_health_6b1a06aa67f91efd, []int{1, 0}
 }
 
 type HealthCheckRequest struct {
-        Service string `protobuf:"bytes,1,opt,name=service" json:"service,omitempty"`
+        Service              string   `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"`
+        XXX_NoUnkeyedLiteral struct{} `json:"-"`
+        XXX_unrecognized     []byte   `json:"-"`
+        XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *HealthCheckRequest) Reset()         { *m = HealthCheckRequest{} }
+func (m *HealthCheckRequest) String() string { return proto.CompactTextString(m) }
+func (*HealthCheckRequest) ProtoMessage()    {}
+func (*HealthCheckRequest) Descriptor() ([]byte, []int) {
+        return fileDescriptor_health_6b1a06aa67f91efd, []int{0}
+}
+func (m *HealthCheckRequest) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_HealthCheckRequest.Unmarshal(m, b)
+}
+func (m *HealthCheckRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_HealthCheckRequest.Marshal(b, m, deterministic)
+}
+func (dst *HealthCheckRequest) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_HealthCheckRequest.Merge(dst, src)
+}
+func (m *HealthCheckRequest) XXX_Size() int {
+        return xxx_messageInfo_HealthCheckRequest.Size(m)
+}
+func (m *HealthCheckRequest) XXX_DiscardUnknown() {
+        xxx_messageInfo_HealthCheckRequest.DiscardUnknown(m)
 }
 
-func (m *HealthCheckRequest) Reset()                    { *m = HealthCheckRequest{} }
-func (m *HealthCheckRequest) String() string            { return proto.CompactTextString(m) }
-func (*HealthCheckRequest) ProtoMessage()               {}
-func (*HealthCheckRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+var xxx_messageInfo_HealthCheckRequest proto.InternalMessageInfo
+
+func (m *HealthCheckRequest) GetService() string {
+        if m != nil {
+                return m.Service
+        }
+        return ""
+}
 
 type HealthCheckResponse struct {
-        Status HealthCheckResponse_ServingStatus `protobuf:"varint,1,opt,name=status,enum=grpc.health.v1.HealthCheckResponse_ServingStatus" json:"status,omitempty"`
+        Status               HealthCheckResponse_ServingStatus `protobuf:"varint,1,opt,name=status,proto3,enum=grpc.health.v1.HealthCheckResponse_ServingStatus" json:"status,omitempty"`
+        XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
+        XXX_unrecognized     []byte                            `json:"-"`
+        XXX_sizecache        int32                             `json:"-"`
 }
 
-func (m *HealthCheckResponse) Reset()                    { *m = HealthCheckResponse{} }
-func (m *HealthCheckResponse) String() string            { return proto.CompactTextString(m) }
-func (*HealthCheckResponse) ProtoMessage()               {}
-func (*HealthCheckResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+func (m *HealthCheckResponse) Reset()         { *m = HealthCheckResponse{} }
+func (m *HealthCheckResponse) String() string { return proto.CompactTextString(m) }
+func (*HealthCheckResponse) ProtoMessage()    {}
+func (*HealthCheckResponse) Descriptor() ([]byte, []int) {
+        return fileDescriptor_health_6b1a06aa67f91efd, []int{1}
+}
+func (m *HealthCheckResponse) XXX_Unmarshal(b []byte) error {
+        return xxx_messageInfo_HealthCheckResponse.Unmarshal(m, b)
+}
+func (m *HealthCheckResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+        return xxx_messageInfo_HealthCheckResponse.Marshal(b, m, deterministic)
+}
+func (dst *HealthCheckResponse) XXX_Merge(src proto.Message) {
+        xxx_messageInfo_HealthCheckResponse.Merge(dst, src)
+}
+func (m *HealthCheckResponse) XXX_Size() int {
+        return xxx_messageInfo_HealthCheckResponse.Size(m)
+}
+func (m *HealthCheckResponse) XXX_DiscardUnknown() {
+        xxx_messageInfo_HealthCheckResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_HealthCheckResponse proto.InternalMessageInfo
+
+func (m *HealthCheckResponse) GetStatus() HealthCheckResponse_ServingStatus {
+        if m != nil {
+                return m.Status
+        }
+        return HealthCheckResponse_UNKNOWN
+}
 
 func init() {
         proto.RegisterType((*HealthCheckRequest)(nil), "grpc.health.v1.HealthCheckRequest")
@@ -92,10 +142,29 @@ var _ grpc.ClientConn
 // is compatible with the grpc package it is being compiled against.
 const _ = grpc.SupportPackageIsVersion4
 
-// Client API for Health service
-
+// HealthClient is the client API for Health service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
 type HealthClient interface {
+        // If the requested service is unknown, the call will fail with status
+        // NOT_FOUND.
         Check(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (*HealthCheckResponse, error)
+        // Performs a watch for the serving status of the requested service.
+        // The server will immediately send back a message indicating the current
+        // serving status.  It will then subsequently send a new message whenever
+        // the service's serving status changes.
+        //
+        // If the requested service is unknown when the call is received, the
+        // server will send a message setting the serving status to
+        // SERVICE_UNKNOWN but will *not* terminate the call.  If at some
+        // future point, the serving status of the service becomes known, the
+        // server will send a new message with the service's serving status.
+        //
+        // If the call terminates with status UNIMPLEMENTED, then clients
+        // should assume this method is not supported and should not retry the
+        // call.  If the call terminates with any other status (including OK),
+        // clients should retry the call with appropriate exponential backoff.
+        Watch(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (Health_WatchClient, error)
 }
 
 type healthClient struct {
@@ -108,17 +177,66 @@ func NewHealthClient(cc *grpc.ClientConn) HealthClient {
 
 func (c *healthClient) Check(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (*HealthCheckResponse, error) {
         out := new(HealthCheckResponse)
-        err := grpc.Invoke(ctx, "/grpc.health.v1.Health/Check", in, out, c.cc, opts...)
+        err := c.cc.Invoke(ctx, "/grpc.health.v1.Health/Check", in, out, opts...)
         if err != nil {
                 return nil, err
         }
         return out, nil
 }
 
-// Server API for Health service
+func (c *healthClient) Watch(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (Health_WatchClient, error) {
+        stream, err := c.cc.NewStream(ctx, &_Health_serviceDesc.Streams[0], "/grpc.health.v1.Health/Watch", opts...)
+        if err != nil {
+                return nil, err
+        }
+        x := &healthWatchClient{stream}
+        if err := x.ClientStream.SendMsg(in); err != nil {
+                return nil, err
+        }
+        if err := x.ClientStream.CloseSend(); err != nil {
+                return nil, err
+        }
+        return x, nil
+}
+
+type Health_WatchClient interface {
+        Recv() (*HealthCheckResponse, error)
+        grpc.ClientStream
+}
+
+type healthWatchClient struct {
+        grpc.ClientStream
+}
 
+func (x *healthWatchClient) Recv() (*HealthCheckResponse, error) {
+        m := new(HealthCheckResponse)
+        if err := x.ClientStream.RecvMsg(m); err != nil {
+                return nil, err
+        }
+        return m, nil
+}
+
+// HealthServer is the server API for Health service.
 type HealthServer interface {
+        // If the requested service is unknown, the call will fail with status
+        // NOT_FOUND.
         Check(context.Context, *HealthCheckRequest) (*HealthCheckResponse, error)
+        // Performs a watch for the serving status of the requested service.
+        // The server will immediately send back a message indicating the current
+        // serving status.  It will then subsequently send a new message whenever
+        // the service's serving status changes.
+        //
+        // If the requested service is unknown when the call is received, the
+        // server will send a message setting the serving status to
+        // SERVICE_UNKNOWN but will *not* terminate the call.  If at some
+        // future point, the serving status of the service becomes known, the
+        // server will send a new message with the service's serving status.
+        //
+        // If the call terminates with status UNIMPLEMENTED, then clients
+        // should assume this method is not supported and should not retry the
+        // call.  If the call terminates with any other status (including OK),
+        // clients should retry the call with appropriate exponential backoff.
+        Watch(*HealthCheckRequest, Health_WatchServer) error
 }
 
 func RegisterHealthServer(s *grpc.Server, srv HealthServer) {
@@ -143,6 +261,27 @@ func _Health_Check_Handler(srv interface{}, ctx context.Context, dec func(interf
         return interceptor(ctx, in, info, handler)
 }
 
+func _Health_Watch_Handler(srv interface{}, stream grpc.ServerStream) error {
+        m := new(HealthCheckRequest)
+        if err := stream.RecvMsg(m); err != nil {
+                return err
+        }
+        return srv.(HealthServer).Watch(m, &healthWatchServer{stream})
+}
+
+type Health_WatchServer interface {
+        Send(*HealthCheckResponse) error
+        grpc.ServerStream
+}
+
+type healthWatchServer struct {
+        grpc.ServerStream
+}
+
+func (x *healthWatchServer) Send(m *HealthCheckResponse) error {
+        return x.ServerStream.SendMsg(m)
+}
+
 var _Health_serviceDesc = grpc.ServiceDesc{
         ServiceName: "grpc.health.v1.Health",
         HandlerType: (*HealthServer)(nil),
@@ -152,25 +291,37 @@ var _Health_serviceDesc = grpc.ServiceDesc{
                         Handler:    _Health_Check_Handler,
                 },
         },
-        Streams:  []grpc.StreamDesc{},
-        Metadata: "health.proto",
-}
-
-func init() { proto.RegisterFile("health.proto", fileDescriptor0) }
-
-var fileDescriptor0 = []byte{
-        // 204 bytes of a gzipped FileDescriptorProto
-        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0xc9, 0x48, 0x4d, 0xcc,
-        0x29, 0xc9, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x4b, 0x2f, 0x2a, 0x48, 0xd6, 0x83,
-        0x0a, 0x95, 0x19, 0x2a, 0xe9, 0x71, 0x09, 0x79, 0x80, 0x39, 0xce, 0x19, 0xa9, 0xc9, 0xd9, 0x41,
-        0xa9, 0x85, 0xa5, 0xa9, 0xc5, 0x25, 0x42, 0x12, 0x5c, 0xec, 0xc5, 0xa9, 0x45, 0x65, 0x99, 0xc9,
-        0xa9, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x9c, 0x41, 0x30, 0xae, 0xd2, 0x1c, 0x46, 0x2e, 0x61, 0x14,
-        0x0d, 0xc5, 0x05, 0xf9, 0x79, 0xc5, 0xa9, 0x42, 0x9e, 0x5c, 0x6c, 0xc5, 0x25, 0x89, 0x25, 0xa5,
-        0xc5, 0x60, 0x0d, 0x7c, 0x46, 0x86, 0x7a, 0xa8, 0x16, 0xe9, 0x61, 0xd1, 0xa4, 0x17, 0x0c, 0x32,
-        0x34, 0x2f, 0x3d, 0x18, 0xac, 0x31, 0x08, 0x6a, 0x80, 0x92, 0x15, 0x17, 0x2f, 0x8a, 0x84, 0x10,
-        0x37, 0x17, 0x7b, 0xa8, 0x9f, 0xb7, 0x9f, 0x7f, 0xb8, 0x9f, 0x00, 0x03, 0x88, 0x13, 0xec, 0x1a,
-        0x14, 0xe6, 0xe9, 0xe7, 0x2e, 0xc0, 0x28, 0xc4, 0xcf, 0xc5, 0xed, 0xe7, 0x1f, 0x12, 0x0f, 0x13,
-        0x60, 0x32, 0x8a, 0xe2, 0x62, 0x83, 0x58, 0x24, 0x14, 0xc0, 0xc5, 0x0a, 0xb6, 0x4c, 0x48, 0x09,
-        0xaf, 0x4b, 0xc0, 0xfe, 0x95, 0x52, 0x26, 0xc2, 0xb5, 0x49, 0x6c, 0xe0, 0x10, 0x34, 0x06, 0x04,
-        0x00, 0x00, 0xff, 0xff, 0xac, 0x56, 0x2a, 0xcb, 0x51, 0x01, 0x00, 0x00,
+        Streams: []grpc.StreamDesc{
+                {
+                        StreamName:    "Watch",
+                        Handler:       _Health_Watch_Handler,
+                        ServerStreams: true,
+                },
+        },
+        Metadata: "grpc/health/v1/health.proto",
+}
+
+func init() { proto.RegisterFile("grpc/health/v1/health.proto", fileDescriptor_health_6b1a06aa67f91efd) }
+
+var fileDescriptor_health_6b1a06aa67f91efd = []byte{
+        // 297 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0x2f, 0x2a, 0x48,
+        0xd6, 0xcf, 0x48, 0x4d, 0xcc, 0x29, 0xc9, 0xd0, 0x2f, 0x33, 0x84, 0xb2, 0xf4, 0x0a, 0x8a, 0xf2,
+        0x4b, 0xf2, 0x85, 0xf8, 0x40, 0x92, 0x7a, 0x50, 0xa1, 0x32, 0x43, 0x25, 0x3d, 0x2e, 0x21, 0x0f,
+        0x30, 0xc7, 0x39, 0x23, 0x35, 0x39, 0x3b, 0x28, 0xb5, 0xb0, 0x34, 0xb5, 0xb8, 0x44, 0x48, 0x82,
+        0x8b, 0xbd, 0x38, 0xb5, 0xa8, 0x2c, 0x33, 0x39, 0x55, 0x82, 0x51, 0x81, 0x51, 0x83, 0x33, 0x08,
+        0xc6, 0x55, 0xda, 0xc8, 0xc8, 0x25, 0x8c, 0xa2, 0xa1, 0xb8, 0x20, 0x3f, 0xaf, 0x38, 0x55, 0xc8,
+        0x93, 0x8b, 0xad, 0xb8, 0x24, 0xb1, 0xa4, 0xb4, 0x18, 0xac, 0x81, 0xcf, 0xc8, 0x50, 0x0f, 0xd5,
+        0x22, 0x3d, 0x2c, 0x9a, 0xf4, 0x82, 0x41, 0x86, 0xe6, 0xa5, 0x07, 0x83, 0x35, 0x06, 0x41, 0x0d,
+        0x50, 0xf2, 0xe7, 0xe2, 0x45, 0x91, 0x10, 0xe2, 0xe6, 0x62, 0x0f, 0xf5, 0xf3, 0xf6, 0xf3, 0x0f,
+        0xf7, 0x13, 0x60, 0x00, 0x71, 0x82, 0x5d, 0x83, 0xc2, 0x3c, 0xfd, 0xdc, 0x05, 0x18, 0x85, 0xf8,
+        0xb9, 0xb8, 0xfd, 0xfc, 0x43, 0xe2, 0x61, 0x02, 0x4c, 0x42, 0xc2, 0x5c, 0xfc, 0x60, 0x8e, 0xb3,
+        0x6b, 0x3c, 0x4c, 0x0b, 0xb3, 0xd1, 0x3a, 0x46, 0x2e, 0x36, 0x88, 0xf5, 0x42, 0x01, 0x5c, 0xac,
+        0x60, 0x27, 0x08, 0x29, 0xe1, 0x75, 0x1f, 0x38, 0x14, 0xa4, 0x94, 0x89, 0xf0, 0x83, 0x50, 0x10,
+        0x17, 0x6b, 0x78, 0x62, 0x49, 0x72, 0x06, 0xd5, 0x4c, 0x34, 0x60, 0x74, 0x4a, 0xe4, 0x12, 0xcc,
+        0xcc, 0x47, 0x53, 0xea, 0xc4, 0x0d, 0x51, 0x1b, 0x00, 0x8a, 0xc6, 0x00, 0xc6, 0x28, 0x9d, 0xf4,
+        0xfc, 0xfc, 0xf4, 0x9c, 0x54, 0xbd, 0xf4, 0xfc, 0x9c, 0xc4, 0xbc, 0x74, 0xbd, 0xfc, 0xa2, 0x74,
+        0x7d, 0xe4, 0x78, 0x07, 0xb1, 0xe3, 0x21, 0xec, 0xf8, 0x32, 0xc3, 0x55, 0x4c, 0x7c, 0xee, 0x20,
+        0xd3, 0x20, 0x46, 0xe8, 0x85, 0x19, 0x26, 0xb1, 0x81, 0x93, 0x83, 0x31, 0x20, 0x00, 0x00, 0xff,
+        0xff, 0x12, 0x7d, 0x96, 0xcb, 0x2d, 0x02, 0x00, 0x00,
 }
diff --git a/vendor/google.golang.org/grpc/health/health.go b/vendor/google.golang.org/grpc/health/health.go
deleted file mode 100644
index 4dccbc7..0000000
--- a/vendor/google.golang.org/grpc/health/health.go
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- *
- * Copyright 2017 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// Package health provides some utility functions to health-check a server. The implementation
-// is based on protobuf. Users need to write their own implementations if other IDLs are used.
-package health
-
-import (
-        "sync"
-
-        "golang.org/x/net/context"
-        "google.golang.org/grpc"
-        "google.golang.org/grpc/codes"
-        healthpb "google.golang.org/grpc/health/grpc_health_v1"
-)
-
-// Server implements `service Health`.
-type Server struct {
-        mu sync.Mutex
-        // statusMap stores the serving status of the services this Server monitors.
-        statusMap map[string]healthpb.HealthCheckResponse_ServingStatus
-}
-
-// NewServer returns a new Server.
-func NewServer() *Server {
-        return &Server{
-                statusMap: make(map[string]healthpb.HealthCheckResponse_ServingStatus),
-        }
-}
-
-// Check implements `service Health`.
-func (s *Server) Check(ctx context.Context, in *healthpb.HealthCheckRequest) (*healthpb.HealthCheckResponse, error) {
-        s.mu.Lock()
-        defer s.mu.Unlock()
-        if in.Service == "" {
-                // check the server overall health status.
-                return &healthpb.HealthCheckResponse{
-                        Status: healthpb.HealthCheckResponse_SERVING,
-                }, nil
-        }
-        if status, ok := s.statusMap[in.Service]; ok {
-                return &healthpb.HealthCheckResponse{
-                        Status: status,
-                }, nil
-        }
-        return nil, grpc.Errorf(codes.NotFound, "unknown service")
-}
-
-// SetServingStatus is called when need to reset the serving status of a service
-// or insert a new service entry into the statusMap.
-func (s *Server) SetServingStatus(service string, status healthpb.HealthCheckResponse_ServingStatus) {
-        s.mu.Lock()
-        s.statusMap[service] = status
-        s.mu.Unlock()
-}
diff --git a/vendor/google.golang.org/grpc/health/regenerate.sh b/vendor/google.golang.org/grpc/health/regenerate.sh
new file mode 100644
index 0000000..b11eccb
--- /dev/null
+++ b/vendor/google.golang.org/grpc/health/regenerate.sh
@@ -0,0 +1,33 @@
+#!/bin/bash
+# Copyright 2018 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set -eux -o pipefail
+
+TMP=$(mktemp -d)
+
+function finish {
+  rm -rf "$TMP"
+}
+trap finish EXIT
+
+pushd "$TMP"
+mkdir -p grpc/health/v1
+curl https://raw.githubusercontent.com/grpc/grpc-proto/master/grpc/health/v1/health.proto > grpc/health/v1/health.proto
+
+protoc --go_out=plugins=grpc,paths=source_relative:. -I. grpc/health/v1/*.proto
+popd
+rm -f grpc_health_v1/*.pb.go
+cp "$TMP"/grpc/health/v1/*.pb.go grpc_health_v1/
+
diff --git a/vendor/google.golang.org/grpc/health/server.go b/vendor/google.golang.org/grpc/health/server.go
new file mode 100644
index 0000000..c79f9d2
--- /dev/null
+++ b/vendor/google.golang.org/grpc/health/server.go
@@ -0,0 +1,165 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+//go:generate ./regenerate.sh
+
+// Package health provides a service that exposes server's health and it must be
+// imported to enable support for client-side health checks.
+package health
+
+import (
+        "context"
+        "sync"
+
+        "google.golang.org/grpc/codes"
+        "google.golang.org/grpc/grpclog"
+        healthgrpc "google.golang.org/grpc/health/grpc_health_v1"
+        healthpb "google.golang.org/grpc/health/grpc_health_v1"
+        "google.golang.org/grpc/status"
+)
+
+// Server implements `service Health`.
+type Server struct {
+        mu sync.Mutex
+        // If shutdown is true, it's expected all serving status is NOT_SERVING, and
+        // will stay in NOT_SERVING.
+        shutdown bool
+        // statusMap stores the serving status of the services this Server monitors.
+        statusMap map[string]healthpb.HealthCheckResponse_ServingStatus
+        updates   map[string]map[healthgrpc.Health_WatchServer]chan healthpb.HealthCheckResponse_ServingStatus
+}
+
+// NewServer returns a new Server.
+func NewServer() *Server {
+        return &Server{
+                statusMap: map[string]healthpb.HealthCheckResponse_ServingStatus{"": healthpb.HealthCheckResponse_SERVING},
+                updates:   make(map[string]map[healthgrpc.Health_WatchServer]chan healthpb.HealthCheckResponse_ServingStatus),
+        }
+}
+
+// Check implements `service Health`.
+func (s *Server) Check(ctx context.Context, in *healthpb.HealthCheckRequest) (*healthpb.HealthCheckResponse, error) {
+        s.mu.Lock()
+        defer s.mu.Unlock()
+        if servingStatus, ok := s.statusMap[in.Service]; ok {
+                return &healthpb.HealthCheckResponse{
+                        Status: servingStatus,
+                }, nil
+        }
+        return nil, status.Error(codes.NotFound, "unknown service")
+}
+
+// Watch implements `service Health`.
+func (s *Server) Watch(in *healthpb.HealthCheckRequest, stream healthgrpc.Health_WatchServer) error {
+        service := in.Service
+        // update channel is used for getting service status updates.
+        update := make(chan healthpb.HealthCheckResponse_ServingStatus, 1)
+        s.mu.Lock()
+        // Puts the initial status to the channel.
+        if servingStatus, ok := s.statusMap[service]; ok {
+                update <- servingStatus
+        } else {
+                update <- healthpb.HealthCheckResponse_SERVICE_UNKNOWN
+        }
+
+        // Registers the update channel to the correct place in the updates map.
+        if _, ok := s.updates[service]; !ok {
+                s.updates[service] = make(map[healthgrpc.Health_WatchServer]chan healthpb.HealthCheckResponse_ServingStatus)
+        }
+        s.updates[service][stream] = update
+        defer func() {
+                s.mu.Lock()
+                delete(s.updates[service], stream)
+                s.mu.Unlock()
+        }()
+        s.mu.Unlock()
+
+        var lastSentStatus healthpb.HealthCheckResponse_ServingStatus = -1
+        for {
+                select {
+                // Status updated. Sends the up-to-date status to the client.
+                case servingStatus := <-update:
+                        if lastSentStatus == servingStatus {
+                                continue
+                        }
+                        lastSentStatus = servingStatus
+                        err := stream.Send(&healthpb.HealthCheckResponse{Status: servingStatus})
+                        if err != nil {
+                                return status.Error(codes.Canceled, "Stream has ended.")
+                        }
+                // Context done. Removes the update channel from the updates map.
+                case <-stream.Context().Done():
+                        return status.Error(codes.Canceled, "Stream has ended.")
+                }
+        }
+}
+
+// SetServingStatus is called when need to reset the serving status of a service
+// or insert a new service entry into the statusMap.
+func (s *Server) SetServingStatus(service string, servingStatus healthpb.HealthCheckResponse_ServingStatus) {
+        s.mu.Lock()
+        defer s.mu.Unlock()
+        if s.shutdown {
+                grpclog.Infof("health: status changing for %s to %v is ignored because health service is shutdown", service, servingStatus)
+                return
+        }
+
+        s.setServingStatusLocked(service, servingStatus)
+}
+
+func (s *Server) setServingStatusLocked(service string, servingStatus healthpb.HealthCheckResponse_ServingStatus) {
+        s.statusMap[service] = servingStatus
+        for _, update := range s.updates[service] {
+                // Clears previous updates, that are not sent to the client, from the channel.
+                // This can happen if the client is not reading and the server gets flow control limited.
+                select {
+                case <-update:
+                default:
+                }
+                // Puts the most recent update to the channel.
+                update <- servingStatus
+        }
+}
+
+// Shutdown sets all serving status to NOT_SERVING, and configures the server to
+// ignore all future status changes.
+//
+// This changes serving status for all services. To set status for a perticular
+// services, call SetServingStatus().
+func (s *Server) Shutdown() {
+        s.mu.Lock()
+        defer s.mu.Unlock()
+        s.shutdown = true
+        for service := range s.statusMap {
+                s.setServingStatusLocked(service, healthpb.HealthCheckResponse_NOT_SERVING)
+        }
+}
+
+// Resume sets all serving status to SERVING, and configures the server to
+// accept all future status changes.
+//
+// This changes serving status for all services. To set status for a perticular
+// services, call SetServingStatus().
+func (s *Server) Resume() {
+        s.mu.Lock()
+        defer s.mu.Unlock()
+        s.shutdown = false
+        for service := range s.statusMap {
+                s.setServingStatusLocked(service, healthpb.HealthCheckResponse_SERVING)
+        }
+}
diff --git a/vendor/google.golang.org/grpc/install_gae.sh b/vendor/google.golang.org/grpc/install_gae.sh
new file mode 100644
index 0000000..7c7bcad
--- /dev/null
+++ b/vendor/google.golang.org/grpc/install_gae.sh
@@ -0,0 +1,6 @@
+#!/bin/bash
+
+TMP=$(mktemp -d /tmp/sdk.XXX) \
+&& curl -o $TMP.zip "https://storage.googleapis.com/appengine-sdks/featured/go_appengine_sdk_linux_amd64-1.9.68.zip" \
+&& unzip -q $TMP.zip -d $TMP \
+&& export PATH="$PATH:$TMP/go_appengine"
diff --git a/vendor/google.golang.org/grpc/interceptor.go b/vendor/google.golang.org/grpc/interceptor.go
index 06dc825..8b73500 100644
--- a/vendor/google.golang.org/grpc/interceptor.go
+++ b/vendor/google.golang.org/grpc/interceptor.go
@@ -19,7 +19,7 @@
 package grpc
 
 import (
-        "golang.org/x/net/context"
+        "context"
 )
 
 // UnaryInvoker is called by UnaryClientInterceptor to complete RPCs.
@@ -48,7 +48,9 @@ type UnaryServerInfo struct {
 }
 
 // UnaryHandler defines the handler invoked by UnaryServerInterceptor to complete the normal
-// execution of a unary RPC.
+// execution of a unary RPC. If a UnaryHandler returns an error, it should be produced by the
+// status package, or else gRPC will use codes.Unknown as the status code and err.Error() as
+// the status message of the RPC.
 type UnaryHandler func(ctx context.Context, req interface{}) (interface{}, error)
 
 // UnaryServerInterceptor provides a hook to intercept the execution of a unary RPC on the server. info
diff --git a/vendor/google.golang.org/grpc/internal/backoff/backoff.go b/vendor/google.golang.org/grpc/internal/backoff/backoff.go
new file mode 100644
index 0000000..1bd0cce
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/backoff/backoff.go
@@ -0,0 +1,78 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package backoff implement the backoff strategy for gRPC.
+//
+// This is kept in internal until the gRPC project decides whether or not to
+// allow alternative backoff strategies.
+package backoff
+
+import (
+        "time"
+
+        "google.golang.org/grpc/internal/grpcrand"
+)
+
+// Strategy defines the methodology for backing off after a grpc connection
+// failure.
+//
+type Strategy interface {
+        // Backoff returns the amount of time to wait before the next retry given
+        // the number of consecutive failures.
+        Backoff(retries int) time.Duration
+}
+
+const (
+        // baseDelay is the amount of time to wait before retrying after the first
+        // failure.
+        baseDelay = 1.0 * time.Second
+        // factor is applied to the backoff after each retry.
+        factor = 1.6
+        // jitter provides a range to randomize backoff delays.
+        jitter = 0.2
+)
+
+// Exponential implements exponential backoff algorithm as defined in
+// https://github.com/grpc/grpc/blob/master/doc/connection-backoff.md.
+type Exponential struct {
+        // MaxDelay is the upper bound of backoff delay.
+        MaxDelay time.Duration
+}
+
+// Backoff returns the amount of time to wait before the next retry given the
+// number of retries.
+func (bc Exponential) Backoff(retries int) time.Duration {
+        if retries == 0 {
+                return baseDelay
+        }
+        backoff, max := float64(baseDelay), float64(bc.MaxDelay)
+        for backoff < max && retries > 0 {
+                backoff *= factor
+                retries--
+        }
+        if backoff > max {
+                backoff = max
+        }
+        // Randomize backoff delays so that if a cluster of requests start at
+        // the same time, they won't operate in lockstep.
+        backoff *= 1 + jitter*(grpcrand.Float64()*2-1)
+        if backoff < 0 {
+                return 0
+        }
+        return time.Duration(backoff)
+}
diff --git a/vendor/google.golang.org/grpc/internal/binarylog/binarylog.go b/vendor/google.golang.org/grpc/internal/binarylog/binarylog.go
new file mode 100644
index 0000000..fee6aec
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/binarylog/binarylog.go
@@ -0,0 +1,167 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package binarylog implementation binary logging as defined in
+// https://github.com/grpc/proposal/blob/master/A16-binary-logging.md.
+package binarylog
+
+import (
+        "fmt"
+        "os"
+
+        "google.golang.org/grpc/grpclog"
+)
+
+// Logger is the global binary logger. It can be used to get binary logger for
+// each method.
+type Logger interface {
+        getMethodLogger(methodName string) *MethodLogger
+}
+
+// binLogger is the global binary logger for the binary. One of this should be
+// built at init time from the configuration (environment varialbe or flags).
+//
+// It is used to get a methodLogger for each individual method.
+var binLogger Logger
+
+// SetLogger sets the binarg logger.
+//
+// Only call this at init time.
+func SetLogger(l Logger) {
+        binLogger = l
+}
+
+// GetMethodLogger returns the methodLogger for the given methodName.
+//
+// methodName should be in the format of "/service/method".
+//
+// Each methodLogger returned by this method is a new instance. This is to
+// generate sequence id within the call.
+func GetMethodLogger(methodName string) *MethodLogger {
+        if binLogger == nil {
+                return nil
+        }
+        return binLogger.getMethodLogger(methodName)
+}
+
+func init() {
+        const envStr = "GRPC_BINARY_LOG_FILTER"
+        configStr := os.Getenv(envStr)
+        binLogger = NewLoggerFromConfigString(configStr)
+}
+
+type methodLoggerConfig struct {
+        // Max length of header and message.
+        hdr, msg uint64
+}
+
+type logger struct {
+        all      *methodLoggerConfig
+        services map[string]*methodLoggerConfig
+        methods  map[string]*methodLoggerConfig
+
+        blacklist map[string]struct{}
+}
+
+// newEmptyLogger creates an empty logger. The map fields need to be filled in
+// using the set* functions.
+func newEmptyLogger() *logger {
+        return &logger{}
+}
+
+// Set method logger for "*".
+func (l *logger) setDefaultMethodLogger(ml *methodLoggerConfig) error {
+        if l.all != nil {
+                return fmt.Errorf("conflicting global rules found")
+        }
+        l.all = ml
+        return nil
+}
+
+// Set method logger for "service/*".
+//
+// New methodLogger with same service overrides the old one.
+func (l *logger) setServiceMethodLogger(service string, ml *methodLoggerConfig) error {
+        if _, ok := l.services[service]; ok {
+                return fmt.Errorf("conflicting rules for service %v found", service)
+        }
+        if l.services == nil {
+                l.services = make(map[string]*methodLoggerConfig)
+        }
+        l.services[service] = ml
+        return nil
+}
+
+// Set method logger for "service/method".
+//
+// New methodLogger with same method overrides the old one.
+func (l *logger) setMethodMethodLogger(method string, ml *methodLoggerConfig) error {
+        if _, ok := l.blacklist[method]; ok {
+                return fmt.Errorf("conflicting rules for method %v found", method)
+        }
+        if _, ok := l.methods[method]; ok {
+                return fmt.Errorf("conflicting rules for method %v found", method)
+        }
+        if l.methods == nil {
+                l.methods = make(map[string]*methodLoggerConfig)
+        }
+        l.methods[method] = ml
+        return nil
+}
+
+// Set blacklist method for "-service/method".
+func (l *logger) setBlacklist(method string) error {
+        if _, ok := l.blacklist[method]; ok {
+                return fmt.Errorf("conflicting rules for method %v found", method)
+        }
+        if _, ok := l.methods[method]; ok {
+                return fmt.Errorf("conflicting rules for method %v found", method)
+        }
+        if l.blacklist == nil {
+                l.blacklist = make(map[string]struct{})
+        }
+        l.blacklist[method] = struct{}{}
+        return nil
+}
+
+// getMethodLogger returns the methodLogger for the given methodName.
+//
+// methodName should be in the format of "/service/method".
+//
+// Each methodLogger returned by this method is a new instance. This is to
+// generate sequence id within the call.
+func (l *logger) getMethodLogger(methodName string) *MethodLogger {
+        s, m, err := parseMethodName(methodName)
+        if err != nil {
+                grpclog.Infof("binarylogging: failed to parse %q: %v", methodName, err)
+                return nil
+        }
+        if ml, ok := l.methods[s+"/"+m]; ok {
+                return newMethodLogger(ml.hdr, ml.msg)
+        }
+        if _, ok := l.blacklist[s+"/"+m]; ok {
+                return nil
+        }
+        if ml, ok := l.services[s]; ok {
+                return newMethodLogger(ml.hdr, ml.msg)
+        }
+        if l.all == nil {
+                return nil
+        }
+        return newMethodLogger(l.all.hdr, l.all.msg)
+}
diff --git a/vendor/google.golang.org/grpc/internal/binarylog/binarylog_testutil.go b/vendor/google.golang.org/grpc/internal/binarylog/binarylog_testutil.go
new file mode 100644
index 0000000..1ee00a3
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/binarylog/binarylog_testutil.go
@@ -0,0 +1,42 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// This file contains exported variables/functions that are exported for testing
+// only.
+//
+// An ideal way for this would be to put those in a *_test.go but in binarylog
+// package. But this doesn't work with staticcheck with go module. Error was:
+// "MdToMetadataProto not declared by package binarylog". This could be caused
+// by the way staticcheck looks for files for a certain package, which doesn't
+// support *_test.go files.
+//
+// Move those to binary_test.go when staticcheck is fixed.
+
+package binarylog
+
+var (
+        // AllLogger is a logger that logs all headers/messages for all RPCs. It's
+        // for testing only.
+        AllLogger = NewLoggerFromConfigString("*")
+        // MdToMetadataProto converts metadata to a binary logging proto message.
+        // It's for testing only.
+        MdToMetadataProto = mdToMetadataProto
+        // AddrToProto converts an address to a binary logging proto message. It's
+        // for testing only.
+        AddrToProto = addrToProto
+)
diff --git a/vendor/google.golang.org/grpc/internal/binarylog/env_config.go b/vendor/google.golang.org/grpc/internal/binarylog/env_config.go
new file mode 100644
index 0000000..eb188ea
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/binarylog/env_config.go
@@ -0,0 +1,210 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package binarylog
+
+import (
+        "errors"
+        "fmt"
+        "regexp"
+        "strconv"
+        "strings"
+
+        "google.golang.org/grpc/grpclog"
+)
+
+// NewLoggerFromConfigString reads the string and build a logger. It can be used
+// to build a new logger and assign it to binarylog.Logger.
+//
+// Example filter config strings:
+//  - "" Nothing will be logged
+//  - "*" All headers and messages will be fully logged.
+//  - "*{h}" Only headers will be logged.
+//  - "*{m:256}" Only the first 256 bytes of each message will be logged.
+//  - "Foo/*" Logs every method in service Foo
+//  - "Foo/*,-Foo/Bar" Logs every method in service Foo except method /Foo/Bar
+//  - "Foo/*,Foo/Bar{m:256}" Logs the first 256 bytes of each message in method
+//    /Foo/Bar, logs all headers and messages in every other method in service
+//    Foo.
+//
+// If two configs exist for one certain method or service, the one specified
+// later overrides the privous config.
+func NewLoggerFromConfigString(s string) Logger {
+        if s == "" {
+                return nil
+        }
+        l := newEmptyLogger()
+        methods := strings.Split(s, ",")
+        for _, method := range methods {
+                if err := l.fillMethodLoggerWithConfigString(method); err != nil {
+                        grpclog.Warningf("failed to parse binary log config: %v", err)
+                        return nil
+                }
+        }
+        return l
+}
+
+// fillMethodLoggerWithConfigString parses config, creates methodLogger and adds
+// it to the right map in the logger.
+func (l *logger) fillMethodLoggerWithConfigString(config string) error {
+        // "" is invalid.
+        if config == "" {
+                return errors.New("empty string is not a valid method binary logging config")
+        }
+
+        // "-service/method", blacklist, no * or {} allowed.
+        if config[0] == '-' {
+                s, m, suffix, err := parseMethodConfigAndSuffix(config[1:])
+                if err != nil {
+                        return fmt.Errorf("invalid config: %q, %v", config, err)
+                }
+                if m == "*" {
+                        return fmt.Errorf("invalid config: %q, %v", config, "* not allowd in blacklist config")
+                }
+                if suffix != "" {
+                        return fmt.Errorf("invalid config: %q, %v", config, "header/message limit not allowed in blacklist config")
+                }
+                if err := l.setBlacklist(s + "/" + m); err != nil {
+                        return fmt.Errorf("invalid config: %v", err)
+                }
+                return nil
+        }
+
+        // "*{h:256;m:256}"
+        if config[0] == '*' {
+                hdr, msg, err := parseHeaderMessageLengthConfig(config[1:])
+                if err != nil {
+                        return fmt.Errorf("invalid config: %q, %v", config, err)
+                }
+                if err := l.setDefaultMethodLogger(&methodLoggerConfig{hdr: hdr, msg: msg}); err != nil {
+                        return fmt.Errorf("invalid config: %v", err)
+                }
+                return nil
+        }
+
+        s, m, suffix, err := parseMethodConfigAndSuffix(config)
+        if err != nil {
+                return fmt.Errorf("invalid config: %q, %v", config, err)
+        }
+        hdr, msg, err := parseHeaderMessageLengthConfig(suffix)
+        if err != nil {
+                return fmt.Errorf("invalid header/message length config: %q, %v", suffix, err)
+        }
+        if m == "*" {
+                if err := l.setServiceMethodLogger(s, &methodLoggerConfig{hdr: hdr, msg: msg}); err != nil {
+                        return fmt.Errorf("invalid config: %v", err)
+                }
+        } else {
+                if err := l.setMethodMethodLogger(s+"/"+m, &methodLoggerConfig{hdr: hdr, msg: msg}); err != nil {
+                        return fmt.Errorf("invalid config: %v", err)
+                }
+        }
+        return nil
+}
+
+const (
+        // TODO: this const is only used by env_config now. But could be useful for
+        // other config. Move to binarylog.go if necessary.
+        maxUInt = ^uint64(0)
+
+        // For "p.s/m" plus any suffix. Suffix will be parsed again. See test for
+        // expected output.
+        longMethodConfigRegexpStr = `^([\w./]+)/((?:\w+)|[*])(.+)?$`
+
+        // For suffix from above, "{h:123,m:123}". See test for expected output.
+        optionalLengthRegexpStr      = `(?::(\d+))?` // Optional ":123".
+        headerConfigRegexpStr        = `^{h` + optionalLengthRegexpStr + `}$`
+        messageConfigRegexpStr       = `^{m` + optionalLengthRegexpStr + `}$`
+        headerMessageConfigRegexpStr = `^{h` + optionalLengthRegexpStr + `;m` + optionalLengthRegexpStr + `}$`
+)
+
+var (
+        longMethodConfigRegexp    = regexp.MustCompile(longMethodConfigRegexpStr)
+        headerConfigRegexp        = regexp.MustCompile(headerConfigRegexpStr)
+        messageConfigRegexp       = regexp.MustCompile(messageConfigRegexpStr)
+        headerMessageConfigRegexp = regexp.MustCompile(headerMessageConfigRegexpStr)
+)
+
+// Turn "service/method{h;m}" into "service", "method", "{h;m}".
+func parseMethodConfigAndSuffix(c string) (service, method, suffix string, _ error) {
+        // Regexp result:
+        //
+        // in:  "p.s/m{h:123,m:123}",
+        // out: []string{"p.s/m{h:123,m:123}", "p.s", "m", "{h:123,m:123}"},
+        match := longMethodConfigRegexp.FindStringSubmatch(c)
+        if match == nil {
+                return "", "", "", fmt.Errorf("%q contains invalid substring", c)
+        }
+        service = match[1]
+        method = match[2]
+        suffix = match[3]
+        return
+}
+
+// Turn "{h:123;m:345}" into 123, 345.
+//
+// Return maxUInt if length is unspecified.
+func parseHeaderMessageLengthConfig(c string) (hdrLenStr, msgLenStr uint64, err error) {
+        if c == "" {
+                return maxUInt, maxUInt, nil
+        }
+        // Header config only.
+        if match := headerConfigRegexp.FindStringSubmatch(c); match != nil {
+                if s := match[1]; s != "" {
+                        hdrLenStr, err = strconv.ParseUint(s, 10, 64)
+                        if err != nil {
+                                return 0, 0, fmt.Errorf("failed to convert %q to uint", s)
+                        }
+                        return hdrLenStr, 0, nil
+                }
+                return maxUInt, 0, nil
+        }
+
+        // Message config only.
+        if match := messageConfigRegexp.FindStringSubmatch(c); match != nil {
+                if s := match[1]; s != "" {
+                        msgLenStr, err = strconv.ParseUint(s, 10, 64)
+                        if err != nil {
+                                return 0, 0, fmt.Errorf("Failed to convert %q to uint", s)
+                        }
+                        return 0, msgLenStr, nil
+                }
+                return 0, maxUInt, nil
+        }
+
+        // Header and message config both.
+        if match := headerMessageConfigRegexp.FindStringSubmatch(c); match != nil {
+                // Both hdr and msg are specified, but one or two of them might be empty.
+                hdrLenStr = maxUInt
+                msgLenStr = maxUInt
+                if s := match[1]; s != "" {
+                        hdrLenStr, err = strconv.ParseUint(s, 10, 64)
+                        if err != nil {
+                                return 0, 0, fmt.Errorf("Failed to convert %q to uint", s)
+                        }
+                }
+                if s := match[2]; s != "" {
+                        msgLenStr, err = strconv.ParseUint(s, 10, 64)
+                        if err != nil {
+                                return 0, 0, fmt.Errorf("Failed to convert %q to uint", s)
+                        }
+                }
+                return hdrLenStr, msgLenStr, nil
+        }
+        return 0, 0, fmt.Errorf("%q contains invalid substring", c)
+}
diff --git a/vendor/google.golang.org/grpc/internal/binarylog/method_logger.go b/vendor/google.golang.org/grpc/internal/binarylog/method_logger.go
new file mode 100644
index 0000000..b06cdd4
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/binarylog/method_logger.go
@@ -0,0 +1,426 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package binarylog
+
+import (
+        "net"
+        "strings"
+        "sync/atomic"
+        "time"
+
+        "github.com/golang/protobuf/proto"
+        "github.com/golang/protobuf/ptypes"
+        pb "google.golang.org/grpc/binarylog/grpc_binarylog_v1"
+        "google.golang.org/grpc/grpclog"
+        "google.golang.org/grpc/metadata"
+        "google.golang.org/grpc/status"
+)
+
+type callIDGenerator struct {
+        id uint64
+}
+
+func (g *callIDGenerator) next() uint64 {
+        id := atomic.AddUint64(&g.id, 1)
+        return id
+}
+
+// reset is for testing only, and doesn't need to be thread safe.
+func (g *callIDGenerator) reset() {
+        g.id = 0
+}
+
+var idGen callIDGenerator
+
+// MethodLogger is the sub-logger for each method.
+type MethodLogger struct {
+        headerMaxLen, messageMaxLen uint64
+
+        callID          uint64
+        idWithinCallGen *callIDGenerator
+
+        sink Sink // TODO(blog): make this plugable.
+}
+
+func newMethodLogger(h, m uint64) *MethodLogger {
+        return &MethodLogger{
+                headerMaxLen:  h,
+                messageMaxLen: m,
+
+                callID:          idGen.next(),
+                idWithinCallGen: &callIDGenerator{},
+
+                sink: defaultSink, // TODO(blog): make it plugable.
+        }
+}
+
+// Log creates a proto binary log entry, and logs it to the sink.
+func (ml *MethodLogger) Log(c LogEntryConfig) {
+        m := c.toProto()
+        timestamp, _ := ptypes.TimestampProto(time.Now())
+        m.Timestamp = timestamp
+        m.CallId = ml.callID
+        m.SequenceIdWithinCall = ml.idWithinCallGen.next()
+
+        switch pay := m.Payload.(type) {
+        case *pb.GrpcLogEntry_ClientHeader:
+                m.PayloadTruncated = ml.truncateMetadata(pay.ClientHeader.GetMetadata())
+        case *pb.GrpcLogEntry_ServerHeader:
+                m.PayloadTruncated = ml.truncateMetadata(pay.ServerHeader.GetMetadata())
+        case *pb.GrpcLogEntry_Message:
+                m.PayloadTruncated = ml.truncateMessage(pay.Message)
+        }
+
+        ml.sink.Write(m)
+}
+
+func (ml *MethodLogger) truncateMetadata(mdPb *pb.Metadata) (truncated bool) {
+        if ml.headerMaxLen == maxUInt {
+                return false
+        }
+        var (
+                bytesLimit = ml.headerMaxLen
+                index      int
+        )
+        // At the end of the loop, index will be the first entry where the total
+        // size is greater than the limit:
+        //
+        // len(entry[:index]) <= ml.hdr && len(entry[:index+1]) > ml.hdr.
+        for ; index < len(mdPb.Entry); index++ {
+                entry := mdPb.Entry[index]
+                if entry.Key == "grpc-trace-bin" {
+                        // "grpc-trace-bin" is a special key. It's kept in the log entry,
+                        // but not counted towards the size limit.
+                        continue
+                }
+                currentEntryLen := uint64(len(entry.Value))
+                if currentEntryLen > bytesLimit {
+                        break
+                }
+                bytesLimit -= currentEntryLen
+        }
+        truncated = index < len(mdPb.Entry)
+        mdPb.Entry = mdPb.Entry[:index]
+        return truncated
+}
+
+func (ml *MethodLogger) truncateMessage(msgPb *pb.Message) (truncated bool) {
+        if ml.messageMaxLen == maxUInt {
+                return false
+        }
+        if ml.messageMaxLen >= uint64(len(msgPb.Data)) {
+                return false
+        }
+        msgPb.Data = msgPb.Data[:ml.messageMaxLen]
+        return true
+}
+
+// LogEntryConfig represents the configuration for binary log entry.
+type LogEntryConfig interface {
+        toProto() *pb.GrpcLogEntry
+}
+
+// ClientHeader configs the binary log entry to be a ClientHeader entry.
+type ClientHeader struct {
+        OnClientSide bool
+        Header       metadata.MD
+        MethodName   string
+        Authority    string
+        Timeout      time.Duration
+        // PeerAddr is required only when it's on server side.
+        PeerAddr net.Addr
+}
+
+func (c *ClientHeader) toProto() *pb.GrpcLogEntry {
+        // This function doesn't need to set all the fields (e.g. seq ID). The Log
+        // function will set the fields when necessary.
+        clientHeader := &pb.ClientHeader{
+                Metadata:   mdToMetadataProto(c.Header),
+                MethodName: c.MethodName,
+                Authority:  c.Authority,
+        }
+        if c.Timeout > 0 {
+                clientHeader.Timeout = ptypes.DurationProto(c.Timeout)
+        }
+        ret := &pb.GrpcLogEntry{
+                Type: pb.GrpcLogEntry_EVENT_TYPE_CLIENT_HEADER,
+                Payload: &pb.GrpcLogEntry_ClientHeader{
+                        ClientHeader: clientHeader,
+                },
+        }
+        if c.OnClientSide {
+                ret.Logger = pb.GrpcLogEntry_LOGGER_CLIENT
+        } else {
+                ret.Logger = pb.GrpcLogEntry_LOGGER_SERVER
+        }
+        if c.PeerAddr != nil {
+                ret.Peer = addrToProto(c.PeerAddr)
+        }
+        return ret
+}
+
+// ServerHeader configs the binary log entry to be a ServerHeader entry.
+type ServerHeader struct {
+        OnClientSide bool
+        Header       metadata.MD
+        // PeerAddr is required only when it's on client side.
+        PeerAddr net.Addr
+}
+
+func (c *ServerHeader) toProto() *pb.GrpcLogEntry {
+        ret := &pb.GrpcLogEntry{
+                Type: pb.GrpcLogEntry_EVENT_TYPE_SERVER_HEADER,
+                Payload: &pb.GrpcLogEntry_ServerHeader{
+                        ServerHeader: &pb.ServerHeader{
+                                Metadata: mdToMetadataProto(c.Header),
+                        },
+                },
+        }
+        if c.OnClientSide {
+                ret.Logger = pb.GrpcLogEntry_LOGGER_CLIENT
+        } else {
+                ret.Logger = pb.GrpcLogEntry_LOGGER_SERVER
+        }
+        if c.PeerAddr != nil {
+                ret.Peer = addrToProto(c.PeerAddr)
+        }
+        return ret
+}
+
+// ClientMessage configs the binary log entry to be a ClientMessage entry.
+type ClientMessage struct {
+        OnClientSide bool
+        // Message can be a proto.Message or []byte. Other messages formats are not
+        // supported.
+        Message interface{}
+}
+
+func (c *ClientMessage) toProto() *pb.GrpcLogEntry {
+        var (
+                data []byte
+                err  error
+        )
+        if m, ok := c.Message.(proto.Message); ok {
+                data, err = proto.Marshal(m)
+                if err != nil {
+                        grpclog.Infof("binarylogging: failed to marshal proto message: %v", err)
+                }
+        } else if b, ok := c.Message.([]byte); ok {
+                data = b
+        } else {
+                grpclog.Infof("binarylogging: message to log is neither proto.message nor []byte")
+        }
+        ret := &pb.GrpcLogEntry{
+                Type: pb.GrpcLogEntry_EVENT_TYPE_CLIENT_MESSAGE,
+                Payload: &pb.GrpcLogEntry_Message{
+                        Message: &pb.Message{
+                                Length: uint32(len(data)),
+                                Data:   data,
+                        },
+                },
+        }
+        if c.OnClientSide {
+                ret.Logger = pb.GrpcLogEntry_LOGGER_CLIENT
+        } else {
+                ret.Logger = pb.GrpcLogEntry_LOGGER_SERVER
+        }
+        return ret
+}
+
+// ServerMessage configs the binary log entry to be a ServerMessage entry.
+type ServerMessage struct {
+        OnClientSide bool
+        // Message can be a proto.Message or []byte. Other messages formats are not
+        // supported.
+        Message interface{}
+}
+
+func (c *ServerMessage) toProto() *pb.GrpcLogEntry {
+        var (
+                data []byte
+                err  error
+        )
+        if m, ok := c.Message.(proto.Message); ok {
+                data, err = proto.Marshal(m)
+                if err != nil {
+                        grpclog.Infof("binarylogging: failed to marshal proto message: %v", err)
+                }
+        } else if b, ok := c.Message.([]byte); ok {
+                data = b
+        } else {
+                grpclog.Infof("binarylogging: message to log is neither proto.message nor []byte")
+        }
+        ret := &pb.GrpcLogEntry{
+                Type: pb.GrpcLogEntry_EVENT_TYPE_SERVER_MESSAGE,
+                Payload: &pb.GrpcLogEntry_Message{
+                        Message: &pb.Message{
+                                Length: uint32(len(data)),
+                                Data:   data,
+                        },
+                },
+        }
+        if c.OnClientSide {
+                ret.Logger = pb.GrpcLogEntry_LOGGER_CLIENT
+        } else {
+                ret.Logger = pb.GrpcLogEntry_LOGGER_SERVER
+        }
+        return ret
+}
+
+// ClientHalfClose configs the binary log entry to be a ClientHalfClose entry.
+type ClientHalfClose struct {
+        OnClientSide bool
+}
+
+func (c *ClientHalfClose) toProto() *pb.GrpcLogEntry {
+        ret := &pb.GrpcLogEntry{
+                Type:    pb.GrpcLogEntry_EVENT_TYPE_CLIENT_HALF_CLOSE,
+                Payload: nil, // No payload here.
+        }
+        if c.OnClientSide {
+                ret.Logger = pb.GrpcLogEntry_LOGGER_CLIENT
+        } else {
+                ret.Logger = pb.GrpcLogEntry_LOGGER_SERVER
+        }
+        return ret
+}
+
+// ServerTrailer configs the binary log entry to be a ServerTrailer entry.
+type ServerTrailer struct {
+        OnClientSide bool
+        Trailer      metadata.MD
+        // Err is the status error.
+        Err error
+        // PeerAddr is required only when it's on client side and the RPC is trailer
+        // only.
+        PeerAddr net.Addr
+}
+
+func (c *ServerTrailer) toProto() *pb.GrpcLogEntry {
+        st, ok := status.FromError(c.Err)
+        if !ok {
+                grpclog.Info("binarylogging: error in trailer is not a status error")
+        }
+        var (
+                detailsBytes []byte
+                err          error
+        )
+        stProto := st.Proto()
+        if stProto != nil && len(stProto.Details) != 0 {
+                detailsBytes, err = proto.Marshal(stProto)
+                if err != nil {
+                        grpclog.Infof("binarylogging: failed to marshal status proto: %v", err)
+                }
+        }
+        ret := &pb.GrpcLogEntry{
+                Type: pb.GrpcLogEntry_EVENT_TYPE_SERVER_TRAILER,
+                Payload: &pb.GrpcLogEntry_Trailer{
+                        Trailer: &pb.Trailer{
+                                Metadata:      mdToMetadataProto(c.Trailer),
+                                StatusCode:    uint32(st.Code()),
+                                StatusMessage: st.Message(),
+                                StatusDetails: detailsBytes,
+                        },
+                },
+        }
+        if c.OnClientSide {
+                ret.Logger = pb.GrpcLogEntry_LOGGER_CLIENT
+        } else {
+                ret.Logger = pb.GrpcLogEntry_LOGGER_SERVER
+        }
+        if c.PeerAddr != nil {
+                ret.Peer = addrToProto(c.PeerAddr)
+        }
+        return ret
+}
+
+// Cancel configs the binary log entry to be a Cancel entry.
+type Cancel struct {
+        OnClientSide bool
+}
+
+func (c *Cancel) toProto() *pb.GrpcLogEntry {
+        ret := &pb.GrpcLogEntry{
+                Type:    pb.GrpcLogEntry_EVENT_TYPE_CANCEL,
+                Payload: nil,
+        }
+        if c.OnClientSide {
+                ret.Logger = pb.GrpcLogEntry_LOGGER_CLIENT
+        } else {
+                ret.Logger = pb.GrpcLogEntry_LOGGER_SERVER
+        }
+        return ret
+}
+
+// metadataKeyOmit returns whether the metadata entry with this key should be
+// omitted.
+func metadataKeyOmit(key string) bool {
+        switch key {
+        case "lb-token", ":path", ":authority", "content-encoding", "content-type", "user-agent", "te":
+                return true
+        case "grpc-trace-bin": // grpc-trace-bin is special because it's visiable to users.
+                return false
+        }
+        if strings.HasPrefix(key, "grpc-") {
+                return true
+        }
+        return false
+}
+
+func mdToMetadataProto(md metadata.MD) *pb.Metadata {
+        ret := &pb.Metadata{}
+        for k, vv := range md {
+                if metadataKeyOmit(k) {
+                        continue
+                }
+                for _, v := range vv {
+                        ret.Entry = append(ret.Entry,
+                                &pb.MetadataEntry{
+                                        Key:   k,
+                                        Value: []byte(v),
+                                },
+                        )
+                }
+        }
+        return ret
+}
+
+func addrToProto(addr net.Addr) *pb.Address {
+        ret := &pb.Address{}
+        switch a := addr.(type) {
+        case *net.TCPAddr:
+                if a.IP.To4() != nil {
+                        ret.Type = pb.Address_TYPE_IPV4
+                } else if a.IP.To16() != nil {
+                        ret.Type = pb.Address_TYPE_IPV6
+                } else {
+                        ret.Type = pb.Address_TYPE_UNKNOWN
+                        // Do not set address and port fields.
+                        break
+                }
+                ret.Address = a.IP.String()
+                ret.IpPort = uint32(a.Port)
+        case *net.UnixAddr:
+                ret.Type = pb.Address_TYPE_UNIX
+                ret.Address = a.String()
+        default:
+                ret.Type = pb.Address_TYPE_UNKNOWN
+        }
+        return ret
+}
diff --git a/vendor/google.golang.org/grpc/internal/binarylog/regenerate.sh b/vendor/google.golang.org/grpc/internal/binarylog/regenerate.sh
new file mode 100644
index 0000000..113d40c
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/binarylog/regenerate.sh
@@ -0,0 +1,33 @@
+#!/bin/bash
+# Copyright 2018 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set -eux -o pipefail
+
+TMP=$(mktemp -d)
+
+function finish {
+  rm -rf "$TMP"
+}
+trap finish EXIT
+
+pushd "$TMP"
+mkdir -p grpc/binarylog/grpc_binarylog_v1
+curl https://raw.githubusercontent.com/grpc/grpc-proto/master/grpc/binlog/v1/binarylog.proto > grpc/binarylog/grpc_binarylog_v1/binarylog.proto
+
+protoc --go_out=plugins=grpc,paths=source_relative:. -I. grpc/binarylog/grpc_binarylog_v1/*.proto
+popd
+rm -f ./grpc_binarylog_v1/*.pb.go
+cp "$TMP"/grpc/binarylog/grpc_binarylog_v1/*.pb.go ../../binarylog/grpc_binarylog_v1/
+
diff --git a/vendor/google.golang.org/grpc/internal/binarylog/sink.go b/vendor/google.golang.org/grpc/internal/binarylog/sink.go
new file mode 100644
index 0000000..20d044f
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/binarylog/sink.go
@@ -0,0 +1,162 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package binarylog
+
+import (
+        "bufio"
+        "encoding/binary"
+        "fmt"
+        "io"
+        "io/ioutil"
+        "sync"
+        "time"
+
+        "github.com/golang/protobuf/proto"
+        pb "google.golang.org/grpc/binarylog/grpc_binarylog_v1"
+        "google.golang.org/grpc/grpclog"
+)
+
+var (
+        defaultSink Sink = &noopSink{} // TODO(blog): change this default (file in /tmp).
+)
+
+// SetDefaultSink sets the sink where binary logs will be written to.
+//
+// Not thread safe. Only set during initialization.
+func SetDefaultSink(s Sink) {
+        if defaultSink != nil {
+                defaultSink.Close()
+        }
+        defaultSink = s
+}
+
+// Sink writes log entry into the binary log sink.
+type Sink interface {
+        // Write will be called to write the log entry into the sink.
+        //
+        // It should be thread-safe so it can be called in parallel.
+        Write(*pb.GrpcLogEntry) error
+        // Close will be called when the Sink is replaced by a new Sink.
+        Close() error
+}
+
+type noopSink struct{}
+
+func (ns *noopSink) Write(*pb.GrpcLogEntry) error { return nil }
+func (ns *noopSink) Close() error                 { return nil }
+
+// newWriterSink creates a binary log sink with the given writer.
+//
+// Write() marshalls the proto message and writes it to the given writer. Each
+// message is prefixed with a 4 byte big endian unsigned integer as the length.
+//
+// No buffer is done, Close() doesn't try to close the writer.
+func newWriterSink(w io.Writer) *writerSink {
+        return &writerSink{out: w}
+}
+
+type writerSink struct {
+        out io.Writer
+}
+
+func (ws *writerSink) Write(e *pb.GrpcLogEntry) error {
+        b, err := proto.Marshal(e)
+        if err != nil {
+                grpclog.Infof("binary logging: failed to marshal proto message: %v", err)
+        }
+        hdr := make([]byte, 4)
+        binary.BigEndian.PutUint32(hdr, uint32(len(b)))
+        if _, err := ws.out.Write(hdr); err != nil {
+                return err
+        }
+        if _, err := ws.out.Write(b); err != nil {
+                return err
+        }
+        return nil
+}
+
+func (ws *writerSink) Close() error { return nil }
+
+type bufWriteCloserSink struct {
+        mu     sync.Mutex
+        closer io.Closer
+        out    *writerSink   // out is built on buf.
+        buf    *bufio.Writer // buf is kept for flush.
+
+        writeStartOnce sync.Once
+        writeTicker    *time.Ticker
+}
+
+func (fs *bufWriteCloserSink) Write(e *pb.GrpcLogEntry) error {
+        // Start the write loop when Write is called.
+        fs.writeStartOnce.Do(fs.startFlushGoroutine)
+        fs.mu.Lock()
+        if err := fs.out.Write(e); err != nil {
+                fs.mu.Unlock()
+                return err
+        }
+        fs.mu.Unlock()
+        return nil
+}
+
+const (
+        bufFlushDuration = 60 * time.Second
+)
+
+func (fs *bufWriteCloserSink) startFlushGoroutine() {
+        fs.writeTicker = time.NewTicker(bufFlushDuration)
+        go func() {
+                for range fs.writeTicker.C {
+                        fs.mu.Lock()
+                        fs.buf.Flush()
+                        fs.mu.Unlock()
+                }
+        }()
+}
+
+func (fs *bufWriteCloserSink) Close() error {
+        if fs.writeTicker != nil {
+                fs.writeTicker.Stop()
+        }
+        fs.mu.Lock()
+        fs.buf.Flush()
+        fs.closer.Close()
+        fs.out.Close()
+        fs.mu.Unlock()
+        return nil
+}
+
+func newBufWriteCloserSink(o io.WriteCloser) Sink {
+        bufW := bufio.NewWriter(o)
+        return &bufWriteCloserSink{
+                closer: o,
+                out:    newWriterSink(bufW),
+                buf:    bufW,
+        }
+}
+
+// NewTempFileSink creates a temp file and returns a Sink that writes to this
+// file.
+func NewTempFileSink() (Sink, error) {
+        tempFile, err := ioutil.TempFile("/tmp", "grpcgo_binarylog_*.txt")
+        if err != nil {
+                return nil, fmt.Errorf("failed to create temp file: %v", err)
+        }
+        return newBufWriteCloserSink(tempFile), nil
+}
diff --git a/vendor/google.golang.org/grpc/internal/binarylog/util.go b/vendor/google.golang.org/grpc/internal/binarylog/util.go
new file mode 100644
index 0000000..15dc780
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/binarylog/util.go
@@ -0,0 +1,41 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package binarylog
+
+import (
+        "errors"
+        "strings"
+)
+
+// parseMethodName splits service and method from the input. It expects format
+// "/service/method".
+//
+// TODO: move to internal/grpcutil.
+func parseMethodName(methodName string) (service, method string, _ error) {
+        if !strings.HasPrefix(methodName, "/") {
+                return "", "", errors.New("invalid method name: should start with /")
+        }
+        methodName = methodName[1:]
+
+        pos := strings.LastIndex(methodName, "/")
+        if pos < 0 {
+                return "", "", errors.New("invalid method name: suffix /method is missing")
+        }
+        return methodName[:pos], methodName[pos+1:], nil
+}
diff --git a/vendor/google.golang.org/grpc/internal/channelz/funcs.go b/vendor/google.golang.org/grpc/internal/channelz/funcs.go
new file mode 100644
index 0000000..041520d
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/channelz/funcs.go
@@ -0,0 +1,699 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package channelz defines APIs for enabling channelz service, entry
+// registration/deletion, and accessing channelz data. It also defines channelz
+// metric struct formats.
+//
+// All APIs in this package are experimental.
+package channelz
+
+import (
+        "sort"
+        "sync"
+        "sync/atomic"
+        "time"
+
+        "google.golang.org/grpc/grpclog"
+)
+
+const (
+        defaultMaxTraceEntry int32 = 30
+)
+
+var (
+        db    dbWrapper
+        idGen idGenerator
+        // EntryPerPage defines the number of channelz entries to be shown on a web page.
+        EntryPerPage  = int64(50)
+        curState      int32
+        maxTraceEntry = defaultMaxTraceEntry
+)
+
+// TurnOn turns on channelz data collection.
+func TurnOn() {
+        if !IsOn() {
+                NewChannelzStorage()
+                atomic.StoreInt32(&curState, 1)
+        }
+}
+
+// IsOn returns whether channelz data collection is on.
+func IsOn() bool {
+        return atomic.CompareAndSwapInt32(&curState, 1, 1)
+}
+
+// SetMaxTraceEntry sets maximum number of trace entry per entity (i.e. channel/subchannel).
+// Setting it to 0 will disable channel tracing.
+func SetMaxTraceEntry(i int32) {
+        atomic.StoreInt32(&maxTraceEntry, i)
+}
+
+// ResetMaxTraceEntryToDefault resets the maximum number of trace entry per entity to default.
+func ResetMaxTraceEntryToDefault() {
+        atomic.StoreInt32(&maxTraceEntry, defaultMaxTraceEntry)
+}
+
+func getMaxTraceEntry() int {
+        i := atomic.LoadInt32(&maxTraceEntry)
+        return int(i)
+}
+
+// dbWarpper wraps around a reference to internal channelz data storage, and
+// provide synchronized functionality to set and get the reference.
+type dbWrapper struct {
+        mu sync.RWMutex
+        DB *channelMap
+}
+
+func (d *dbWrapper) set(db *channelMap) {
+        d.mu.Lock()
+        d.DB = db
+        d.mu.Unlock()
+}
+
+func (d *dbWrapper) get() *channelMap {
+        d.mu.RLock()
+        defer d.mu.RUnlock()
+        return d.DB
+}
+
+// NewChannelzStorage initializes channelz data storage and id generator.
+//
+// Note: This function is exported for testing purpose only. User should not call
+// it in most cases.
+func NewChannelzStorage() {
+        db.set(&channelMap{
+                topLevelChannels: make(map[int64]struct{}),
+                channels:         make(map[int64]*channel),
+                listenSockets:    make(map[int64]*listenSocket),
+                normalSockets:    make(map[int64]*normalSocket),
+                servers:          make(map[int64]*server),
+                subChannels:      make(map[int64]*subChannel),
+        })
+        idGen.reset()
+}
+
+// GetTopChannels returns a slice of top channel's ChannelMetric, along with a
+// boolean indicating whether there's more top channels to be queried for.
+//
+// The arg id specifies that only top channel with id at or above it will be included
+// in the result. The returned slice is up to a length of the arg maxResults or
+// EntryPerPage if maxResults is zero, and is sorted in ascending id order.
+func GetTopChannels(id int64, maxResults int64) ([]*ChannelMetric, bool) {
+        return db.get().GetTopChannels(id, maxResults)
+}
+
+// GetServers returns a slice of server's ServerMetric, along with a
+// boolean indicating whether there's more servers to be queried for.
+//
+// The arg id specifies that only server with id at or above it will be included
+// in the result. The returned slice is up to a length of the arg maxResults or
+// EntryPerPage if maxResults is zero, and is sorted in ascending id order.
+func GetServers(id int64, maxResults int64) ([]*ServerMetric, bool) {
+        return db.get().GetServers(id, maxResults)
+}
+
+// GetServerSockets returns a slice of server's (identified by id) normal socket's
+// SocketMetric, along with a boolean indicating whether there's more sockets to
+// be queried for.
+//
+// The arg startID specifies that only sockets with id at or above it will be
+// included in the result. The returned slice is up to a length of the arg maxResults
+// or EntryPerPage if maxResults is zero, and is sorted in ascending id order.
+func GetServerSockets(id int64, startID int64, maxResults int64) ([]*SocketMetric, bool) {
+        return db.get().GetServerSockets(id, startID, maxResults)
+}
+
+// GetChannel returns the ChannelMetric for the channel (identified by id).
+func GetChannel(id int64) *ChannelMetric {
+        return db.get().GetChannel(id)
+}
+
+// GetSubChannel returns the SubChannelMetric for the subchannel (identified by id).
+func GetSubChannel(id int64) *SubChannelMetric {
+        return db.get().GetSubChannel(id)
+}
+
+// GetSocket returns the SocketInternalMetric for the socket (identified by id).
+func GetSocket(id int64) *SocketMetric {
+        return db.get().GetSocket(id)
+}
+
+// GetServer returns the ServerMetric for the server (identified by id).
+func GetServer(id int64) *ServerMetric {
+        return db.get().GetServer(id)
+}
+
+// RegisterChannel registers the given channel c in channelz database with ref
+// as its reference name, and add it to the child list of its parent (identified
+// by pid). pid = 0 means no parent. It returns the unique channelz tracking id
+// assigned to this channel.
+func RegisterChannel(c Channel, pid int64, ref string) int64 {
+        id := idGen.genID()
+        cn := &channel{
+                refName:     ref,
+                c:           c,
+                subChans:    make(map[int64]string),
+                nestedChans: make(map[int64]string),
+                id:          id,
+                pid:         pid,
+                trace:       &channelTrace{createdTime: time.Now(), events: make([]*TraceEvent, 0, getMaxTraceEntry())},
+        }
+        if pid == 0 {
+                db.get().addChannel(id, cn, true, pid, ref)
+        } else {
+                db.get().addChannel(id, cn, false, pid, ref)
+        }
+        return id
+}
+
+// RegisterSubChannel registers the given channel c in channelz database with ref
+// as its reference name, and add it to the child list of its parent (identified
+// by pid). It returns the unique channelz tracking id assigned to this subchannel.
+func RegisterSubChannel(c Channel, pid int64, ref string) int64 {
+        if pid == 0 {
+                grpclog.Error("a SubChannel's parent id cannot be 0")
+                return 0
+        }
+        id := idGen.genID()
+        sc := &subChannel{
+                refName: ref,
+                c:       c,
+                sockets: make(map[int64]string),
+                id:      id,
+                pid:     pid,
+                trace:   &channelTrace{createdTime: time.Now(), events: make([]*TraceEvent, 0, getMaxTraceEntry())},
+        }
+        db.get().addSubChannel(id, sc, pid, ref)
+        return id
+}
+
+// RegisterServer registers the given server s in channelz database. It returns
+// the unique channelz tracking id assigned to this server.
+func RegisterServer(s Server, ref string) int64 {
+        id := idGen.genID()
+        svr := &server{
+                refName:       ref,
+                s:             s,
+                sockets:       make(map[int64]string),
+                listenSockets: make(map[int64]string),
+                id:            id,
+        }
+        db.get().addServer(id, svr)
+        return id
+}
+
+// RegisterListenSocket registers the given listen socket s in channelz database
+// with ref as its reference name, and add it to the child list of its parent
+// (identified by pid). It returns the unique channelz tracking id assigned to
+// this listen socket.
+func RegisterListenSocket(s Socket, pid int64, ref string) int64 {
+        if pid == 0 {
+                grpclog.Error("a ListenSocket's parent id cannot be 0")
+                return 0
+        }
+        id := idGen.genID()
+        ls := &listenSocket{refName: ref, s: s, id: id, pid: pid}
+        db.get().addListenSocket(id, ls, pid, ref)
+        return id
+}
+
+// RegisterNormalSocket registers the given normal socket s in channelz database
+// with ref as its reference name, and add it to the child list of its parent
+// (identified by pid). It returns the unique channelz tracking id assigned to
+// this normal socket.
+func RegisterNormalSocket(s Socket, pid int64, ref string) int64 {
+        if pid == 0 {
+                grpclog.Error("a NormalSocket's parent id cannot be 0")
+                return 0
+        }
+        id := idGen.genID()
+        ns := &normalSocket{refName: ref, s: s, id: id, pid: pid}
+        db.get().addNormalSocket(id, ns, pid, ref)
+        return id
+}
+
+// RemoveEntry removes an entry with unique channelz trakcing id to be id from
+// channelz database.
+func RemoveEntry(id int64) {
+        db.get().removeEntry(id)
+}
+
+// TraceEventDesc is what the caller of AddTraceEvent should provide to describe the event to be added
+// to the channel trace.
+// The Parent field is optional. It is used for event that will be recorded in the entity's parent
+// trace also.
+type TraceEventDesc struct {
+        Desc     string
+        Severity Severity
+        Parent   *TraceEventDesc
+}
+
+// AddTraceEvent adds trace related to the entity with specified id, using the provided TraceEventDesc.
+func AddTraceEvent(id int64, desc *TraceEventDesc) {
+        if getMaxTraceEntry() == 0 {
+                return
+        }
+        db.get().traceEvent(id, desc)
+}
+
+// channelMap is the storage data structure for channelz.
+// Methods of channelMap can be divided in two two categories with respect to locking.
+// 1. Methods acquire the global lock.
+// 2. Methods that can only be called when global lock is held.
+// A second type of method need always to be called inside a first type of method.
+type channelMap struct {
+        mu               sync.RWMutex
+        topLevelChannels map[int64]struct{}
+        servers          map[int64]*server
+        channels         map[int64]*channel
+        subChannels      map[int64]*subChannel
+        listenSockets    map[int64]*listenSocket
+        normalSockets    map[int64]*normalSocket
+}
+
+func (c *channelMap) addServer(id int64, s *server) {
+        c.mu.Lock()
+        s.cm = c
+        c.servers[id] = s
+        c.mu.Unlock()
+}
+
+func (c *channelMap) addChannel(id int64, cn *channel, isTopChannel bool, pid int64, ref string) {
+        c.mu.Lock()
+        cn.cm = c
+        cn.trace.cm = c
+        c.channels[id] = cn
+        if isTopChannel {
+                c.topLevelChannels[id] = struct{}{}
+        } else {
+                c.findEntry(pid).addChild(id, cn)
+        }
+        c.mu.Unlock()
+}
+
+func (c *channelMap) addSubChannel(id int64, sc *subChannel, pid int64, ref string) {
+        c.mu.Lock()
+        sc.cm = c
+        sc.trace.cm = c
+        c.subChannels[id] = sc
+        c.findEntry(pid).addChild(id, sc)
+        c.mu.Unlock()
+}
+
+func (c *channelMap) addListenSocket(id int64, ls *listenSocket, pid int64, ref string) {
+        c.mu.Lock()
+        ls.cm = c
+        c.listenSockets[id] = ls
+        c.findEntry(pid).addChild(id, ls)
+        c.mu.Unlock()
+}
+
+func (c *channelMap) addNormalSocket(id int64, ns *normalSocket, pid int64, ref string) {
+        c.mu.Lock()
+        ns.cm = c
+        c.normalSockets[id] = ns
+        c.findEntry(pid).addChild(id, ns)
+        c.mu.Unlock()
+}
+
+// removeEntry triggers the removal of an entry, which may not indeed delete the entry, if it has to
+// wait on the deletion of its children and until no other entity's channel trace references it.
+// It may lead to a chain of entry deletion. For example, deleting the last socket of a gracefully
+// shutting down server will lead to the server being also deleted.
+func (c *channelMap) removeEntry(id int64) {
+        c.mu.Lock()
+        c.findEntry(id).triggerDelete()
+        c.mu.Unlock()
+}
+
+// c.mu must be held by the caller
+func (c *channelMap) decrTraceRefCount(id int64) {
+        e := c.findEntry(id)
+        if v, ok := e.(tracedChannel); ok {
+                v.decrTraceRefCount()
+                e.deleteSelfIfReady()
+        }
+}
+
+// c.mu must be held by the caller.
+func (c *channelMap) findEntry(id int64) entry {
+        var v entry
+        var ok bool
+        if v, ok = c.channels[id]; ok {
+                return v
+        }
+        if v, ok = c.subChannels[id]; ok {
+                return v
+        }
+        if v, ok = c.servers[id]; ok {
+                return v
+        }
+        if v, ok = c.listenSockets[id]; ok {
+                return v
+        }
+        if v, ok = c.normalSockets[id]; ok {
+                return v
+        }
+        return &dummyEntry{idNotFound: id}
+}
+
+// c.mu must be held by the caller
+// deleteEntry simply deletes an entry from the channelMap. Before calling this
+// method, caller must check this entry is ready to be deleted, i.e removeEntry()
+// has been called on it, and no children still exist.
+// Conditionals are ordered by the expected frequency of deletion of each entity
+// type, in order to optimize performance.
+func (c *channelMap) deleteEntry(id int64) {
+        var ok bool
+        if _, ok = c.normalSockets[id]; ok {
+                delete(c.normalSockets, id)
+                return
+        }
+        if _, ok = c.subChannels[id]; ok {
+                delete(c.subChannels, id)
+                return
+        }
+        if _, ok = c.channels[id]; ok {
+                delete(c.channels, id)
+                delete(c.topLevelChannels, id)
+                return
+        }
+        if _, ok = c.listenSockets[id]; ok {
+                delete(c.listenSockets, id)
+                return
+        }
+        if _, ok = c.servers[id]; ok {
+                delete(c.servers, id)
+                return
+        }
+}
+
+func (c *channelMap) traceEvent(id int64, desc *TraceEventDesc) {
+        c.mu.Lock()
+        child := c.findEntry(id)
+        childTC, ok := child.(tracedChannel)
+        if !ok {
+                c.mu.Unlock()
+                return
+        }
+        childTC.getChannelTrace().append(&TraceEvent{Desc: desc.Desc, Severity: desc.Severity, Timestamp: time.Now()})
+        if desc.Parent != nil {
+                parent := c.findEntry(child.getParentID())
+                var chanType RefChannelType
+                switch child.(type) {
+                case *channel:
+                        chanType = RefChannel
+                case *subChannel:
+                        chanType = RefSubChannel
+                }
+                if parentTC, ok := parent.(tracedChannel); ok {
+                        parentTC.getChannelTrace().append(&TraceEvent{
+                                Desc:      desc.Parent.Desc,
+                                Severity:  desc.Parent.Severity,
+                                Timestamp: time.Now(),
+                                RefID:     id,
+                                RefName:   childTC.getRefName(),
+                                RefType:   chanType,
+                        })
+                        childTC.incrTraceRefCount()
+                }
+        }
+        c.mu.Unlock()
+}
+
+type int64Slice []int64
+
+func (s int64Slice) Len() int           { return len(s) }
+func (s int64Slice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s int64Slice) Less(i, j int) bool { return s[i] < s[j] }
+
+func copyMap(m map[int64]string) map[int64]string {
+        n := make(map[int64]string)
+        for k, v := range m {
+                n[k] = v
+        }
+        return n
+}
+
+func min(a, b int64) int64 {
+        if a < b {
+                return a
+        }
+        return b
+}
+
+func (c *channelMap) GetTopChannels(id int64, maxResults int64) ([]*ChannelMetric, bool) {
+        if maxResults <= 0 {
+                maxResults = EntryPerPage
+        }
+        c.mu.RLock()
+        l := int64(len(c.topLevelChannels))
+        ids := make([]int64, 0, l)
+        cns := make([]*channel, 0, min(l, maxResults))
+
+        for k := range c.topLevelChannels {
+                ids = append(ids, k)
+        }
+        sort.Sort(int64Slice(ids))
+        idx := sort.Search(len(ids), func(i int) bool { return ids[i] >= id })
+        count := int64(0)
+        var end bool
+        var t []*ChannelMetric
+        for i, v := range ids[idx:] {
+                if count == maxResults {
+                        break
+                }
+                if cn, ok := c.channels[v]; ok {
+                        cns = append(cns, cn)
+                        t = append(t, &ChannelMetric{
+                                NestedChans: copyMap(cn.nestedChans),
+                                SubChans:    copyMap(cn.subChans),
+                        })
+                        count++
+                }
+                if i == len(ids[idx:])-1 {
+                        end = true
+                        break
+                }
+        }
+        c.mu.RUnlock()
+        if count == 0 {
+                end = true
+        }
+
+        for i, cn := range cns {
+                t[i].ChannelData = cn.c.ChannelzMetric()
+                t[i].ID = cn.id
+                t[i].RefName = cn.refName
+                t[i].Trace = cn.trace.dumpData()
+        }
+        return t, end
+}
+
+func (c *channelMap) GetServers(id, maxResults int64) ([]*ServerMetric, bool) {
+        if maxResults <= 0 {
+                maxResults = EntryPerPage
+        }
+        c.mu.RLock()
+        l := int64(len(c.servers))
+        ids := make([]int64, 0, l)
+        ss := make([]*server, 0, min(l, maxResults))
+        for k := range c.servers {
+                ids = append(ids, k)
+        }
+        sort.Sort(int64Slice(ids))
+        idx := sort.Search(len(ids), func(i int) bool { return ids[i] >= id })
+        count := int64(0)
+        var end bool
+        var s []*ServerMetric
+        for i, v := range ids[idx:] {
+                if count == maxResults {
+                        break
+                }
+                if svr, ok := c.servers[v]; ok {
+                        ss = append(ss, svr)
+                        s = append(s, &ServerMetric{
+                                ListenSockets: copyMap(svr.listenSockets),
+                        })
+                        count++
+                }
+                if i == len(ids[idx:])-1 {
+                        end = true
+                        break
+                }
+        }
+        c.mu.RUnlock()
+        if count == 0 {
+                end = true
+        }
+
+        for i, svr := range ss {
+                s[i].ServerData = svr.s.ChannelzMetric()
+                s[i].ID = svr.id
+                s[i].RefName = svr.refName
+        }
+        return s, end
+}
+
+func (c *channelMap) GetServerSockets(id int64, startID int64, maxResults int64) ([]*SocketMetric, bool) {
+        if maxResults <= 0 {
+                maxResults = EntryPerPage
+        }
+        var svr *server
+        var ok bool
+        c.mu.RLock()
+        if svr, ok = c.servers[id]; !ok {
+                // server with id doesn't exist.
+                c.mu.RUnlock()
+                return nil, true
+        }
+        svrskts := svr.sockets
+        l := int64(len(svrskts))
+        ids := make([]int64, 0, l)
+        sks := make([]*normalSocket, 0, min(l, maxResults))
+        for k := range svrskts {
+                ids = append(ids, k)
+        }
+        sort.Sort(int64Slice(ids))
+        idx := sort.Search(len(ids), func(i int) bool { return ids[i] >= startID })
+        count := int64(0)
+        var end bool
+        for i, v := range ids[idx:] {
+                if count == maxResults {
+                        break
+                }
+                if ns, ok := c.normalSockets[v]; ok {
+                        sks = append(sks, ns)
+                        count++
+                }
+                if i == len(ids[idx:])-1 {
+                        end = true
+                        break
+                }
+        }
+        c.mu.RUnlock()
+        if count == 0 {
+                end = true
+        }
+        var s []*SocketMetric
+        for _, ns := range sks {
+                sm := &SocketMetric{}
+                sm.SocketData = ns.s.ChannelzMetric()
+                sm.ID = ns.id
+                sm.RefName = ns.refName
+                s = append(s, sm)
+        }
+        return s, end
+}
+
+func (c *channelMap) GetChannel(id int64) *ChannelMetric {
+        cm := &ChannelMetric{}
+        var cn *channel
+        var ok bool
+        c.mu.RLock()
+        if cn, ok = c.channels[id]; !ok {
+                // channel with id doesn't exist.
+                c.mu.RUnlock()
+                return nil
+        }
+        cm.NestedChans = copyMap(cn.nestedChans)
+        cm.SubChans = copyMap(cn.subChans)
+        // cn.c can be set to &dummyChannel{} when deleteSelfFromMap is called. Save a copy of cn.c when
+        // holding the lock to prevent potential data race.
+        chanCopy := cn.c
+        c.mu.RUnlock()
+        cm.ChannelData = chanCopy.ChannelzMetric()
+        cm.ID = cn.id
+        cm.RefName = cn.refName
+        cm.Trace = cn.trace.dumpData()
+        return cm
+}
+
+func (c *channelMap) GetSubChannel(id int64) *SubChannelMetric {
+        cm := &SubChannelMetric{}
+        var sc *subChannel
+        var ok bool
+        c.mu.RLock()
+        if sc, ok = c.subChannels[id]; !ok {
+                // subchannel with id doesn't exist.
+                c.mu.RUnlock()
+                return nil
+        }
+        cm.Sockets = copyMap(sc.sockets)
+        // sc.c can be set to &dummyChannel{} when deleteSelfFromMap is called. Save a copy of sc.c when
+        // holding the lock to prevent potential data race.
+        chanCopy := sc.c
+        c.mu.RUnlock()
+        cm.ChannelData = chanCopy.ChannelzMetric()
+        cm.ID = sc.id
+        cm.RefName = sc.refName
+        cm.Trace = sc.trace.dumpData()
+        return cm
+}
+
+func (c *channelMap) GetSocket(id int64) *SocketMetric {
+        sm := &SocketMetric{}
+        c.mu.RLock()
+        if ls, ok := c.listenSockets[id]; ok {
+                c.mu.RUnlock()
+                sm.SocketData = ls.s.ChannelzMetric()
+                sm.ID = ls.id
+                sm.RefName = ls.refName
+                return sm
+        }
+        if ns, ok := c.normalSockets[id]; ok {
+                c.mu.RUnlock()
+                sm.SocketData = ns.s.ChannelzMetric()
+                sm.ID = ns.id
+                sm.RefName = ns.refName
+                return sm
+        }
+        c.mu.RUnlock()
+        return nil
+}
+
+func (c *channelMap) GetServer(id int64) *ServerMetric {
+        sm := &ServerMetric{}
+        var svr *server
+        var ok bool
+        c.mu.RLock()
+        if svr, ok = c.servers[id]; !ok {
+                c.mu.RUnlock()
+                return nil
+        }
+        sm.ListenSockets = copyMap(svr.listenSockets)
+        c.mu.RUnlock()
+        sm.ID = svr.id
+        sm.RefName = svr.refName
+        sm.ServerData = svr.s.ChannelzMetric()
+        return sm
+}
+
+type idGenerator struct {
+        id int64
+}
+
+func (i *idGenerator) reset() {
+        atomic.StoreInt64(&i.id, 0)
+}
+
+func (i *idGenerator) genID() int64 {
+        return atomic.AddInt64(&i.id, 1)
+}
diff --git a/vendor/google.golang.org/grpc/internal/channelz/types.go b/vendor/google.golang.org/grpc/internal/channelz/types.go
new file mode 100644
index 0000000..17c2274
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/channelz/types.go
@@ -0,0 +1,702 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package channelz
+
+import (
+        "net"
+        "sync"
+        "sync/atomic"
+        "time"
+
+        "google.golang.org/grpc/connectivity"
+        "google.golang.org/grpc/credentials"
+        "google.golang.org/grpc/grpclog"
+)
+
+// entry represents a node in the channelz database.
+type entry interface {
+        // addChild adds a child e, whose channelz id is id to child list
+        addChild(id int64, e entry)
+        // deleteChild deletes a child with channelz id to be id from child list
+        deleteChild(id int64)
+        // triggerDelete tries to delete self from channelz database. However, if child
+        // list is not empty, then deletion from the database is on hold until the last
+        // child is deleted from database.
+        triggerDelete()
+        // deleteSelfIfReady check whether triggerDelete() has been called before, and whether child
+        // list is now empty. If both conditions are met, then delete self from database.
+        deleteSelfIfReady()
+        // getParentID returns parent ID of the entry. 0 value parent ID means no parent.
+        getParentID() int64
+}
+
+// dummyEntry is a fake entry to handle entry not found case.
+type dummyEntry struct {
+        idNotFound int64
+}
+
+func (d *dummyEntry) addChild(id int64, e entry) {
+        // Note: It is possible for a normal program to reach here under race condition.
+        // For example, there could be a race between ClientConn.Close() info being propagated
+        // to addrConn and http2Client. ClientConn.Close() cancel the context and result
+        // in http2Client to error. The error info is then caught by transport monitor
+        // and before addrConn.tearDown() is called in side ClientConn.Close(). Therefore,
+        // the addrConn will create a new transport. And when registering the new transport in
+        // channelz, its parent addrConn could have already been torn down and deleted
+        // from channelz tracking, and thus reach the code here.
+        grpclog.Infof("attempt to add child of type %T with id %d to a parent (id=%d) that doesn't currently exist", e, id, d.idNotFound)
+}
+
+func (d *dummyEntry) deleteChild(id int64) {
+        // It is possible for a normal program to reach here under race condition.
+        // Refer to the example described in addChild().
+        grpclog.Infof("attempt to delete child with id %d from a parent (id=%d) that doesn't currently exist", id, d.idNotFound)
+}
+
+func (d *dummyEntry) triggerDelete() {
+        grpclog.Warningf("attempt to delete an entry (id=%d) that doesn't currently exist", d.idNotFound)
+}
+
+func (*dummyEntry) deleteSelfIfReady() {
+        // code should not reach here. deleteSelfIfReady is always called on an existing entry.
+}
+
+func (*dummyEntry) getParentID() int64 {
+        return 0
+}
+
+// ChannelMetric defines the info channelz provides for a specific Channel, which
+// includes ChannelInternalMetric and channelz-specific data, such as channelz id,
+// child list, etc.
+type ChannelMetric struct {
+        // ID is the channelz id of this channel.
+        ID int64
+        // RefName is the human readable reference string of this channel.
+        RefName string
+        // ChannelData contains channel internal metric reported by the channel through
+        // ChannelzMetric().
+        ChannelData *ChannelInternalMetric
+        // NestedChans tracks the nested channel type children of this channel in the format of
+        // a map from nested channel channelz id to corresponding reference string.
+        NestedChans map[int64]string
+        // SubChans tracks the subchannel type children of this channel in the format of a
+        // map from subchannel channelz id to corresponding reference string.
+        SubChans map[int64]string
+        // Sockets tracks the socket type children of this channel in the format of a map
+        // from socket channelz id to corresponding reference string.
+        // Note current grpc implementation doesn't allow channel having sockets directly,
+        // therefore, this is field is unused.
+        Sockets map[int64]string
+        // Trace contains the most recent traced events.
+        Trace *ChannelTrace
+}
+
+// SubChannelMetric defines the info channelz provides for a specific SubChannel,
+// which includes ChannelInternalMetric and channelz-specific data, such as
+// channelz id, child list, etc.
+type SubChannelMetric struct {
+        // ID is the channelz id of this subchannel.
+        ID int64
+        // RefName is the human readable reference string of this subchannel.
+        RefName string
+        // ChannelData contains subchannel internal metric reported by the subchannel
+        // through ChannelzMetric().
+        ChannelData *ChannelInternalMetric
+        // NestedChans tracks the nested channel type children of this subchannel in the format of
+        // a map from nested channel channelz id to corresponding reference string.
+        // Note current grpc implementation doesn't allow subchannel to have nested channels
+        // as children, therefore, this field is unused.
+        NestedChans map[int64]string
+        // SubChans tracks the subchannel type children of this subchannel in the format of a
+        // map from subchannel channelz id to corresponding reference string.
+        // Note current grpc implementation doesn't allow subchannel to have subchannels
+        // as children, therefore, this field is unused.
+        SubChans map[int64]string
+        // Sockets tracks the socket type children of this subchannel in the format of a map
+        // from socket channelz id to corresponding reference string.
+        Sockets map[int64]string
+        // Trace contains the most recent traced events.
+        Trace *ChannelTrace
+}
+
+// ChannelInternalMetric defines the struct that the implementor of Channel interface
+// should return from ChannelzMetric().
+type ChannelInternalMetric struct {
+        // current connectivity state of the channel.
+        State connectivity.State
+        // The target this channel originally tried to connect to.  May be absent
+        Target string
+        // The number of calls started on the channel.
+        CallsStarted int64
+        // The number of calls that have completed with an OK status.
+        CallsSucceeded int64
+        // The number of calls that have a completed with a non-OK status.
+        CallsFailed int64
+        // The last time a call was started on the channel.
+        LastCallStartedTimestamp time.Time
+}
+
+// ChannelTrace stores traced events on a channel/subchannel and related info.
+type ChannelTrace struct {
+        // EventNum is the number of events that ever got traced (i.e. including those that have been deleted)
+        EventNum int64
+        // CreationTime is the creation time of the trace.
+        CreationTime time.Time
+        // Events stores the most recent trace events (up to $maxTraceEntry, newer event will overwrite the
+        // oldest one)
+        Events []*TraceEvent
+}
+
+// TraceEvent represent a single trace event
+type TraceEvent struct {
+        // Desc is a simple description of the trace event.
+        Desc string
+        // Severity states the severity of this trace event.
+        Severity Severity
+        // Timestamp is the event time.
+        Timestamp time.Time
+        // RefID is the id of the entity that gets referenced in the event. RefID is 0 if no other entity is
+        // involved in this event.
+        // e.g. SubChannel (id: 4[]) Created. --> RefID = 4, RefName = "" (inside [])
+        RefID int64
+        // RefName is the reference name for the entity that gets referenced in the event.
+        RefName string
+        // RefType indicates the referenced entity type, i.e Channel or SubChannel.
+        RefType RefChannelType
+}
+
+// Channel is the interface that should be satisfied in order to be tracked by
+// channelz as Channel or SubChannel.
+type Channel interface {
+        ChannelzMetric() *ChannelInternalMetric
+}
+
+type dummyChannel struct{}
+
+func (d *dummyChannel) ChannelzMetric() *ChannelInternalMetric {
+        return &ChannelInternalMetric{}
+}
+
+type channel struct {
+        refName     string
+        c           Channel
+        closeCalled bool
+        nestedChans map[int64]string
+        subChans    map[int64]string
+        id          int64
+        pid         int64
+        cm          *channelMap
+        trace       *channelTrace
+        // traceRefCount is the number of trace events that reference this channel.
+        // Non-zero traceRefCount means the trace of this channel cannot be deleted.
+        traceRefCount int32
+}
+
+func (c *channel) addChild(id int64, e entry) {
+        switch v := e.(type) {
+        case *subChannel:
+                c.subChans[id] = v.refName
+        case *channel:
+                c.nestedChans[id] = v.refName
+        default:
+                grpclog.Errorf("cannot add a child (id = %d) of type %T to a channel", id, e)
+        }
+}
+
+func (c *channel) deleteChild(id int64) {
+        delete(c.subChans, id)
+        delete(c.nestedChans, id)
+        c.deleteSelfIfReady()
+}
+
+func (c *channel) triggerDelete() {
+        c.closeCalled = true
+        c.deleteSelfIfReady()
+}
+
+func (c *channel) getParentID() int64 {
+        return c.pid
+}
+
+// deleteSelfFromTree tries to delete the channel from the channelz entry relation tree, which means
+// deleting the channel reference from its parent's child list.
+//
+// In order for a channel to be deleted from the tree, it must meet the criteria that, removal of the
+// corresponding grpc object has been invoked, and the channel does not have any children left.
+//
+// The returned boolean value indicates whether the channel has been successfully deleted from tree.
+func (c *channel) deleteSelfFromTree() (deleted bool) {
+        if !c.closeCalled || len(c.subChans)+len(c.nestedChans) != 0 {
+                return false
+        }
+        // not top channel
+        if c.pid != 0 {
+                c.cm.findEntry(c.pid).deleteChild(c.id)
+        }
+        return true
+}
+
+// deleteSelfFromMap checks whether it is valid to delete the channel from the map, which means
+// deleting the channel from channelz's tracking entirely. Users can no longer use id to query the
+// channel, and its memory will be garbage collected.
+//
+// The trace reference count of the channel must be 0 in order to be deleted from the map. This is
+// specified in the channel tracing gRFC that as long as some other trace has reference to an entity,
+// the trace of the referenced entity must not be deleted. In order to release the resource allocated
+// by grpc, the reference to the grpc object is reset to a dummy object.
+//
+// deleteSelfFromMap must be called after deleteSelfFromTree returns true.
+//
+// It returns a bool to indicate whether the channel can be safely deleted from map.
+func (c *channel) deleteSelfFromMap() (delete bool) {
+        if c.getTraceRefCount() != 0 {
+                c.c = &dummyChannel{}
+                return false
+        }
+        return true
+}
+
+// deleteSelfIfReady tries to delete the channel itself from the channelz database.
+// The delete process includes two steps:
+// 1. delete the channel from the entry relation tree, i.e. delete the channel reference from its
+//    parent's child list.
+// 2. delete the channel from the map, i.e. delete the channel entirely from channelz. Lookup by id
+//    will return entry not found error.
+func (c *channel) deleteSelfIfReady() {
+        if !c.deleteSelfFromTree() {
+                return
+        }
+        if !c.deleteSelfFromMap() {
+                return
+        }
+        c.cm.deleteEntry(c.id)
+        c.trace.clear()
+}
+
+func (c *channel) getChannelTrace() *channelTrace {
+        return c.trace
+}
+
+func (c *channel) incrTraceRefCount() {
+        atomic.AddInt32(&c.traceRefCount, 1)
+}
+
+func (c *channel) decrTraceRefCount() {
+        atomic.AddInt32(&c.traceRefCount, -1)
+}
+
+func (c *channel) getTraceRefCount() int {
+        i := atomic.LoadInt32(&c.traceRefCount)
+        return int(i)
+}
+
+func (c *channel) getRefName() string {
+        return c.refName
+}
+
+type subChannel struct {
+        refName       string
+        c             Channel
+        closeCalled   bool
+        sockets       map[int64]string
+        id            int64
+        pid           int64
+        cm            *channelMap
+        trace         *channelTrace
+        traceRefCount int32
+}
+
+func (sc *subChannel) addChild(id int64, e entry) {
+        if v, ok := e.(*normalSocket); ok {
+                sc.sockets[id] = v.refName
+        } else {
+                grpclog.Errorf("cannot add a child (id = %d) of type %T to a subChannel", id, e)
+        }
+}
+
+func (sc *subChannel) deleteChild(id int64) {
+        delete(sc.sockets, id)
+        sc.deleteSelfIfReady()
+}
+
+func (sc *subChannel) triggerDelete() {
+        sc.closeCalled = true
+        sc.deleteSelfIfReady()
+}
+
+func (sc *subChannel) getParentID() int64 {
+        return sc.pid
+}
+
+// deleteSelfFromTree tries to delete the subchannel from the channelz entry relation tree, which
+// means deleting the subchannel reference from its parent's child list.
+//
+// In order for a subchannel to be deleted from the tree, it must meet the criteria that, removal of
+// the corresponding grpc object has been invoked, and the subchannel does not have any children left.
+//
+// The returned boolean value indicates whether the channel has been successfully deleted from tree.
+func (sc *subChannel) deleteSelfFromTree() (deleted bool) {
+        if !sc.closeCalled || len(sc.sockets) != 0 {
+                return false
+        }
+        sc.cm.findEntry(sc.pid).deleteChild(sc.id)
+        return true
+}
+
+// deleteSelfFromMap checks whether it is valid to delete the subchannel from the map, which means
+// deleting the subchannel from channelz's tracking entirely. Users can no longer use id to query
+// the subchannel, and its memory will be garbage collected.
+//
+// The trace reference count of the subchannel must be 0 in order to be deleted from the map. This is
+// specified in the channel tracing gRFC that as long as some other trace has reference to an entity,
+// the trace of the referenced entity must not be deleted. In order to release the resource allocated
+// by grpc, the reference to the grpc object is reset to a dummy object.
+//
+// deleteSelfFromMap must be called after deleteSelfFromTree returns true.
+//
+// It returns a bool to indicate whether the channel can be safely deleted from map.
+func (sc *subChannel) deleteSelfFromMap() (delete bool) {
+        if sc.getTraceRefCount() != 0 {
+                // free the grpc struct (i.e. addrConn)
+                sc.c = &dummyChannel{}
+                return false
+        }
+        return true
+}
+
+// deleteSelfIfReady tries to delete the subchannel itself from the channelz database.
+// The delete process includes two steps:
+// 1. delete the subchannel from the entry relation tree, i.e. delete the subchannel reference from
+//    its parent's child list.
+// 2. delete the subchannel from the map, i.e. delete the subchannel entirely from channelz. Lookup
+//    by id will return entry not found error.
+func (sc *subChannel) deleteSelfIfReady() {
+        if !sc.deleteSelfFromTree() {
+                return
+        }
+        if !sc.deleteSelfFromMap() {
+                return
+        }
+        sc.cm.deleteEntry(sc.id)
+        sc.trace.clear()
+}
+
+func (sc *subChannel) getChannelTrace() *channelTrace {
+        return sc.trace
+}
+
+func (sc *subChannel) incrTraceRefCount() {
+        atomic.AddInt32(&sc.traceRefCount, 1)
+}
+
+func (sc *subChannel) decrTraceRefCount() {
+        atomic.AddInt32(&sc.traceRefCount, -1)
+}
+
+func (sc *subChannel) getTraceRefCount() int {
+        i := atomic.LoadInt32(&sc.traceRefCount)
+        return int(i)
+}
+
+func (sc *subChannel) getRefName() string {
+        return sc.refName
+}
+
+// SocketMetric defines the info channelz provides for a specific Socket, which
+// includes SocketInternalMetric and channelz-specific data, such as channelz id, etc.
+type SocketMetric struct {
+        // ID is the channelz id of this socket.
+        ID int64
+        // RefName is the human readable reference string of this socket.
+        RefName string
+        // SocketData contains socket internal metric reported by the socket through
+        // ChannelzMetric().
+        SocketData *SocketInternalMetric
+}
+
+// SocketInternalMetric defines the struct that the implementor of Socket interface
+// should return from ChannelzMetric().
+type SocketInternalMetric struct {
+        // The number of streams that have been started.
+        StreamsStarted int64
+        // The number of streams that have ended successfully:
+        // On client side, receiving frame with eos bit set.
+        // On server side, sending frame with eos bit set.
+        StreamsSucceeded int64
+        // The number of streams that have ended unsuccessfully:
+        // On client side, termination without receiving frame with eos bit set.
+        // On server side, termination without sending frame with eos bit set.
+        StreamsFailed int64
+        // The number of messages successfully sent on this socket.
+        MessagesSent     int64
+        MessagesReceived int64
+        // The number of keep alives sent.  This is typically implemented with HTTP/2
+        // ping messages.
+        KeepAlivesSent int64
+        // The last time a stream was created by this endpoint.  Usually unset for
+        // servers.
+        LastLocalStreamCreatedTimestamp time.Time
+        // The last time a stream was created by the remote endpoint.  Usually unset
+        // for clients.
+        LastRemoteStreamCreatedTimestamp time.Time
+        // The last time a message was sent by this endpoint.
+        LastMessageSentTimestamp time.Time
+        // The last time a message was received by this endpoint.
+        LastMessageReceivedTimestamp time.Time
+        // The amount of window, granted to the local endpoint by the remote endpoint.
+        // This may be slightly out of date due to network latency.  This does NOT
+        // include stream level or TCP level flow control info.
+        LocalFlowControlWindow int64
+        // The amount of window, granted to the remote endpoint by the local endpoint.
+        // This may be slightly out of date due to network latency.  This does NOT
+        // include stream level or TCP level flow control info.
+        RemoteFlowControlWindow int64
+        // The locally bound address.
+        LocalAddr net.Addr
+        // The remote bound address.  May be absent.
+        RemoteAddr net.Addr
+        // Optional, represents the name of the remote endpoint, if different than
+        // the original target name.
+        RemoteName    string
+        SocketOptions *SocketOptionData
+        Security      credentials.ChannelzSecurityValue
+}
+
+// Socket is the interface that should be satisfied in order to be tracked by
+// channelz as Socket.
+type Socket interface {
+        ChannelzMetric() *SocketInternalMetric
+}
+
+type listenSocket struct {
+        refName string
+        s       Socket
+        id      int64
+        pid     int64
+        cm      *channelMap
+}
+
+func (ls *listenSocket) addChild(id int64, e entry) {
+        grpclog.Errorf("cannot add a child (id = %d) of type %T to a listen socket", id, e)
+}
+
+func (ls *listenSocket) deleteChild(id int64) {
+        grpclog.Errorf("cannot delete a child (id = %d) from a listen socket", id)
+}
+
+func (ls *listenSocket) triggerDelete() {
+        ls.cm.deleteEntry(ls.id)
+        ls.cm.findEntry(ls.pid).deleteChild(ls.id)
+}
+
+func (ls *listenSocket) deleteSelfIfReady() {
+        grpclog.Errorf("cannot call deleteSelfIfReady on a listen socket")
+}
+
+func (ls *listenSocket) getParentID() int64 {
+        return ls.pid
+}
+
+type normalSocket struct {
+        refName string
+        s       Socket
+        id      int64
+        pid     int64
+        cm      *channelMap
+}
+
+func (ns *normalSocket) addChild(id int64, e entry) {
+        grpclog.Errorf("cannot add a child (id = %d) of type %T to a normal socket", id, e)
+}
+
+func (ns *normalSocket) deleteChild(id int64) {
+        grpclog.Errorf("cannot delete a child (id = %d) from a normal socket", id)
+}
+
+func (ns *normalSocket) triggerDelete() {
+        ns.cm.deleteEntry(ns.id)
+        ns.cm.findEntry(ns.pid).deleteChild(ns.id)
+}
+
+func (ns *normalSocket) deleteSelfIfReady() {
+        grpclog.Errorf("cannot call deleteSelfIfReady on a normal socket")
+}
+
+func (ns *normalSocket) getParentID() int64 {
+        return ns.pid
+}
+
+// ServerMetric defines the info channelz provides for a specific Server, which
+// includes ServerInternalMetric and channelz-specific data, such as channelz id,
+// child list, etc.
+type ServerMetric struct {
+        // ID is the channelz id of this server.
+        ID int64
+        // RefName is the human readable reference string of this server.
+        RefName string
+        // ServerData contains server internal metric reported by the server through
+        // ChannelzMetric().
+        ServerData *ServerInternalMetric
+        // ListenSockets tracks the listener socket type children of this server in the
+        // format of a map from socket channelz id to corresponding reference string.
+        ListenSockets map[int64]string
+}
+
+// ServerInternalMetric defines the struct that the implementor of Server interface
+// should return from ChannelzMetric().
+type ServerInternalMetric struct {
+        // The number of incoming calls started on the server.
+        CallsStarted int64
+        // The number of incoming calls that have completed with an OK status.
+        CallsSucceeded int64
+        // The number of incoming calls that have a completed with a non-OK status.
+        CallsFailed int64
+        // The last time a call was started on the server.
+        LastCallStartedTimestamp time.Time
+}
+
+// Server is the interface to be satisfied in order to be tracked by channelz as
+// Server.
+type Server interface {
+        ChannelzMetric() *ServerInternalMetric
+}
+
+type server struct {
+        refName       string
+        s             Server
+        closeCalled   bool
+        sockets       map[int64]string
+        listenSockets map[int64]string
+        id            int64
+        cm            *channelMap
+}
+
+func (s *server) addChild(id int64, e entry) {
+        switch v := e.(type) {
+        case *normalSocket:
+                s.sockets[id] = v.refName
+        case *listenSocket:
+                s.listenSockets[id] = v.refName
+        default:
+                grpclog.Errorf("cannot add a child (id = %d) of type %T to a server", id, e)
+        }
+}
+
+func (s *server) deleteChild(id int64) {
+        delete(s.sockets, id)
+        delete(s.listenSockets, id)
+        s.deleteSelfIfReady()
+}
+
+func (s *server) triggerDelete() {
+        s.closeCalled = true
+        s.deleteSelfIfReady()
+}
+
+func (s *server) deleteSelfIfReady() {
+        if !s.closeCalled || len(s.sockets)+len(s.listenSockets) != 0 {
+                return
+        }
+        s.cm.deleteEntry(s.id)
+}
+
+func (s *server) getParentID() int64 {
+        return 0
+}
+
+type tracedChannel interface {
+        getChannelTrace() *channelTrace
+        incrTraceRefCount()
+        decrTraceRefCount()
+        getRefName() string
+}
+
+type channelTrace struct {
+        cm          *channelMap
+        createdTime time.Time
+        eventCount  int64
+        mu          sync.Mutex
+        events      []*TraceEvent
+}
+
+func (c *channelTrace) append(e *TraceEvent) {
+        c.mu.Lock()
+        if len(c.events) == getMaxTraceEntry() {
+                del := c.events[0]
+                c.events = c.events[1:]
+                if del.RefID != 0 {
+                        // start recursive cleanup in a goroutine to not block the call originated from grpc.
+                        go func() {
+                                // need to acquire c.cm.mu lock to call the unlocked attemptCleanup func.
+                                c.cm.mu.Lock()
+                                c.cm.decrTraceRefCount(del.RefID)
+                                c.cm.mu.Unlock()
+                        }()
+                }
+        }
+        e.Timestamp = time.Now()
+        c.events = append(c.events, e)
+        c.eventCount++
+        c.mu.Unlock()
+}
+
+func (c *channelTrace) clear() {
+        c.mu.Lock()
+        for _, e := range c.events {
+                if e.RefID != 0 {
+                        // caller should have already held the c.cm.mu lock.
+                        c.cm.decrTraceRefCount(e.RefID)
+                }
+        }
+        c.mu.Unlock()
+}
+
+// Severity is the severity level of a trace event.
+// The canonical enumeration of all valid values is here:
+// https://github.com/grpc/grpc-proto/blob/9b13d199cc0d4703c7ea26c9c330ba695866eb23/grpc/channelz/v1/channelz.proto#L126.
+type Severity int
+
+const (
+        // CtUNKNOWN indicates unknown severity of a trace event.
+        CtUNKNOWN Severity = iota
+        // CtINFO indicates info level severity of a trace event.
+        CtINFO
+        // CtWarning indicates warning level severity of a trace event.
+        CtWarning
+        // CtError indicates error level severity of a trace event.
+        CtError
+)
+
+// RefChannelType is the type of the entity being referenced in a trace event.
+type RefChannelType int
+
+const (
+        // RefChannel indicates the referenced entity is a Channel.
+        RefChannel RefChannelType = iota
+        // RefSubChannel indicates the referenced entity is a SubChannel.
+        RefSubChannel
+)
+
+func (c *channelTrace) dumpData() *ChannelTrace {
+        c.mu.Lock()
+        ct := &ChannelTrace{EventNum: c.eventCount, CreationTime: c.createdTime}
+        ct.Events = c.events[:len(c.events)]
+        c.mu.Unlock()
+        return ct
+}
diff --git a/vendor/google.golang.org/grpc/internal/channelz/types_linux.go b/vendor/google.golang.org/grpc/internal/channelz/types_linux.go
new file mode 100644
index 0000000..692dd61
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/channelz/types_linux.go
@@ -0,0 +1,53 @@
+// +build !appengine
+
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package channelz
+
+import (
+        "syscall"
+
+        "golang.org/x/sys/unix"
+)
+
+// SocketOptionData defines the struct to hold socket option data, and related
+// getter function to obtain info from fd.
+type SocketOptionData struct {
+        Linger      *unix.Linger
+        RecvTimeout *unix.Timeval
+        SendTimeout *unix.Timeval
+        TCPInfo     *unix.TCPInfo
+}
+
+// Getsockopt defines the function to get socket options requested by channelz.
+// It is to be passed to syscall.RawConn.Control().
+func (s *SocketOptionData) Getsockopt(fd uintptr) {
+        if v, err := unix.GetsockoptLinger(int(fd), syscall.SOL_SOCKET, syscall.SO_LINGER); err == nil {
+                s.Linger = v
+        }
+        if v, err := unix.GetsockoptTimeval(int(fd), syscall.SOL_SOCKET, syscall.SO_RCVTIMEO); err == nil {
+                s.RecvTimeout = v
+        }
+        if v, err := unix.GetsockoptTimeval(int(fd), syscall.SOL_SOCKET, syscall.SO_SNDTIMEO); err == nil {
+                s.SendTimeout = v
+        }
+        if v, err := unix.GetsockoptTCPInfo(int(fd), syscall.SOL_TCP, syscall.TCP_INFO); err == nil {
+                s.TCPInfo = v
+        }
+}
diff --git a/vendor/google.golang.org/grpc/internal/channelz/types_nonlinux.go b/vendor/google.golang.org/grpc/internal/channelz/types_nonlinux.go
new file mode 100644
index 0000000..79edbef
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/channelz/types_nonlinux.go
@@ -0,0 +1,44 @@
+// +build !linux appengine
+
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package channelz
+
+import (
+        "sync"
+
+        "google.golang.org/grpc/grpclog"
+)
+
+var once sync.Once
+
+// SocketOptionData defines the struct to hold socket option data, and related
+// getter function to obtain info from fd.
+// Windows OS doesn't support Socket Option
+type SocketOptionData struct {
+}
+
+// Getsockopt defines the function to get socket options requested by channelz.
+// It is to be passed to syscall.RawConn.Control().
+// Windows OS doesn't support Socket Option
+func (s *SocketOptionData) Getsockopt(fd uintptr) {
+        once.Do(func() {
+                grpclog.Warningln("Channelz: socket options are not supported on non-linux os and appengine.")
+        })
+}
diff --git a/vendor/google.golang.org/grpc/credentials/credentials_util_go18.go b/vendor/google.golang.org/grpc/internal/channelz/util_linux.go
index 93f0e1d..fdf409d 100644
--- a/vendor/google.golang.org/grpc/credentials/credentials_util_go18.go
+++ b/vendor/google.golang.org/grpc/internal/channelz/util_linux.go
@@ -1,8 +1,8 @@
-// +build go1.8
+// +build linux,!appengine
 
 /*
  *
- * Copyright 2017 gRPC authors.
+ * Copyright 2018 gRPC authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,21 +18,22 @@
  *
  */
 
-package credentials
+package channelz
 
 import (
-        "crypto/tls"
+        "syscall"
 )
 
-// cloneTLSConfig returns a shallow clone of the exported
-// fields of cfg, ignoring the unexported sync.Once, which
-// contains a mutex and must not be copied.
-//
-// If cfg is nil, a new zero tls.Config is returned.
-func cloneTLSConfig(cfg *tls.Config) *tls.Config {
-        if cfg == nil {
-                return &tls.Config{}
+// GetSocketOption gets the socket option info of the conn.
+func GetSocketOption(socket interface{}) *SocketOptionData {
+        c, ok := socket.(syscall.Conn)
+        if !ok {
+                return nil
         }
-
-        return cfg.Clone()
+        data := &SocketOptionData{}
+        if rawConn, err := c.SyscallConn(); err == nil {
+                rawConn.Control(data.Getsockopt)
+                return data
+        }
+        return nil
 }
diff --git a/vendor/google.golang.org/grpc/internal/channelz/util_nonlinux.go b/vendor/google.golang.org/grpc/internal/channelz/util_nonlinux.go
new file mode 100644
index 0000000..8864a08
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/channelz/util_nonlinux.go
@@ -0,0 +1,26 @@
+// +build !linux appengine
+
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package channelz
+
+// GetSocketOption gets the socket option info of the conn.
+func GetSocketOption(c interface{}) *SocketOptionData {
+        return nil
+}
diff --git a/vendor/google.golang.org/grpc/internal/envconfig/envconfig.go b/vendor/google.golang.org/grpc/internal/envconfig/envconfig.go
new file mode 100644
index 0000000..d2193b3
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/envconfig/envconfig.go
@@ -0,0 +1,70 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package envconfig contains grpc settings configured by environment variables.
+package envconfig
+
+import (
+        "os"
+        "strings"
+)
+
+const (
+        prefix              = "GRPC_GO_"
+        retryStr            = prefix + "RETRY"
+        requireHandshakeStr = prefix + "REQUIRE_HANDSHAKE"
+)
+
+// RequireHandshakeSetting describes the settings for handshaking.
+type RequireHandshakeSetting int
+
+const (
+        // RequireHandshakeHybrid (default, deprecated) indicates to not wait for
+        // handshake before considering a connection ready, but wait before
+        // considering successful.
+        RequireHandshakeHybrid RequireHandshakeSetting = iota
+        // RequireHandshakeOn (default after the 1.17 release) indicates to wait
+        // for handshake before considering a connection ready/successful.
+        RequireHandshakeOn
+        // RequireHandshakeOff indicates to not wait for handshake before
+        // considering a connection ready/successful.
+        RequireHandshakeOff
+)
+
+var (
+        // Retry is set if retry is explicitly enabled via "GRPC_GO_RETRY=on".
+        Retry = strings.EqualFold(os.Getenv(retryStr), "on")
+        // RequireHandshake is set based upon the GRPC_GO_REQUIRE_HANDSHAKE
+        // environment variable.
+        //
+        // Will be removed after the 1.18 release.
+        RequireHandshake RequireHandshakeSetting
+)
+
+func init() {
+        switch strings.ToLower(os.Getenv(requireHandshakeStr)) {
+        case "on":
+        default:
+                RequireHandshake = RequireHandshakeOn
+        case "off":
+                RequireHandshake = RequireHandshakeOff
+        case "hybrid":
+                // Will be removed after the 1.17 release.
+                RequireHandshake = RequireHandshakeHybrid
+        }
+}
diff --git a/vendor/google.golang.org/grpc/internal/grpcrand/grpcrand.go b/vendor/google.golang.org/grpc/internal/grpcrand/grpcrand.go
new file mode 100644
index 0000000..200b115
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/grpcrand/grpcrand.go
@@ -0,0 +1,56 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package grpcrand implements math/rand functions in a concurrent-safe way
+// with a global random source, independent of math/rand's global source.
+package grpcrand
+
+import (
+        "math/rand"
+        "sync"
+        "time"
+)
+
+var (
+        r  = rand.New(rand.NewSource(time.Now().UnixNano()))
+        mu sync.Mutex
+)
+
+// Int63n implements rand.Int63n on the grpcrand global source.
+func Int63n(n int64) int64 {
+        mu.Lock()
+        res := r.Int63n(n)
+        mu.Unlock()
+        return res
+}
+
+// Intn implements rand.Intn on the grpcrand global source.
+func Intn(n int) int {
+        mu.Lock()
+        res := r.Intn(n)
+        mu.Unlock()
+        return res
+}
+
+// Float64 implements rand.Float64 on the grpcrand global source.
+func Float64() float64 {
+        mu.Lock()
+        res := r.Float64()
+        mu.Unlock()
+        return res
+}
diff --git a/vendor/google.golang.org/grpc/internal/grpcsync/event.go b/vendor/google.golang.org/grpc/internal/grpcsync/event.go
new file mode 100644
index 0000000..fbe697c
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/grpcsync/event.go
@@ -0,0 +1,61 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package grpcsync implements additional synchronization primitives built upon
+// the sync package.
+package grpcsync
+
+import (
+        "sync"
+        "sync/atomic"
+)
+
+// Event represents a one-time event that may occur in the future.
+type Event struct {
+        fired int32
+        c     chan struct{}
+        o     sync.Once
+}
+
+// Fire causes e to complete.  It is safe to call multiple times, and
+// concurrently.  It returns true iff this call to Fire caused the signaling
+// channel returned by Done to close.
+func (e *Event) Fire() bool {
+        ret := false
+        e.o.Do(func() {
+                atomic.StoreInt32(&e.fired, 1)
+                close(e.c)
+                ret = true
+        })
+        return ret
+}
+
+// Done returns a channel that will be closed when Fire is called.
+func (e *Event) Done() <-chan struct{} {
+        return e.c
+}
+
+// HasFired returns true if Fire has been called.
+func (e *Event) HasFired() bool {
+        return atomic.LoadInt32(&e.fired) == 1
+}
+
+// NewEvent returns a new, ready-to-use Event.
+func NewEvent() *Event {
+        return &Event{c: make(chan struct{})}
+}
diff --git a/vendor/google.golang.org/grpc/internal/internal.go b/vendor/google.golang.org/grpc/internal/internal.go
index 0708383..eaa54d4 100644
--- a/vendor/google.golang.org/grpc/internal/internal.go
+++ b/vendor/google.golang.org/grpc/internal/internal.go
@@ -15,20 +15,36 @@
  *
  */
 
-// Package internal contains gRPC-internal code for testing, to avoid polluting
-// the godoc of the top-level grpc package.
+// Package internal contains gRPC-internal code, to avoid polluting
+// the godoc of the top-level grpc package.  It must not import any grpc
+// symbols to avoid circular dependencies.
 package internal
 
-// TestingCloseConns closes all existing transports but keeps
-// grpcServer.lis accepting new connections.
-//
-// The provided grpcServer must be of type *grpc.Server. It is untyped
-// for circular dependency reasons.
-var TestingCloseConns func(grpcServer interface{})
+import "context"
 
-// TestingUseHandlerImpl enables the http.Handler-based server implementation.
-// It must be called before Serve and requires TLS credentials.
-//
-// The provided grpcServer must be of type *grpc.Server. It is untyped
-// for circular dependency reasons.
-var TestingUseHandlerImpl func(grpcServer interface{})
+var (
+        // WithContextDialer is exported by dialoptions.go
+        WithContextDialer interface{} // func(context.Context, string) (net.Conn, error) grpc.DialOption
+        // WithResolverBuilder is exported by dialoptions.go
+        WithResolverBuilder interface{} // func (resolver.Builder) grpc.DialOption
+        // WithHealthCheckFunc is not exported by dialoptions.go
+        WithHealthCheckFunc interface{} // func (HealthChecker) DialOption
+        // HealthCheckFunc is used to provide client-side LB channel health checking
+        HealthCheckFunc HealthChecker
+        // BalancerUnregister is exported by package balancer to unregister a balancer.
+        BalancerUnregister func(name string)
+)
+
+// HealthChecker defines the signature of the client-side LB channel health checking function.
+type HealthChecker func(ctx context.Context, newStream func() (interface{}, error), reportHealth func(bool), serviceName string) error
+
+const (
+        // CredsBundleModeFallback switches GoogleDefaultCreds to fallback mode.
+        CredsBundleModeFallback = "fallback"
+        // CredsBundleModeBalancer switches GoogleDefaultCreds to grpclb balancer
+        // mode.
+        CredsBundleModeBalancer = "balancer"
+        // CredsBundleModeBackendFromBalancer switches GoogleDefaultCreds to mode
+        // that supports backend returned by grpclb balancer.
+        CredsBundleModeBackendFromBalancer = "backend-from-balancer"
+)
diff --git a/vendor/google.golang.org/grpc/internal/syscall/syscall_linux.go b/vendor/google.golang.org/grpc/internal/syscall/syscall_linux.go
new file mode 100644
index 0000000..43281a3
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/syscall/syscall_linux.go
@@ -0,0 +1,114 @@
+// +build !appengine
+
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package syscall provides functionalities that grpc uses to get low-level operating system
+// stats/info.
+package syscall
+
+import (
+        "fmt"
+        "net"
+        "syscall"
+        "time"
+
+        "golang.org/x/sys/unix"
+        "google.golang.org/grpc/grpclog"
+)
+
+// GetCPUTime returns the how much CPU time has passed since the start of this process.
+func GetCPUTime() int64 {
+        var ts unix.Timespec
+        if err := unix.ClockGettime(unix.CLOCK_PROCESS_CPUTIME_ID, &ts); err != nil {
+                grpclog.Fatal(err)
+        }
+        return ts.Nano()
+}
+
+// Rusage is an alias for syscall.Rusage under linux non-appengine environment.
+type Rusage syscall.Rusage
+
+// GetRusage returns the resource usage of current process.
+func GetRusage() (rusage *Rusage) {
+        rusage = new(Rusage)
+        syscall.Getrusage(syscall.RUSAGE_SELF, (*syscall.Rusage)(rusage))
+        return
+}
+
+// CPUTimeDiff returns the differences of user CPU time and system CPU time used
+// between two Rusage structs.
+func CPUTimeDiff(first *Rusage, latest *Rusage) (float64, float64) {
+        f := (*syscall.Rusage)(first)
+        l := (*syscall.Rusage)(latest)
+        var (
+                utimeDiffs  = l.Utime.Sec - f.Utime.Sec
+                utimeDiffus = l.Utime.Usec - f.Utime.Usec
+                stimeDiffs  = l.Stime.Sec - f.Stime.Sec
+                stimeDiffus = l.Stime.Usec - f.Stime.Usec
+        )
+
+        uTimeElapsed := float64(utimeDiffs) + float64(utimeDiffus)*1.0e-6
+        sTimeElapsed := float64(stimeDiffs) + float64(stimeDiffus)*1.0e-6
+
+        return uTimeElapsed, sTimeElapsed
+}
+
+// SetTCPUserTimeout sets the TCP user timeout on a connection's socket
+func SetTCPUserTimeout(conn net.Conn, timeout time.Duration) error {
+        tcpconn, ok := conn.(*net.TCPConn)
+        if !ok {
+                // not a TCP connection. exit early
+                return nil
+        }
+        rawConn, err := tcpconn.SyscallConn()
+        if err != nil {
+                return fmt.Errorf("error getting raw connection: %v", err)
+        }
+        err = rawConn.Control(func(fd uintptr) {
+                err = syscall.SetsockoptInt(int(fd), syscall.IPPROTO_TCP, unix.TCP_USER_TIMEOUT, int(timeout/time.Millisecond))
+        })
+        if err != nil {
+                return fmt.Errorf("error setting option on socket: %v", err)
+        }
+
+        return nil
+}
+
+// GetTCPUserTimeout gets the TCP user timeout on a connection's socket
+func GetTCPUserTimeout(conn net.Conn) (opt int, err error) {
+        tcpconn, ok := conn.(*net.TCPConn)
+        if !ok {
+                err = fmt.Errorf("conn is not *net.TCPConn. got %T", conn)
+                return
+        }
+        rawConn, err := tcpconn.SyscallConn()
+        if err != nil {
+                err = fmt.Errorf("error getting raw connection: %v", err)
+                return
+        }
+        err = rawConn.Control(func(fd uintptr) {
+                opt, err = syscall.GetsockoptInt(int(fd), syscall.IPPROTO_TCP, unix.TCP_USER_TIMEOUT)
+        })
+        if err != nil {
+                err = fmt.Errorf("error getting option on socket: %v", err)
+                return
+        }
+
+        return
+}
diff --git a/vendor/google.golang.org/grpc/internal/syscall/syscall_nonlinux.go b/vendor/google.golang.org/grpc/internal/syscall/syscall_nonlinux.go
new file mode 100644
index 0000000..61678fe
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/syscall/syscall_nonlinux.go
@@ -0,0 +1,63 @@
+// +build !linux appengine
+
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package syscall
+
+import (
+        "net"
+        "time"
+
+        "google.golang.org/grpc/grpclog"
+)
+
+func init() {
+        grpclog.Info("CPU time info is unavailable on non-linux or appengine environment.")
+}
+
+// GetCPUTime returns the how much CPU time has passed since the start of this process.
+// It always returns 0 under non-linux or appengine environment.
+func GetCPUTime() int64 {
+        return 0
+}
+
+// Rusage is an empty struct under non-linux or appengine environment.
+type Rusage struct{}
+
+// GetRusage is a no-op function under non-linux or appengine environment.
+func GetRusage() (rusage *Rusage) {
+        return nil
+}
+
+// CPUTimeDiff returns the differences of user CPU time and system CPU time used
+// between two Rusage structs. It a no-op function for non-linux or appengine environment.
+func CPUTimeDiff(first *Rusage, latest *Rusage) (float64, float64) {
+        return 0, 0
+}
+
+// SetTCPUserTimeout is a no-op function under non-linux or appengine environments
+func SetTCPUserTimeout(conn net.Conn, timeout time.Duration) error {
+        return nil
+}
+
+// GetTCPUserTimeout is a no-op function under non-linux or appengine environments
+// a negative return value indicates the operation is not supported
+func GetTCPUserTimeout(conn net.Conn) (int, error) {
+        return -1, nil
+}
diff --git a/vendor/google.golang.org/grpc/transport/bdp_estimator.go b/vendor/google.golang.org/grpc/internal/transport/bdp_estimator.go
index 667edb8..070680e 100644
--- a/vendor/google.golang.org/grpc/transport/bdp_estimator.go
+++ b/vendor/google.golang.org/grpc/internal/transport/bdp_estimator.go
@@ -24,9 +24,10 @@ import (
 )
 
 const (
-        // bdpLimit is the maximum value the flow control windows
-        // will be increased to.
-        bdpLimit = (1 << 20) * 4
+        // bdpLimit is the maximum value the flow control windows will be increased
+        // to.  TCP typically limits this to 4MB, but some systems go up to 16MB.
+        // Since this is only a limit, it is safe to make it optimistic.
+        bdpLimit = (1 << 20) * 16
         // alpha is a constant factor used to keep a moving average
         // of RTTs.
         alpha = 0.9
@@ -41,12 +42,9 @@ const (
         gamma = 2
 )
 
-var (
-        // Adding arbitrary data to ping so that its ack can be
-        // identified.
-        // Easter-egg: what does the ping message say?
-        bdpPing = &ping{data: [8]byte{2, 4, 16, 16, 9, 14, 7, 7}}
-)
+// Adding arbitrary data to ping so that its ack can be identified.
+// Easter-egg: what does the ping message say?
+var bdpPing = &ping{data: [8]byte{2, 4, 16, 16, 9, 14, 7, 7}}
 
 type bdpEstimator struct {
         // sentAt is the time when the ping was sent.
@@ -59,7 +57,7 @@ type bdpEstimator struct {
         sample uint32
         // bwMax is the maximum bandwidth noted so far (bytes/sec).
         bwMax float64
-        // bool to keep track of the begining of a new measurement cycle.
+        // bool to keep track of the beginning of a new measurement cycle.
         isSent bool
         // Callback to update the window sizes.
         updateFlowControl func(n uint32)
@@ -70,7 +68,7 @@ type bdpEstimator struct {
 }
 
 // timesnap registers the time bdp ping was sent out so that
-// network rtt can be calculated when its ack is recieved.
+// network rtt can be calculated when its ack is received.
 // It is called (by controller) when the bdpPing is
 // being written on the wire.
 func (b *bdpEstimator) timesnap(d [8]byte) {
@@ -119,7 +117,7 @@ func (b *bdpEstimator) calculate(d [8]byte) {
                 b.rtt += (rttSample - b.rtt) * float64(alpha)
         }
         b.isSent = false
-        // The number of bytes accumalated so far in the sample is smaller
+        // The number of bytes accumulated so far in the sample is smaller
         // than or equal to 1.5 times the real BDP on a saturated connection.
         bwCurrent := float64(b.sample) / (b.rtt * float64(1.5))
         if bwCurrent > b.bwMax {
diff --git a/vendor/google.golang.org/grpc/internal/transport/controlbuf.go b/vendor/google.golang.org/grpc/internal/transport/controlbuf.go
new file mode 100644
index 0000000..204ba15
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/transport/controlbuf.go
@@ -0,0 +1,852 @@
+/*
+ *
+ * Copyright 2014 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package transport
+
+import (
+        "bytes"
+        "fmt"
+        "runtime"
+        "sync"
+
+        "golang.org/x/net/http2"
+        "golang.org/x/net/http2/hpack"
+)
+
+var updateHeaderTblSize = func(e *hpack.Encoder, v uint32) {
+        e.SetMaxDynamicTableSizeLimit(v)
+}
+
+type itemNode struct {
+        it   interface{}
+        next *itemNode
+}
+
+type itemList struct {
+        head *itemNode
+        tail *itemNode
+}
+
+func (il *itemList) enqueue(i interface{}) {
+        n := &itemNode{it: i}
+        if il.tail == nil {
+                il.head, il.tail = n, n
+                return
+        }
+        il.tail.next = n
+        il.tail = n
+}
+
+// peek returns the first item in the list without removing it from the
+// list.
+func (il *itemList) peek() interface{} {
+        return il.head.it
+}
+
+func (il *itemList) dequeue() interface{} {
+        if il.head == nil {
+                return nil
+        }
+        i := il.head.it
+        il.head = il.head.next
+        if il.head == nil {
+                il.tail = nil
+        }
+        return i
+}
+
+func (il *itemList) dequeueAll() *itemNode {
+        h := il.head
+        il.head, il.tail = nil, nil
+        return h
+}
+
+func (il *itemList) isEmpty() bool {
+        return il.head == nil
+}
+
+// The following defines various control items which could flow through
+// the control buffer of transport. They represent different aspects of
+// control tasks, e.g., flow control, settings, streaming resetting, etc.
+
+// registerStream is used to register an incoming stream with loopy writer.
+type registerStream struct {
+        streamID uint32
+        wq       *writeQuota
+}
+
+// headerFrame is also used to register stream on the client-side.
+type headerFrame struct {
+        streamID   uint32
+        hf         []hpack.HeaderField
+        endStream  bool                       // Valid on server side.
+        initStream func(uint32) (bool, error) // Used only on the client side.
+        onWrite    func()
+        wq         *writeQuota    // write quota for the stream created.
+        cleanup    *cleanupStream // Valid on the server side.
+        onOrphaned func(error)    // Valid on client-side
+}
+
+type cleanupStream struct {
+        streamID uint32
+        rst      bool
+        rstCode  http2.ErrCode
+        onWrite  func()
+}
+
+type dataFrame struct {
+        streamID  uint32
+        endStream bool
+        h         []byte
+        d         []byte
+        // onEachWrite is called every time
+        // a part of d is written out.
+        onEachWrite func()
+}
+
+type incomingWindowUpdate struct {
+        streamID  uint32
+        increment uint32
+}
+
+type outgoingWindowUpdate struct {
+        streamID  uint32
+        increment uint32
+}
+
+type incomingSettings struct {
+        ss []http2.Setting
+}
+
+type outgoingSettings struct {
+        ss []http2.Setting
+}
+
+type incomingGoAway struct {
+}
+
+type goAway struct {
+        code      http2.ErrCode
+        debugData []byte
+        headsUp   bool
+        closeConn bool
+}
+
+type ping struct {
+        ack  bool
+        data [8]byte
+}
+
+type outFlowControlSizeRequest struct {
+        resp chan uint32
+}
+
+type outStreamState int
+
+const (
+        active outStreamState = iota
+        empty
+        waitingOnStreamQuota
+)
+
+type outStream struct {
+        id               uint32
+        state            outStreamState
+        itl              *itemList
+        bytesOutStanding int
+        wq               *writeQuota
+
+        next *outStream
+        prev *outStream
+}
+
+func (s *outStream) deleteSelf() {
+        if s.prev != nil {
+                s.prev.next = s.next
+        }
+        if s.next != nil {
+                s.next.prev = s.prev
+        }
+        s.next, s.prev = nil, nil
+}
+
+type outStreamList struct {
+        // Following are sentinel objects that mark the
+        // beginning and end of the list. They do not
+        // contain any item lists. All valid objects are
+        // inserted in between them.
+        // This is needed so that an outStream object can
+        // deleteSelf() in O(1) time without knowing which
+        // list it belongs to.
+        head *outStream
+        tail *outStream
+}
+
+func newOutStreamList() *outStreamList {
+        head, tail := new(outStream), new(outStream)
+        head.next = tail
+        tail.prev = head
+        return &outStreamList{
+                head: head,
+                tail: tail,
+        }
+}
+
+func (l *outStreamList) enqueue(s *outStream) {
+        e := l.tail.prev
+        e.next = s
+        s.prev = e
+        s.next = l.tail
+        l.tail.prev = s
+}
+
+// remove from the beginning of the list.
+func (l *outStreamList) dequeue() *outStream {
+        b := l.head.next
+        if b == l.tail {
+                return nil
+        }
+        b.deleteSelf()
+        return b
+}
+
+// controlBuffer is a way to pass information to loopy.
+// Information is passed as specific struct types called control frames.
+// A control frame not only represents data, messages or headers to be sent out
+// but can also be used to instruct loopy to update its internal state.
+// It shouldn't be confused with an HTTP2 frame, although some of the control frames
+// like dataFrame and headerFrame do go out on wire as HTTP2 frames.
+type controlBuffer struct {
+        ch              chan struct{}
+        done            <-chan struct{}
+        mu              sync.Mutex
+        consumerWaiting bool
+        list            *itemList
+        err             error
+}
+
+func newControlBuffer(done <-chan struct{}) *controlBuffer {
+        return &controlBuffer{
+                ch:   make(chan struct{}, 1),
+                list: &itemList{},
+                done: done,
+        }
+}
+
+func (c *controlBuffer) put(it interface{}) error {
+        _, err := c.executeAndPut(nil, it)
+        return err
+}
+
+func (c *controlBuffer) executeAndPut(f func(it interface{}) bool, it interface{}) (bool, error) {
+        var wakeUp bool
+        c.mu.Lock()
+        if c.err != nil {
+                c.mu.Unlock()
+                return false, c.err
+        }
+        if f != nil {
+                if !f(it) { // f wasn't successful
+                        c.mu.Unlock()
+                        return false, nil
+                }
+        }
+        if c.consumerWaiting {
+                wakeUp = true
+                c.consumerWaiting = false
+        }
+        c.list.enqueue(it)
+        c.mu.Unlock()
+        if wakeUp {
+                select {
+                case c.ch <- struct{}{}:
+                default:
+                }
+        }
+        return true, nil
+}
+
+// Note argument f should never be nil.
+func (c *controlBuffer) execute(f func(it interface{}) bool, it interface{}) (bool, error) {
+        c.mu.Lock()
+        if c.err != nil {
+                c.mu.Unlock()
+                return false, c.err
+        }
+        if !f(it) { // f wasn't successful
+                c.mu.Unlock()
+                return false, nil
+        }
+        c.mu.Unlock()
+        return true, nil
+}
+
+func (c *controlBuffer) get(block bool) (interface{}, error) {
+        for {
+                c.mu.Lock()
+                if c.err != nil {
+                        c.mu.Unlock()
+                        return nil, c.err
+                }
+                if !c.list.isEmpty() {
+                        h := c.list.dequeue()
+                        c.mu.Unlock()
+                        return h, nil
+                }
+                if !block {
+                        c.mu.Unlock()
+                        return nil, nil
+                }
+                c.consumerWaiting = true
+                c.mu.Unlock()
+                select {
+                case <-c.ch:
+                case <-c.done:
+                        c.finish()
+                        return nil, ErrConnClosing
+                }
+        }
+}
+
+func (c *controlBuffer) finish() {
+        c.mu.Lock()
+        if c.err != nil {
+                c.mu.Unlock()
+                return
+        }
+        c.err = ErrConnClosing
+        // There may be headers for streams in the control buffer.
+        // These streams need to be cleaned out since the transport
+        // is still not aware of these yet.
+        for head := c.list.dequeueAll(); head != nil; head = head.next {
+                hdr, ok := head.it.(*headerFrame)
+                if !ok {
+                        continue
+                }
+                if hdr.onOrphaned != nil { // It will be nil on the server-side.
+                        hdr.onOrphaned(ErrConnClosing)
+                }
+        }
+        c.mu.Unlock()
+}
+
+type side int
+
+const (
+        clientSide side = iota
+        serverSide
+)
+
+// Loopy receives frames from the control buffer.
+// Each frame is handled individually; most of the work done by loopy goes
+// into handling data frames. Loopy maintains a queue of active streams, and each
+// stream maintains a queue of data frames; as loopy receives data frames
+// it gets added to the queue of the relevant stream.
+// Loopy goes over this list of active streams by processing one node every iteration,
+// thereby closely resemebling to a round-robin scheduling over all streams. While
+// processing a stream, loopy writes out data bytes from this stream capped by the min
+// of http2MaxFrameLen, connection-level flow control and stream-level flow control.
+type loopyWriter struct {
+        side      side
+        cbuf      *controlBuffer
+        sendQuota uint32
+        oiws      uint32 // outbound initial window size.
+        // estdStreams is map of all established streams that are not cleaned-up yet.
+        // On client-side, this is all streams whose headers were sent out.
+        // On server-side, this is all streams whose headers were received.
+        estdStreams map[uint32]*outStream // Established streams.
+        // activeStreams is a linked-list of all streams that have data to send and some
+        // stream-level flow control quota.
+        // Each of these streams internally have a list of data items(and perhaps trailers
+        // on the server-side) to be sent out.
+        activeStreams *outStreamList
+        framer        *framer
+        hBuf          *bytes.Buffer  // The buffer for HPACK encoding.
+        hEnc          *hpack.Encoder // HPACK encoder.
+        bdpEst        *bdpEstimator
+        draining      bool
+
+        // Side-specific handlers
+        ssGoAwayHandler func(*goAway) (bool, error)
+}
+
+func newLoopyWriter(s side, fr *framer, cbuf *controlBuffer, bdpEst *bdpEstimator) *loopyWriter {
+        var buf bytes.Buffer
+        l := &loopyWriter{
+                side:          s,
+                cbuf:          cbuf,
+                sendQuota:     defaultWindowSize,
+                oiws:          defaultWindowSize,
+                estdStreams:   make(map[uint32]*outStream),
+                activeStreams: newOutStreamList(),
+                framer:        fr,
+                hBuf:          &buf,
+                hEnc:          hpack.NewEncoder(&buf),
+                bdpEst:        bdpEst,
+        }
+        return l
+}
+
+const minBatchSize = 1000
+
+// run should be run in a separate goroutine.
+// It reads control frames from controlBuf and processes them by:
+// 1. Updating loopy's internal state, or/and
+// 2. Writing out HTTP2 frames on the wire.
+//
+// Loopy keeps all active streams with data to send in a linked-list.
+// All streams in the activeStreams linked-list must have both:
+// 1. Data to send, and
+// 2. Stream level flow control quota available.
+//
+// In each iteration of run loop, other than processing the incoming control
+// frame, loopy calls processData, which processes one node from the activeStreams linked-list.
+// This results in writing of HTTP2 frames into an underlying write buffer.
+// When there's no more control frames to read from controlBuf, loopy flushes the write buffer.
+// As an optimization, to increase the batch size for each flush, loopy yields the processor, once
+// if the batch size is too low to give stream goroutines a chance to fill it up.
+func (l *loopyWriter) run() (err error) {
+        defer func() {
+                if err == ErrConnClosing {
+                        // Don't log ErrConnClosing as error since it happens
+                        // 1. When the connection is closed by some other known issue.
+                        // 2. User closed the connection.
+                        // 3. A graceful close of connection.
+                        infof("transport: loopyWriter.run returning. %v", err)
+                        err = nil
+                }
+        }()
+        for {
+                it, err := l.cbuf.get(true)
+                if err != nil {
+                        return err
+                }
+                if err = l.handle(it); err != nil {
+                        return err
+                }
+                if _, err = l.processData(); err != nil {
+                        return err
+                }
+                gosched := true
+        hasdata:
+                for {
+                        it, err := l.cbuf.get(false)
+                        if err != nil {
+                                return err
+                        }
+                        if it != nil {
+                                if err = l.handle(it); err != nil {
+                                        return err
+                                }
+                                if _, err = l.processData(); err != nil {
+                                        return err
+                                }
+                                continue hasdata
+                        }
+                        isEmpty, err := l.processData()
+                        if err != nil {
+                                return err
+                        }
+                        if !isEmpty {
+                                continue hasdata
+                        }
+                        if gosched {
+                                gosched = false
+                                if l.framer.writer.offset < minBatchSize {
+                                        runtime.Gosched()
+                                        continue hasdata
+                                }
+                        }
+                        l.framer.writer.Flush()
+                        break hasdata
+
+                }
+        }
+}
+
+func (l *loopyWriter) outgoingWindowUpdateHandler(w *outgoingWindowUpdate) error {
+        return l.framer.fr.WriteWindowUpdate(w.streamID, w.increment)
+}
+
+func (l *loopyWriter) incomingWindowUpdateHandler(w *incomingWindowUpdate) error {
+        // Otherwise update the quota.
+        if w.streamID == 0 {
+                l.sendQuota += w.increment
+                return nil
+        }
+        // Find the stream and update it.
+        if str, ok := l.estdStreams[w.streamID]; ok {
+                str.bytesOutStanding -= int(w.increment)
+                if strQuota := int(l.oiws) - str.bytesOutStanding; strQuota > 0 && str.state == waitingOnStreamQuota {
+                        str.state = active
+                        l.activeStreams.enqueue(str)
+                        return nil
+                }
+        }
+        return nil
+}
+
+func (l *loopyWriter) outgoingSettingsHandler(s *outgoingSettings) error {
+        return l.framer.fr.WriteSettings(s.ss...)
+}
+
+func (l *loopyWriter) incomingSettingsHandler(s *incomingSettings) error {
+        if err := l.applySettings(s.ss); err != nil {
+                return err
+        }
+        return l.framer.fr.WriteSettingsAck()
+}
+
+func (l *loopyWriter) registerStreamHandler(h *registerStream) error {
+        str := &outStream{
+                id:    h.streamID,
+                state: empty,
+                itl:   &itemList{},
+                wq:    h.wq,
+        }
+        l.estdStreams[h.streamID] = str
+        return nil
+}
+
+func (l *loopyWriter) headerHandler(h *headerFrame) error {
+        if l.side == serverSide {
+                str, ok := l.estdStreams[h.streamID]
+                if !ok {
+                        warningf("transport: loopy doesn't recognize the stream: %d", h.streamID)
+                        return nil
+                }
+                // Case 1.A: Server is responding back with headers.
+                if !h.endStream {
+                        return l.writeHeader(h.streamID, h.endStream, h.hf, h.onWrite)
+                }
+                // else:  Case 1.B: Server wants to close stream.
+
+                if str.state != empty { // either active or waiting on stream quota.
+                        // add it str's list of items.
+                        str.itl.enqueue(h)
+                        return nil
+                }
+                if err := l.writeHeader(h.streamID, h.endStream, h.hf, h.onWrite); err != nil {
+                        return err
+                }
+                return l.cleanupStreamHandler(h.cleanup)
+        }
+        // Case 2: Client wants to originate stream.
+        str := &outStream{
+                id:    h.streamID,
+                state: empty,
+                itl:   &itemList{},
+                wq:    h.wq,
+        }
+        str.itl.enqueue(h)
+        return l.originateStream(str)
+}
+
+func (l *loopyWriter) originateStream(str *outStream) error {
+        hdr := str.itl.dequeue().(*headerFrame)
+        sendPing, err := hdr.initStream(str.id)
+        if err != nil {
+                if err == ErrConnClosing {
+                        return err
+                }
+                // Other errors(errStreamDrain) need not close transport.
+                return nil
+        }
+        if err = l.writeHeader(str.id, hdr.endStream, hdr.hf, hdr.onWrite); err != nil {
+                return err
+        }
+        l.estdStreams[str.id] = str
+        if sendPing {
+                return l.pingHandler(&ping{data: [8]byte{}})
+        }
+        return nil
+}
+
+func (l *loopyWriter) writeHeader(streamID uint32, endStream bool, hf []hpack.HeaderField, onWrite func()) error {
+        if onWrite != nil {
+                onWrite()
+        }
+        l.hBuf.Reset()
+        for _, f := range hf {
+                if err := l.hEnc.WriteField(f); err != nil {
+                        warningf("transport: loopyWriter.writeHeader encountered error while encoding headers:", err)
+                }
+        }
+        var (
+                err               error
+                endHeaders, first bool
+        )
+        first = true
+        for !endHeaders {
+                size := l.hBuf.Len()
+                if size > http2MaxFrameLen {
+                        size = http2MaxFrameLen
+                } else {
+                        endHeaders = true
+                }
+                if first {
+                        first = false
+                        err = l.framer.fr.WriteHeaders(http2.HeadersFrameParam{
+                                StreamID:      streamID,
+                                BlockFragment: l.hBuf.Next(size),
+                                EndStream:     endStream,
+                                EndHeaders:    endHeaders,
+                        })
+                } else {
+                        err = l.framer.fr.WriteContinuation(
+                                streamID,
+                                endHeaders,
+                                l.hBuf.Next(size),
+                        )
+                }
+                if err != nil {
+                        return err
+                }
+        }
+        return nil
+}
+
+func (l *loopyWriter) preprocessData(df *dataFrame) error {
+        str, ok := l.estdStreams[df.streamID]
+        if !ok {
+                return nil
+        }
+        // If we got data for a stream it means that
+        // stream was originated and the headers were sent out.
+        str.itl.enqueue(df)
+        if str.state == empty {
+                str.state = active
+                l.activeStreams.enqueue(str)
+        }
+        return nil
+}
+
+func (l *loopyWriter) pingHandler(p *ping) error {
+        if !p.ack {
+                l.bdpEst.timesnap(p.data)
+        }
+        return l.framer.fr.WritePing(p.ack, p.data)
+
+}
+
+func (l *loopyWriter) outFlowControlSizeRequestHandler(o *outFlowControlSizeRequest) error {
+        o.resp <- l.sendQuota
+        return nil
+}
+
+func (l *loopyWriter) cleanupStreamHandler(c *cleanupStream) error {
+        c.onWrite()
+        if str, ok := l.estdStreams[c.streamID]; ok {
+                // On the server side it could be a trailers-only response or
+                // a RST_STREAM before stream initialization thus the stream might
+                // not be established yet.
+                delete(l.estdStreams, c.streamID)
+                str.deleteSelf()
+        }
+        if c.rst { // If RST_STREAM needs to be sent.
+                if err := l.framer.fr.WriteRSTStream(c.streamID, c.rstCode); err != nil {
+                        return err
+                }
+        }
+        if l.side == clientSide && l.draining && len(l.estdStreams) == 0 {
+                return ErrConnClosing
+        }
+        return nil
+}
+
+func (l *loopyWriter) incomingGoAwayHandler(*incomingGoAway) error {
+        if l.side == clientSide {
+                l.draining = true
+                if len(l.estdStreams) == 0 {
+                        return ErrConnClosing
+                }
+        }
+        return nil
+}
+
+func (l *loopyWriter) goAwayHandler(g *goAway) error {
+        // Handling of outgoing GoAway is very specific to side.
+        if l.ssGoAwayHandler != nil {
+                draining, err := l.ssGoAwayHandler(g)
+                if err != nil {
+                        return err
+                }
+                l.draining = draining
+        }
+        return nil
+}
+
+func (l *loopyWriter) handle(i interface{}) error {
+        switch i := i.(type) {
+        case *incomingWindowUpdate:
+                return l.incomingWindowUpdateHandler(i)
+        case *outgoingWindowUpdate:
+                return l.outgoingWindowUpdateHandler(i)
+        case *incomingSettings:
+                return l.incomingSettingsHandler(i)
+        case *outgoingSettings:
+                return l.outgoingSettingsHandler(i)
+        case *headerFrame:
+                return l.headerHandler(i)
+        case *registerStream:
+                return l.registerStreamHandler(i)
+        case *cleanupStream:
+                return l.cleanupStreamHandler(i)
+        case *incomingGoAway:
+                return l.incomingGoAwayHandler(i)
+        case *dataFrame:
+                return l.preprocessData(i)
+        case *ping:
+                return l.pingHandler(i)
+        case *goAway:
+                return l.goAwayHandler(i)
+        case *outFlowControlSizeRequest:
+                return l.outFlowControlSizeRequestHandler(i)
+        default:
+                return fmt.Errorf("transport: unknown control message type %T", i)
+        }
+}
+
+func (l *loopyWriter) applySettings(ss []http2.Setting) error {
+        for _, s := range ss {
+                switch s.ID {
+                case http2.SettingInitialWindowSize:
+                        o := l.oiws
+                        l.oiws = s.Val
+                        if o < l.oiws {
+                                // If the new limit is greater make all depleted streams active.
+                                for _, stream := range l.estdStreams {
+                                        if stream.state == waitingOnStreamQuota {
+                                                stream.state = active
+                                                l.activeStreams.enqueue(stream)
+                                        }
+                                }
+                        }
+                case http2.SettingHeaderTableSize:
+                        updateHeaderTblSize(l.hEnc, s.Val)
+                }
+        }
+        return nil
+}
+
+// processData removes the first stream from active streams, writes out at most 16KB
+// of its data and then puts it at the end of activeStreams if there's still more data
+// to be sent and stream has some stream-level flow control.
+func (l *loopyWriter) processData() (bool, error) {
+        if l.sendQuota == 0 {
+                return true, nil
+        }
+        str := l.activeStreams.dequeue() // Remove the first stream.
+        if str == nil {
+                return true, nil
+        }
+        dataItem := str.itl.peek().(*dataFrame) // Peek at the first data item this stream.
+        // A data item is represented by a dataFrame, since it later translates into
+        // multiple HTTP2 data frames.
+        // Every dataFrame has two buffers; h that keeps grpc-message header and d that is acutal data.
+        // As an optimization to keep wire traffic low, data from d is copied to h to make as big as the
+        // maximum possilbe HTTP2 frame size.
+
+        if len(dataItem.h) == 0 && len(dataItem.d) == 0 { // Empty data frame
+                // Client sends out empty data frame with endStream = true
+                if err := l.framer.fr.WriteData(dataItem.streamID, dataItem.endStream, nil); err != nil {
+                        return false, err
+                }
+                str.itl.dequeue() // remove the empty data item from stream
+                if str.itl.isEmpty() {
+                        str.state = empty
+                } else if trailer, ok := str.itl.peek().(*headerFrame); ok { // the next item is trailers.
+                        if err := l.writeHeader(trailer.streamID, trailer.endStream, trailer.hf, trailer.onWrite); err != nil {
+                                return false, err
+                        }
+                        if err := l.cleanupStreamHandler(trailer.cleanup); err != nil {
+                                return false, nil
+                        }
+                } else {
+                        l.activeStreams.enqueue(str)
+                }
+                return false, nil
+        }
+        var (
+                idx int
+                buf []byte
+        )
+        if len(dataItem.h) != 0 { // data header has not been written out yet.
+                buf = dataItem.h
+        } else {
+                idx = 1
+                buf = dataItem.d
+        }
+        size := http2MaxFrameLen
+        if len(buf) < size {
+                size = len(buf)
+        }
+        if strQuota := int(l.oiws) - str.bytesOutStanding; strQuota <= 0 { // stream-level flow control.
+                str.state = waitingOnStreamQuota
+                return false, nil
+        } else if strQuota < size {
+                size = strQuota
+        }
+
+        if l.sendQuota < uint32(size) { // connection-level flow control.
+                size = int(l.sendQuota)
+        }
+        // Now that outgoing flow controls are checked we can replenish str's write quota
+        str.wq.replenish(size)
+        var endStream bool
+        // If this is the last data message on this stream and all of it can be written in this iteration.
+        if dataItem.endStream && size == len(buf) {
+                // buf contains either data or it contains header but data is empty.
+                if idx == 1 || len(dataItem.d) == 0 {
+                        endStream = true
+                }
+        }
+        if dataItem.onEachWrite != nil {
+                dataItem.onEachWrite()
+        }
+        if err := l.framer.fr.WriteData(dataItem.streamID, endStream, buf[:size]); err != nil {
+                return false, err
+        }
+        buf = buf[size:]
+        str.bytesOutStanding += size
+        l.sendQuota -= uint32(size)
+        if idx == 0 {
+                dataItem.h = buf
+        } else {
+                dataItem.d = buf
+        }
+
+        if len(dataItem.h) == 0 && len(dataItem.d) == 0 { // All the data from that message was written out.
+                str.itl.dequeue()
+        }
+        if str.itl.isEmpty() {
+                str.state = empty
+        } else if trailer, ok := str.itl.peek().(*headerFrame); ok { // The next item is trailers.
+                if err := l.writeHeader(trailer.streamID, trailer.endStream, trailer.hf, trailer.onWrite); err != nil {
+                        return false, err
+                }
+                if err := l.cleanupStreamHandler(trailer.cleanup); err != nil {
+                        return false, err
+                }
+        } else if int(l.oiws)-str.bytesOutStanding <= 0 { // Ran out of stream quota.
+                str.state = waitingOnStreamQuota
+        } else { // Otherwise add it back to the list of active streams.
+                l.activeStreams.enqueue(str)
+        }
+        return false, nil
+}
diff --git a/vendor/google.golang.org/grpc/internal/transport/defaults.go b/vendor/google.golang.org/grpc/internal/transport/defaults.go
new file mode 100644
index 0000000..9fa306b
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/transport/defaults.go
@@ -0,0 +1,49 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package transport
+
+import (
+        "math"
+        "time"
+)
+
+const (
+        // The default value of flow control window size in HTTP2 spec.
+        defaultWindowSize = 65535
+        // The initial window size for flow control.
+        initialWindowSize             = defaultWindowSize // for an RPC
+        infinity                      = time.Duration(math.MaxInt64)
+        defaultClientKeepaliveTime    = infinity
+        defaultClientKeepaliveTimeout = 20 * time.Second
+        defaultMaxStreamsClient       = 100
+        defaultMaxConnectionIdle      = infinity
+        defaultMaxConnectionAge       = infinity
+        defaultMaxConnectionAgeGrace  = infinity
+        defaultServerKeepaliveTime    = 2 * time.Hour
+        defaultServerKeepaliveTimeout = 20 * time.Second
+        defaultKeepalivePolicyMinTime = 5 * time.Minute
+        // max window limit set by HTTP2 Specs.
+        maxWindowSize = math.MaxInt32
+        // defaultWriteQuota is the default value for number of data
+        // bytes that each stream can schedule before some of it being
+        // flushed out.
+        defaultWriteQuota              = 64 * 1024
+        defaultClientMaxHeaderListSize = uint32(16 << 20)
+        defaultServerMaxHeaderListSize = uint32(16 << 20)
+)
diff --git a/vendor/google.golang.org/grpc/transport/control.go b/vendor/google.golang.org/grpc/internal/transport/flowcontrol.go
index 501eb03..5ea997a 100644
--- a/vendor/google.golang.org/grpc/transport/control.go
+++ b/vendor/google.golang.org/grpc/internal/transport/flowcontrol.go
@@ -22,128 +22,102 @@ import (
         "fmt"
         "math"
         "sync"
-        "time"
-
-        "golang.org/x/net/http2"
-)
-
-const (
-        // The default value of flow control window size in HTTP2 spec.
-        defaultWindowSize = 65535
-        // The initial window size for flow control.
-        initialWindowSize             = defaultWindowSize // for an RPC
-        infinity                      = time.Duration(math.MaxInt64)
-        defaultClientKeepaliveTime    = infinity
-        defaultClientKeepaliveTimeout = time.Duration(20 * time.Second)
-        defaultMaxStreamsClient       = 100
-        defaultMaxConnectionIdle      = infinity
-        defaultMaxConnectionAge       = infinity
-        defaultMaxConnectionAgeGrace  = infinity
-        defaultServerKeepaliveTime    = time.Duration(2 * time.Hour)
-        defaultServerKeepaliveTimeout = time.Duration(20 * time.Second)
-        defaultKeepalivePolicyMinTime = time.Duration(5 * time.Minute)
-        // max window limit set by HTTP2 Specs.
-        maxWindowSize = math.MaxInt32
+        "sync/atomic"
 )
 
-// The following defines various control items which could flow through
-// the control buffer of transport. They represent different aspects of
-// control tasks, e.g., flow control, settings, streaming resetting, etc.
-type windowUpdate struct {
-        streamID  uint32
-        increment uint32
-        flush     bool
-}
-
-func (*windowUpdate) item() {}
-
-type settings struct {
-        ack bool
-        ss  []http2.Setting
+// writeQuota is a soft limit on the amount of data a stream can
+// schedule before some of it is written out.
+type writeQuota struct {
+        quota int32
+        // get waits on read from when quota goes less than or equal to zero.
+        // replenish writes on it when quota goes positive again.
+        ch chan struct{}
+        // done is triggered in error case.
+        done <-chan struct{}
+        // replenish is called by loopyWriter to give quota back to.
+        // It is implemented as a field so that it can be updated
+        // by tests.
+        replenish func(n int)
+}
+
+func newWriteQuota(sz int32, done <-chan struct{}) *writeQuota {
+        w := &writeQuota{
+                quota: sz,
+                ch:    make(chan struct{}, 1),
+                done:  done,
+        }
+        w.replenish = w.realReplenish
+        return w
 }
 
-func (*settings) item() {}
-
-type resetStream struct {
-        streamID uint32
-        code     http2.ErrCode
+func (w *writeQuota) get(sz int32) error {
+        for {
+                if atomic.LoadInt32(&w.quota) > 0 {
+                        atomic.AddInt32(&w.quota, -sz)
+                        return nil
+                }
+                select {
+                case <-w.ch:
+                        continue
+                case <-w.done:
+                        return errStreamDone
+                }
+        }
 }
 
-func (*resetStream) item() {}
-
-type goAway struct {
-        code      http2.ErrCode
-        debugData []byte
-        headsUp   bool
-        closeConn bool
+func (w *writeQuota) realReplenish(n int) {
+        sz := int32(n)
+        a := atomic.AddInt32(&w.quota, sz)
+        b := a - sz
+        if b <= 0 && a > 0 {
+                select {
+                case w.ch <- struct{}{}:
+                default:
+                }
+        }
 }
 
-func (*goAway) item() {}
-
-type flushIO struct {
+type trInFlow struct {
+        limit               uint32
+        unacked             uint32
+        effectiveWindowSize uint32
 }
 
-func (*flushIO) item() {}
-
-type ping struct {
-        ack  bool
-        data [8]byte
+func (f *trInFlow) newLimit(n uint32) uint32 {
+        d := n - f.limit
+        f.limit = n
+        f.updateEffectiveWindowSize()
+        return d
 }
 
-func (*ping) item() {}
-
-// quotaPool is a pool which accumulates the quota and sends it to acquire()
-// when it is available.
-type quotaPool struct {
-        c chan int
-
-        mu    sync.Mutex
-        quota int
+func (f *trInFlow) onData(n uint32) uint32 {
+        f.unacked += n
+        if f.unacked >= f.limit/4 {
+                w := f.unacked
+                f.unacked = 0
+                f.updateEffectiveWindowSize()
+                return w
+        }
+        f.updateEffectiveWindowSize()
+        return 0
 }
 
-// newQuotaPool creates a quotaPool which has quota q available to consume.
-func newQuotaPool(q int) *quotaPool {
-        qb := &quotaPool{
-                c: make(chan int, 1),
-        }
-        if q > 0 {
-                qb.c <- q
-        } else {
-                qb.quota = q
-        }
-        return qb
+func (f *trInFlow) reset() uint32 {
+        w := f.unacked
+        f.unacked = 0
+        f.updateEffectiveWindowSize()
+        return w
 }
 
-// add cancels the pending quota sent on acquired, incremented by v and sends
-// it back on acquire.
-func (qb *quotaPool) add(v int) {
-        qb.mu.Lock()
-        defer qb.mu.Unlock()
-        select {
-        case n := <-qb.c:
-                qb.quota += n
-        default:
-        }
-        qb.quota += v
-        if qb.quota <= 0 {
-                return
-        }
-        // After the pool has been created, this is the only place that sends on
-        // the channel. Since mu is held at this point and any quota that was sent
-        // on the channel has been retrieved, we know that this code will always
-        // place any positive quota value on the channel.
-        select {
-        case qb.c <- qb.quota:
-                qb.quota = 0
-        default:
-        }
+func (f *trInFlow) updateEffectiveWindowSize() {
+        atomic.StoreUint32(&f.effectiveWindowSize, f.limit-f.unacked)
 }
 
-// acquire returns the channel on which available quota amounts are sent.
-func (qb *quotaPool) acquire() <-chan int {
-        return qb.c
+func (f *trInFlow) getSize() uint32 {
+        return atomic.LoadUint32(&f.effectiveWindowSize)
 }
 
+// TODO(mmukhi): Simplify this code.
 // inFlow deals with inbound flow control
 type inFlow struct {
         mu sync.Mutex
@@ -164,9 +138,9 @@ type inFlow struct {
 // It assumes that n is always greater than the old limit.
 func (f *inFlow) newLimit(n uint32) uint32 {
         f.mu.Lock()
-        defer f.mu.Unlock()
         d := n - f.limit
         f.limit = n
+        f.mu.Unlock()
         return d
 }
 
@@ -175,7 +149,6 @@ func (f *inFlow) maybeAdjust(n uint32) uint32 {
                 n = uint32(math.MaxInt32)
         }
         f.mu.Lock()
-        defer f.mu.Unlock()
         // estSenderQuota is the receiver's view of the maximum number of bytes the sender
         // can send without a window update.
         estSenderQuota := int32(f.limit - (f.pendingData + f.pendingUpdate))
@@ -187,7 +160,7 @@ func (f *inFlow) maybeAdjust(n uint32) uint32 {
         // for this message. Therefore we must send an update over the limit since there's an active read
         // request from the application.
         if estUntransmittedData > estSenderQuota {
-                // Sender's window shouldn't go more than 2^31 - 1 as speecified in the HTTP spec.
+                // Sender's window shouldn't go more than 2^31 - 1 as specified in the HTTP spec.
                 if f.limit+n > maxWindowSize {
                         f.delta = maxWindowSize - f.limit
                 } else {
@@ -196,19 +169,24 @@ func (f *inFlow) maybeAdjust(n uint32) uint32 {
                         // is padded; We will fallback on the current available window(at least a 1/4th of the limit).
                         f.delta = n
                 }
+                f.mu.Unlock()
                 return f.delta
         }
+        f.mu.Unlock()
         return 0
 }
 
 // onData is invoked when some data frame is received. It updates pendingData.
 func (f *inFlow) onData(n uint32) error {
         f.mu.Lock()
-        defer f.mu.Unlock()
         f.pendingData += n
         if f.pendingData+f.pendingUpdate > f.limit+f.delta {
-                return fmt.Errorf("received %d-bytes data exceeding the limit %d bytes", f.pendingData+f.pendingUpdate, f.limit)
+                limit := f.limit
+                rcvd := f.pendingData + f.pendingUpdate
+                f.mu.Unlock()
+                return fmt.Errorf("received %d-bytes data exceeding the limit %d bytes", rcvd, limit)
         }
+        f.mu.Unlock()
         return nil
 }
 
@@ -216,8 +194,8 @@ func (f *inFlow) onData(n uint32) error {
 // to be sent to the peer.
 func (f *inFlow) onRead(n uint32) uint32 {
         f.mu.Lock()
-        defer f.mu.Unlock()
         if f.pendingData == 0 {
+                f.mu.Unlock()
                 return 0
         }
         f.pendingData -= n
@@ -232,15 +210,9 @@ func (f *inFlow) onRead(n uint32) uint32 {
         if f.pendingUpdate >= f.limit/4 {
                 wu := f.pendingUpdate
                 f.pendingUpdate = 0
+                f.mu.Unlock()
                 return wu
         }
+        f.mu.Unlock()
         return 0
 }
-
-func (f *inFlow) resetPendingUpdate() uint32 {
-        f.mu.Lock()
-        defer f.mu.Unlock()
-        n := f.pendingUpdate
-        f.pendingUpdate = 0
-        return n
-}
diff --git a/vendor/google.golang.org/grpc/transport/handler_server.go b/vendor/google.golang.org/grpc/internal/transport/handler_server.go
index 27372b5..73b41ea 100644
--- a/vendor/google.golang.org/grpc/transport/handler_server.go
+++ b/vendor/google.golang.org/grpc/internal/transport/handler_server.go
@@ -24,6 +24,7 @@
 package transport
 
 import (
+        "context"
         "errors"
         "fmt"
         "io"
@@ -33,26 +34,30 @@ import (
         "sync"
         "time"
 
-        "golang.org/x/net/context"
+        "github.com/golang/protobuf/proto"
         "golang.org/x/net/http2"
         "google.golang.org/grpc/codes"
         "google.golang.org/grpc/credentials"
         "google.golang.org/grpc/metadata"
         "google.golang.org/grpc/peer"
+        "google.golang.org/grpc/stats"
         "google.golang.org/grpc/status"
 )
 
 // NewServerHandlerTransport returns a ServerTransport handling gRPC
 // from inside an http.Handler. It requires that the http Server
 // supports HTTP/2.
-func NewServerHandlerTransport(w http.ResponseWriter, r *http.Request) (ServerTransport, error) {
+func NewServerHandlerTransport(w http.ResponseWriter, r *http.Request, stats stats.Handler) (ServerTransport, error) {
         if r.ProtoMajor != 2 {
                 return nil, errors.New("gRPC requires HTTP/2")
         }
         if r.Method != "POST" {
                 return nil, errors.New("invalid gRPC request method")
         }
-        if !validContentType(r.Header.Get("Content-Type")) {
+        contentType := r.Header.Get("Content-Type")
+        // TODO: do we assume contentType is lowercase? we did before
+        contentSubtype, validContentType := contentSubtype(contentType)
+        if !validContentType {
                 return nil, errors.New("invalid gRPC request content-type")
         }
         if _, ok := w.(http.Flusher); !ok {
@@ -63,34 +68,37 @@ func NewServerHandlerTransport(w http.ResponseWriter, r *http.Request) (ServerTr
         }
 
         st := &serverHandlerTransport{
-                rw:       w,
-                req:      r,
-                closedCh: make(chan struct{}),
-                writes:   make(chan func()),
+                rw:             w,
+                req:            r,
+                closedCh:       make(chan struct{}),
+                writes:         make(chan func()),
+                contentType:    contentType,
+                contentSubtype: contentSubtype,
+                stats:          stats,
         }
 
         if v := r.Header.Get("grpc-timeout"); v != "" {
                 to, err := decodeTimeout(v)
                 if err != nil {
-                        return nil, streamErrorf(codes.Internal, "malformed time-out: %v", err)
+                        return nil, status.Errorf(codes.Internal, "malformed time-out: %v", err)
                 }
                 st.timeoutSet = true
                 st.timeout = to
         }
 
-        var metakv []string
+        metakv := []string{"content-type", contentType}
         if r.Host != "" {
                 metakv = append(metakv, ":authority", r.Host)
         }
         for k, vv := range r.Header {
                 k = strings.ToLower(k)
-                if isReservedHeader(k) && !isWhitelistedPseudoHeader(k) {
+                if isReservedHeader(k) && !isWhitelistedHeader(k) {
                         continue
                 }
                 for _, v := range vv {
                         v, err := decodeMetadataHeader(k, v)
                         if err != nil {
-                                return nil, streamErrorf(codes.InvalidArgument, "malformed binary metadata: %v", err)
+                                return nil, status.Errorf(codes.Internal, "malformed binary metadata: %v", err)
                         }
                         metakv = append(metakv, k, v)
                 }
@@ -121,6 +129,18 @@ type serverHandlerTransport struct {
         // ServeHTTP (HandleStreams) goroutine. The channel is closed
         // when WriteStatus is called.
         writes chan func()
+
+        // block concurrent WriteStatus calls
+        // e.g. grpc/(*serverStream).SendMsg/RecvMsg
+        writeStatusMu sync.Mutex
+
+        // we just mirror the request content-type
+        contentType string
+        // we store both contentType and contentSubtype so we don't keep recreating them
+        // TODO make sure this is consistent across handler_server and http2_server
+        contentSubtype string
+
+        stats stats.Handler
 }
 
 func (ht *serverHandlerTransport) Close() error {
@@ -167,11 +187,13 @@ func (ht *serverHandlerTransport) do(fn func()) error {
                 case <-ht.closedCh:
                         return ErrConnClosing
                 }
-
         }
 }
 
 func (ht *serverHandlerTransport) WriteStatus(s *Stream, st *status.Status) error {
+        ht.writeStatusMu.Lock()
+        defer ht.writeStatusMu.Unlock()
+
         err := ht.do(func() {
                 ht.writeCommonHeaders(s)
 
@@ -186,7 +208,15 @@ func (ht *serverHandlerTransport) WriteStatus(s *Stream, st *status.Status) erro
                         h.Set("Grpc-Message", encodeGrpcMessage(m))
                 }
 
-                // TODO: Support Grpc-Status-Details-Bin
+                if p := st.Proto(); p != nil && len(p.Details) > 0 {
+                        stBytes, err := proto.Marshal(p)
+                        if err != nil {
+                                // TODO: return error instead, when callers are able to handle it.
+                                panic(err)
+                        }
+
+                        h.Set("Grpc-Status-Details-Bin", encodeBinHeader(stBytes))
+                }
 
                 if md := s.Trailer(); len(md) > 0 {
                         for k, vv := range md {
@@ -202,7 +232,14 @@ func (ht *serverHandlerTransport) WriteStatus(s *Stream, st *status.Status) erro
                         }
                 }
         })
-        close(ht.writes)
+
+        if err == nil { // transport has not been closed
+                if ht.stats != nil {
+                        ht.stats.HandleRPC(s.Context(), &stats.OutTrailer{})
+                }
+                close(ht.writes)
+        }
+        ht.Close()
         return err
 }
 
@@ -216,7 +253,7 @@ func (ht *serverHandlerTransport) writeCommonHeaders(s *Stream) {
 
         h := ht.rw.Header()
         h["Date"] = nil // suppress Date to make tests happy; TODO: restore
-        h.Set("Content-Type", "application/grpc")
+        h.Set("Content-Type", ht.contentType)
 
         // Predeclare trailers we'll set later in WriteStatus (after the body).
         // This is a SHOULD in the HTTP RFC, and the way you add (known)
@@ -225,25 +262,24 @@ func (ht *serverHandlerTransport) writeCommonHeaders(s *Stream) {
         // and https://golang.org/pkg/net/http/#example_ResponseWriter_trailers
         h.Add("Trailer", "Grpc-Status")
         h.Add("Trailer", "Grpc-Message")
-        // TODO: Support Grpc-Status-Details-Bin
+        h.Add("Trailer", "Grpc-Status-Details-Bin")
 
         if s.sendCompress != "" {
                 h.Set("Grpc-Encoding", s.sendCompress)
         }
 }
 
-func (ht *serverHandlerTransport) Write(s *Stream, data []byte, opts *Options) error {
+func (ht *serverHandlerTransport) Write(s *Stream, hdr []byte, data []byte, opts *Options) error {
         return ht.do(func() {
                 ht.writeCommonHeaders(s)
+                ht.rw.Write(hdr)
                 ht.rw.Write(data)
-                if !opts.Delay {
-                        ht.rw.(http.Flusher).Flush()
-                }
+                ht.rw.(http.Flusher).Flush()
         })
 }
 
 func (ht *serverHandlerTransport) WriteHeader(s *Stream, md metadata.MD) error {
-        return ht.do(func() {
+        err := ht.do(func() {
                 ht.writeCommonHeaders(s)
                 h := ht.rw.Header()
                 for k, vv := range md {
@@ -259,17 +295,24 @@ func (ht *serverHandlerTransport) WriteHeader(s *Stream, md metadata.MD) error {
                 ht.rw.WriteHeader(200)
                 ht.rw.(http.Flusher).Flush()
         })
+
+        if err == nil {
+                if ht.stats != nil {
+                        ht.stats.HandleRPC(s.Context(), &stats.OutHeader{})
+                }
+        }
+        return err
 }
 
 func (ht *serverHandlerTransport) HandleStreams(startStream func(*Stream), traceCtx func(context.Context, string) context.Context) {
         // With this transport type there will be exactly 1 stream: this HTTP request.
 
-        var ctx context.Context
+        ctx := ht.req.Context()
         var cancel context.CancelFunc
         if ht.timeoutSet {
-                ctx, cancel = context.WithTimeout(context.Background(), ht.timeout)
+                ctx, cancel = context.WithTimeout(ctx, ht.timeout)
         } else {
-                ctx, cancel = context.WithCancel(context.Background())
+                ctx, cancel = context.WithCancel(ctx)
         }
 
         // requestOver is closed when either the request's context is done
@@ -283,23 +326,24 @@ func (ht *serverHandlerTransport) HandleStreams(startStream func(*Stream), trace
         go func() {
                 select {
                 case <-requestOver:
-                        return
                 case <-ht.closedCh:
                 case <-clientGone:
                 }
                 cancel()
+                ht.Close()
         }()
 
         req := ht.req
 
         s := &Stream{
-                id:           0, // irrelevant
-                requestRead:  func(int) {},
-                cancel:       cancel,
-                buf:          newRecvBuffer(),
-                st:           ht,
-                method:       req.URL.Path,
-                recvCompress: req.Header.Get("grpc-encoding"),
+                id:             0, // irrelevant
+                requestRead:    func(int) {},
+                cancel:         cancel,
+                buf:            newRecvBuffer(),
+                st:             ht,
+                method:         req.URL.Path,
+                recvCompress:   req.Header.Get("grpc-encoding"),
+                contentSubtype: ht.contentSubtype,
         }
         pr := &peer.Peer{
                 Addr: ht.RemoteAddr(),
@@ -308,10 +352,18 @@ func (ht *serverHandlerTransport) HandleStreams(startStream func(*Stream), trace
                 pr.AuthInfo = credentials.TLSInfo{State: *req.TLS}
         }
         ctx = metadata.NewIncomingContext(ctx, ht.headerMD)
-        ctx = peer.NewContext(ctx, pr)
-        s.ctx = newContextWithStream(ctx, s)
+        s.ctx = peer.NewContext(ctx, pr)
+        if ht.stats != nil {
+                s.ctx = ht.stats.TagRPC(s.ctx, &stats.RPCTagInfo{FullMethodName: s.method})
+                inHeader := &stats.InHeader{
+                        FullMethod:  s.method,
+                        RemoteAddr:  ht.RemoteAddr(),
+                        Compression: s.recvCompress,
+                }
+                ht.stats.HandleRPC(s.ctx, inHeader)
+        }
         s.trReader = &transportReader{
-                reader:        &recvBufferReader{ctx: s.ctx, recv: s.buf},
+                reader:        &recvBufferReader{ctx: s.ctx, ctxDone: s.ctx.Done(), recv: s.buf},
                 windowHandler: func(int) {},
         }
 
@@ -366,6 +418,10 @@ func (ht *serverHandlerTransport) runStream() {
         }
 }
 
+func (ht *serverHandlerTransport) IncrMsgSent() {}
+
+func (ht *serverHandlerTransport) IncrMsgRecv() {}
+
 func (ht *serverHandlerTransport) Drain() {
         panic("Drain() is not implemented")
 }
@@ -376,18 +432,18 @@ func (ht *serverHandlerTransport) Drain() {
 //   * io.EOF
 //   * io.ErrUnexpectedEOF
 //   * of type transport.ConnectionError
-//   * of type transport.StreamError
+//   * an error from the status package
 func mapRecvMsgError(err error) error {
         if err == io.EOF || err == io.ErrUnexpectedEOF {
                 return err
         }
         if se, ok := err.(http2.StreamError); ok {
                 if code, ok := http2ErrConvTab[se.Code]; ok {
-                        return StreamError{
-                                Code: code,
-                                Desc: se.Error(),
-                        }
+                        return status.Error(code, se.Error())
                 }
         }
+        if strings.Contains(err.Error(), "body closed by handler") {
+                return status.Error(codes.Canceled, err.Error())
+        }
         return connectionErrorf(true, err, err.Error())
 }
diff --git a/vendor/google.golang.org/grpc/internal/transport/http2_client.go b/vendor/google.golang.org/grpc/internal/transport/http2_client.go
new file mode 100644
index 0000000..babcaee
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/transport/http2_client.go
@@ -0,0 +1,1380 @@
+/*
+ *
+ * Copyright 2014 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package transport
+
+import (
+        "context"
+        "fmt"
+        "io"
+        "math"
+        "net"
+        "strconv"
+        "strings"
+        "sync"
+        "sync/atomic"
+        "time"
+
+        "golang.org/x/net/http2"
+        "golang.org/x/net/http2/hpack"
+
+        "google.golang.org/grpc/codes"
+        "google.golang.org/grpc/credentials"
+        "google.golang.org/grpc/internal/channelz"
+        "google.golang.org/grpc/internal/syscall"
+        "google.golang.org/grpc/keepalive"
+        "google.golang.org/grpc/metadata"
+        "google.golang.org/grpc/peer"
+        "google.golang.org/grpc/stats"
+        "google.golang.org/grpc/status"
+)
+
+// http2Client implements the ClientTransport interface with HTTP2.
+type http2Client struct {
+        ctx        context.Context
+        cancel     context.CancelFunc
+        ctxDone    <-chan struct{} // Cache the ctx.Done() chan.
+        userAgent  string
+        md         interface{}
+        conn       net.Conn // underlying communication channel
+        loopy      *loopyWriter
+        remoteAddr net.Addr
+        localAddr  net.Addr
+        authInfo   credentials.AuthInfo // auth info about the connection
+
+        readerDone chan struct{} // sync point to enable testing.
+        writerDone chan struct{} // sync point to enable testing.
+        // goAway is closed to notify the upper layer (i.e., addrConn.transportMonitor)
+        // that the server sent GoAway on this transport.
+        goAway chan struct{}
+        // awakenKeepalive is used to wake up keepalive when after it has gone dormant.
+        awakenKeepalive chan struct{}
+
+        framer *framer
+        // controlBuf delivers all the control related tasks (e.g., window
+        // updates, reset streams, and various settings) to the controller.
+        controlBuf *controlBuffer
+        fc         *trInFlow
+        // The scheme used: https if TLS is on, http otherwise.
+        scheme string
+
+        isSecure bool
+
+        perRPCCreds []credentials.PerRPCCredentials
+
+        // Boolean to keep track of reading activity on transport.
+        // 1 is true and 0 is false.
+        activity         uint32 // Accessed atomically.
+        kp               keepalive.ClientParameters
+        keepaliveEnabled bool
+
+        statsHandler stats.Handler
+
+        initialWindowSize int32
+
+        // configured by peer through SETTINGS_MAX_HEADER_LIST_SIZE
+        maxSendHeaderListSize *uint32
+
+        bdpEst *bdpEstimator
+        // onPrefaceReceipt is a callback that client transport calls upon
+        // receiving server preface to signal that a succefull HTTP2
+        // connection was established.
+        onPrefaceReceipt func()
+
+        maxConcurrentStreams  uint32
+        streamQuota           int64
+        streamsQuotaAvailable chan struct{}
+        waitingStreams        uint32
+        nextID                uint32
+
+        mu            sync.Mutex // guard the following variables
+        state         transportState
+        activeStreams map[uint32]*Stream
+        // prevGoAway ID records the Last-Stream-ID in the previous GOAway frame.
+        prevGoAwayID uint32
+        // goAwayReason records the http2.ErrCode and debug data received with the
+        // GoAway frame.
+        goAwayReason GoAwayReason
+
+        // Fields below are for channelz metric collection.
+        channelzID int64 // channelz unique identification number
+        czData     *channelzData
+
+        onGoAway func(GoAwayReason)
+        onClose  func()
+}
+
+func dial(ctx context.Context, fn func(context.Context, string) (net.Conn, error), addr string) (net.Conn, error) {
+        if fn != nil {
+                return fn(ctx, addr)
+        }
+        return (&net.Dialer{}).DialContext(ctx, "tcp", addr)
+}
+
+func isTemporary(err error) bool {
+        switch err := err.(type) {
+        case interface {
+                Temporary() bool
+        }:
+                return err.Temporary()
+        case interface {
+                Timeout() bool
+        }:
+                // Timeouts may be resolved upon retry, and are thus treated as
+                // temporary.
+                return err.Timeout()
+        }
+        return true
+}
+
+// newHTTP2Client constructs a connected ClientTransport to addr based on HTTP2
+// and starts to receive messages on it. Non-nil error returns if construction
+// fails.
+func newHTTP2Client(connectCtx, ctx context.Context, addr TargetInfo, opts ConnectOptions, onPrefaceReceipt func(), onGoAway func(GoAwayReason), onClose func()) (_ *http2Client, err error) {
+        scheme := "http"
+        ctx, cancel := context.WithCancel(ctx)
+        defer func() {
+                if err != nil {
+                        cancel()
+                }
+        }()
+
+        conn, err := dial(connectCtx, opts.Dialer, addr.Addr)
+        if err != nil {
+                if opts.FailOnNonTempDialError {
+                        return nil, connectionErrorf(isTemporary(err), err, "transport: error while dialing: %v", err)
+                }
+                return nil, connectionErrorf(true, err, "transport: Error while dialing %v", err)
+        }
+        // Any further errors will close the underlying connection
+        defer func(conn net.Conn) {
+                if err != nil {
+                        conn.Close()
+                }
+        }(conn)
+        kp := opts.KeepaliveParams
+        // Validate keepalive parameters.
+        if kp.Time == 0 {
+                kp.Time = defaultClientKeepaliveTime
+        }
+        if kp.Timeout == 0 {
+                kp.Timeout = defaultClientKeepaliveTimeout
+        }
+        keepaliveEnabled := false
+        if kp.Time != infinity {
+                if err = syscall.SetTCPUserTimeout(conn, kp.Timeout); err != nil {
+                        return nil, connectionErrorf(false, err, "transport: failed to set TCP_USER_TIMEOUT: %v", err)
+                }
+                keepaliveEnabled = true
+        }
+        var (
+                isSecure bool
+                authInfo credentials.AuthInfo
+        )
+        transportCreds := opts.TransportCredentials
+        perRPCCreds := opts.PerRPCCredentials
+
+        if b := opts.CredsBundle; b != nil {
+                if t := b.TransportCredentials(); t != nil {
+                        transportCreds = t
+                }
+                if t := b.PerRPCCredentials(); t != nil {
+                        perRPCCreds = append(perRPCCreds, t)
+                }
+        }
+        if transportCreds != nil {
+                scheme = "https"
+                conn, authInfo, err = transportCreds.ClientHandshake(connectCtx, addr.Authority, conn)
+                if err != nil {
+                        return nil, connectionErrorf(isTemporary(err), err, "transport: authentication handshake failed: %v", err)
+                }
+                isSecure = true
+        }
+        dynamicWindow := true
+        icwz := int32(initialWindowSize)
+        if opts.InitialConnWindowSize >= defaultWindowSize {
+                icwz = opts.InitialConnWindowSize
+                dynamicWindow = false
+        }
+        writeBufSize := opts.WriteBufferSize
+        readBufSize := opts.ReadBufferSize
+        maxHeaderListSize := defaultClientMaxHeaderListSize
+        if opts.MaxHeaderListSize != nil {
+                maxHeaderListSize = *opts.MaxHeaderListSize
+        }
+        t := &http2Client{
+                ctx:                   ctx,
+                ctxDone:               ctx.Done(), // Cache Done chan.
+                cancel:                cancel,
+                userAgent:             opts.UserAgent,
+                md:                    addr.Metadata,
+                conn:                  conn,
+                remoteAddr:            conn.RemoteAddr(),
+                localAddr:             conn.LocalAddr(),
+                authInfo:              authInfo,
+                readerDone:            make(chan struct{}),
+                writerDone:            make(chan struct{}),
+                goAway:                make(chan struct{}),
+                awakenKeepalive:       make(chan struct{}, 1),
+                framer:                newFramer(conn, writeBufSize, readBufSize, maxHeaderListSize),
+                fc:                    &trInFlow{limit: uint32(icwz)},
+                scheme:                scheme,
+                activeStreams:         make(map[uint32]*Stream),
+                isSecure:              isSecure,
+                perRPCCreds:           perRPCCreds,
+                kp:                    kp,
+                statsHandler:          opts.StatsHandler,
+                initialWindowSize:     initialWindowSize,
+                onPrefaceReceipt:      onPrefaceReceipt,
+                nextID:                1,
+                maxConcurrentStreams:  defaultMaxStreamsClient,
+                streamQuota:           defaultMaxStreamsClient,
+                streamsQuotaAvailable: make(chan struct{}, 1),
+                czData:                new(channelzData),
+                onGoAway:              onGoAway,
+                onClose:               onClose,
+                keepaliveEnabled:      keepaliveEnabled,
+        }
+        t.controlBuf = newControlBuffer(t.ctxDone)
+        if opts.InitialWindowSize >= defaultWindowSize {
+                t.initialWindowSize = opts.InitialWindowSize
+                dynamicWindow = false
+        }
+        if dynamicWindow {
+                t.bdpEst = &bdpEstimator{
+                        bdp:               initialWindowSize,
+                        updateFlowControl: t.updateFlowControl,
+                }
+        }
+        // Make sure awakenKeepalive can't be written upon.
+        // keepalive routine will make it writable, if need be.
+        t.awakenKeepalive <- struct{}{}
+        if t.statsHandler != nil {
+                t.ctx = t.statsHandler.TagConn(t.ctx, &stats.ConnTagInfo{
+                        RemoteAddr: t.remoteAddr,
+                        LocalAddr:  t.localAddr,
+                })
+                connBegin := &stats.ConnBegin{
+                        Client: true,
+                }
+                t.statsHandler.HandleConn(t.ctx, connBegin)
+        }
+        if channelz.IsOn() {
+                t.channelzID = channelz.RegisterNormalSocket(t, opts.ChannelzParentID, fmt.Sprintf("%s -> %s", t.localAddr, t.remoteAddr))
+        }
+        if t.keepaliveEnabled {
+                go t.keepalive()
+        }
+        // Start the reader goroutine for incoming message. Each transport has
+        // a dedicated goroutine which reads HTTP2 frame from network. Then it
+        // dispatches the frame to the corresponding stream entity.
+        go t.reader()
+
+        // Send connection preface to server.
+        n, err := t.conn.Write(clientPreface)
+        if err != nil {
+                t.Close()
+                return nil, connectionErrorf(true, err, "transport: failed to write client preface: %v", err)
+        }
+        if n != len(clientPreface) {
+                t.Close()
+                return nil, connectionErrorf(true, err, "transport: preface mismatch, wrote %d bytes; want %d", n, len(clientPreface))
+        }
+        var ss []http2.Setting
+
+        if t.initialWindowSize != defaultWindowSize {
+                ss = append(ss, http2.Setting{
+                        ID:  http2.SettingInitialWindowSize,
+                        Val: uint32(t.initialWindowSize),
+                })
+        }
+        if opts.MaxHeaderListSize != nil {
+                ss = append(ss, http2.Setting{
+                        ID:  http2.SettingMaxHeaderListSize,
+                        Val: *opts.MaxHeaderListSize,
+                })
+        }
+        err = t.framer.fr.WriteSettings(ss...)
+        if err != nil {
+                t.Close()
+                return nil, connectionErrorf(true, err, "transport: failed to write initial settings frame: %v", err)
+        }
+        // Adjust the connection flow control window if needed.
+        if delta := uint32(icwz - defaultWindowSize); delta > 0 {
+                if err := t.framer.fr.WriteWindowUpdate(0, delta); err != nil {
+                        t.Close()
+                        return nil, connectionErrorf(true, err, "transport: failed to write window update: %v", err)
+                }
+        }
+
+        t.framer.writer.Flush()
+        go func() {
+                t.loopy = newLoopyWriter(clientSide, t.framer, t.controlBuf, t.bdpEst)
+                err := t.loopy.run()
+                if err != nil {
+                        errorf("transport: loopyWriter.run returning. Err: %v", err)
+                }
+                // If it's a connection error, let reader goroutine handle it
+                // since there might be data in the buffers.
+                if _, ok := err.(net.Error); !ok {
+                        t.conn.Close()
+                }
+                close(t.writerDone)
+        }()
+        return t, nil
+}
+
+func (t *http2Client) newStream(ctx context.Context, callHdr *CallHdr) *Stream {
+        // TODO(zhaoq): Handle uint32 overflow of Stream.id.
+        s := &Stream{
+                done:           make(chan struct{}),
+                method:         callHdr.Method,
+                sendCompress:   callHdr.SendCompress,
+                buf:            newRecvBuffer(),
+                headerChan:     make(chan struct{}),
+                contentSubtype: callHdr.ContentSubtype,
+        }
+        s.wq = newWriteQuota(defaultWriteQuota, s.done)
+        s.requestRead = func(n int) {
+                t.adjustWindow(s, uint32(n))
+        }
+        // The client side stream context should have exactly the same life cycle with the user provided context.
+        // That means, s.ctx should be read-only. And s.ctx is done iff ctx is done.
+        // So we use the original context here instead of creating a copy.
+        s.ctx = ctx
+        s.trReader = &transportReader{
+                reader: &recvBufferReader{
+                        ctx:     s.ctx,
+                        ctxDone: s.ctx.Done(),
+                        recv:    s.buf,
+                        closeStream: func(err error) {
+                                t.CloseStream(s, err)
+                        },
+                },
+                windowHandler: func(n int) {
+                        t.updateWindow(s, uint32(n))
+                },
+        }
+        return s
+}
+
+func (t *http2Client) getPeer() *peer.Peer {
+        pr := &peer.Peer{
+                Addr: t.remoteAddr,
+        }
+        // Attach Auth info if there is any.
+        if t.authInfo != nil {
+                pr.AuthInfo = t.authInfo
+        }
+        return pr
+}
+
+func (t *http2Client) createHeaderFields(ctx context.Context, callHdr *CallHdr) ([]hpack.HeaderField, error) {
+        aud := t.createAudience(callHdr)
+        authData, err := t.getTrAuthData(ctx, aud)
+        if err != nil {
+                return nil, err
+        }
+        callAuthData, err := t.getCallAuthData(ctx, aud, callHdr)
+        if err != nil {
+                return nil, err
+        }
+        // TODO(mmukhi): Benchmark if the performance gets better if count the metadata and other header fields
+        // first and create a slice of that exact size.
+        // Make the slice of certain predictable size to reduce allocations made by append.
+        hfLen := 7 // :method, :scheme, :path, :authority, content-type, user-agent, te
+        hfLen += len(authData) + len(callAuthData)
+        headerFields := make([]hpack.HeaderField, 0, hfLen)
+        headerFields = append(headerFields, hpack.HeaderField{Name: ":method", Value: "POST"})
+        headerFields = append(headerFields, hpack.HeaderField{Name: ":scheme", Value: t.scheme})
+        headerFields = append(headerFields, hpack.HeaderField{Name: ":path", Value: callHdr.Method})
+        headerFields = append(headerFields, hpack.HeaderField{Name: ":authority", Value: callHdr.Host})
+        headerFields = append(headerFields, hpack.HeaderField{Name: "content-type", Value: contentType(callHdr.ContentSubtype)})
+        headerFields = append(headerFields, hpack.HeaderField{Name: "user-agent", Value: t.userAgent})
+        headerFields = append(headerFields, hpack.HeaderField{Name: "te", Value: "trailers"})
+        if callHdr.PreviousAttempts > 0 {
+                headerFields = append(headerFields, hpack.HeaderField{Name: "grpc-previous-rpc-attempts", Value: strconv.Itoa(callHdr.PreviousAttempts)})
+        }
+
+        if callHdr.SendCompress != "" {
+                headerFields = append(headerFields, hpack.HeaderField{Name: "grpc-encoding", Value: callHdr.SendCompress})
+        }
+        if dl, ok := ctx.Deadline(); ok {
+                // Send out timeout regardless its value. The server can detect timeout context by itself.
+                // TODO(mmukhi): Perhaps this field should be updated when actually writing out to the wire.
+                timeout := dl.Sub(time.Now())
+                headerFields = append(headerFields, hpack.HeaderField{Name: "grpc-timeout", Value: encodeTimeout(timeout)})
+        }
+        for k, v := range authData {
+                headerFields = append(headerFields, hpack.HeaderField{Name: k, Value: encodeMetadataHeader(k, v)})
+        }
+        for k, v := range callAuthData {
+                headerFields = append(headerFields, hpack.HeaderField{Name: k, Value: encodeMetadataHeader(k, v)})
+        }
+        if b := stats.OutgoingTags(ctx); b != nil {
+                headerFields = append(headerFields, hpack.HeaderField{Name: "grpc-tags-bin", Value: encodeBinHeader(b)})
+        }
+        if b := stats.OutgoingTrace(ctx); b != nil {
+                headerFields = append(headerFields, hpack.HeaderField{Name: "grpc-trace-bin", Value: encodeBinHeader(b)})
+        }
+
+        if md, added, ok := metadata.FromOutgoingContextRaw(ctx); ok {
+                var k string
+                for _, vv := range added {
+                        for i, v := range vv {
+                                if i%2 == 0 {
+                                        k = v
+                                        continue
+                                }
+                                // HTTP doesn't allow you to set pseudoheaders after non pseudoheaders were set.
+                                if isReservedHeader(k) {
+                                        continue
+                                }
+                                headerFields = append(headerFields, hpack.HeaderField{Name: strings.ToLower(k), Value: encodeMetadataHeader(k, v)})
+                        }
+                }
+                for k, vv := range md {
+                        // HTTP doesn't allow you to set pseudoheaders after non pseudoheaders were set.
+                        if isReservedHeader(k) {
+                                continue
+                        }
+                        for _, v := range vv {
+                                headerFields = append(headerFields, hpack.HeaderField{Name: k, Value: encodeMetadataHeader(k, v)})
+                        }
+                }
+        }
+        if md, ok := t.md.(*metadata.MD); ok {
+                for k, vv := range *md {
+                        if isReservedHeader(k) {
+                                continue
+                        }
+                        for _, v := range vv {
+                                headerFields = append(headerFields, hpack.HeaderField{Name: k, Value: encodeMetadataHeader(k, v)})
+                        }
+                }
+        }
+        return headerFields, nil
+}
+
+func (t *http2Client) createAudience(callHdr *CallHdr) string {
+        // Create an audience string only if needed.
+        if len(t.perRPCCreds) == 0 && callHdr.Creds == nil {
+                return ""
+        }
+        // Construct URI required to get auth request metadata.
+        // Omit port if it is the default one.
+        host := strings.TrimSuffix(callHdr.Host, ":443")
+        pos := strings.LastIndex(callHdr.Method, "/")
+        if pos == -1 {
+                pos = len(callHdr.Method)
+        }
+        return "https://" + host + callHdr.Method[:pos]
+}
+
+func (t *http2Client) getTrAuthData(ctx context.Context, audience string) (map[string]string, error) {
+        authData := map[string]string{}
+        for _, c := range t.perRPCCreds {
+                data, err := c.GetRequestMetadata(ctx, audience)
+                if err != nil {
+                        if _, ok := status.FromError(err); ok {
+                                return nil, err
+                        }
+
+                        return nil, status.Errorf(codes.Unauthenticated, "transport: %v", err)
+                }
+                for k, v := range data {
+                        // Capital header names are illegal in HTTP/2.
+                        k = strings.ToLower(k)
+                        authData[k] = v
+                }
+        }
+        return authData, nil
+}
+
+func (t *http2Client) getCallAuthData(ctx context.Context, audience string, callHdr *CallHdr) (map[string]string, error) {
+        callAuthData := map[string]string{}
+        // Check if credentials.PerRPCCredentials were provided via call options.
+        // Note: if these credentials are provided both via dial options and call
+        // options, then both sets of credentials will be applied.
+        if callCreds := callHdr.Creds; callCreds != nil {
+                if !t.isSecure && callCreds.RequireTransportSecurity() {
+                        return nil, status.Error(codes.Unauthenticated, "transport: cannot send secure credentials on an insecure connection")
+                }
+                data, err := callCreds.GetRequestMetadata(ctx, audience)
+                if err != nil {
+                        return nil, status.Errorf(codes.Internal, "transport: %v", err)
+                }
+                for k, v := range data {
+                        // Capital header names are illegal in HTTP/2
+                        k = strings.ToLower(k)
+                        callAuthData[k] = v
+                }
+        }
+        return callAuthData, nil
+}
+
+// NewStream creates a stream and registers it into the transport as "active"
+// streams.
+func (t *http2Client) NewStream(ctx context.Context, callHdr *CallHdr) (_ *Stream, err error) {
+        ctx = peer.NewContext(ctx, t.getPeer())
+        headerFields, err := t.createHeaderFields(ctx, callHdr)
+        if err != nil {
+                return nil, err
+        }
+        s := t.newStream(ctx, callHdr)
+        cleanup := func(err error) {
+                if s.swapState(streamDone) == streamDone {
+                        // If it was already done, return.
+                        return
+                }
+                // The stream was unprocessed by the server.
+                atomic.StoreUint32(&s.unprocessed, 1)
+                s.write(recvMsg{err: err})
+                close(s.done)
+                // If headerChan isn't closed, then close it.
+                if atomic.SwapUint32(&s.headerDone, 1) == 0 {
+                        close(s.headerChan)
+                }
+
+        }
+        hdr := &headerFrame{
+                hf:        headerFields,
+                endStream: false,
+                initStream: func(id uint32) (bool, error) {
+                        t.mu.Lock()
+                        if state := t.state; state != reachable {
+                                t.mu.Unlock()
+                                // Do a quick cleanup.
+                                err := error(errStreamDrain)
+                                if state == closing {
+                                        err = ErrConnClosing
+                                }
+                                cleanup(err)
+                                return false, err
+                        }
+                        t.activeStreams[id] = s
+                        if channelz.IsOn() {
+                                atomic.AddInt64(&t.czData.streamsStarted, 1)
+                                atomic.StoreInt64(&t.czData.lastStreamCreatedTime, time.Now().UnixNano())
+                        }
+                        var sendPing bool
+                        // If the number of active streams change from 0 to 1, then check if keepalive
+                        // has gone dormant. If so, wake it up.
+                        if len(t.activeStreams) == 1 && t.keepaliveEnabled {
+                                select {
+                                case t.awakenKeepalive <- struct{}{}:
+                                        sendPing = true
+                                        // Fill the awakenKeepalive channel again as this channel must be
+                                        // kept non-writable except at the point that the keepalive()
+                                        // goroutine is waiting either to be awaken or shutdown.
+                                        t.awakenKeepalive <- struct{}{}
+                                default:
+                                }
+                        }
+                        t.mu.Unlock()
+                        return sendPing, nil
+                },
+                onOrphaned: cleanup,
+                wq:         s.wq,
+        }
+        firstTry := true
+        var ch chan struct{}
+        checkForStreamQuota := func(it interface{}) bool {
+                if t.streamQuota <= 0 { // Can go negative if server decreases it.
+                        if firstTry {
+                                t.waitingStreams++
+                        }
+                        ch = t.streamsQuotaAvailable
+                        return false
+                }
+                if !firstTry {
+                        t.waitingStreams--
+                }
+                t.streamQuota--
+                h := it.(*headerFrame)
+                h.streamID = t.nextID
+                t.nextID += 2
+                s.id = h.streamID
+                s.fc = &inFlow{limit: uint32(t.initialWindowSize)}
+                if t.streamQuota > 0 && t.waitingStreams > 0 {
+                        select {
+                        case t.streamsQuotaAvailable <- struct{}{}:
+                        default:
+                        }
+                }
+                return true
+        }
+        var hdrListSizeErr error
+        checkForHeaderListSize := func(it interface{}) bool {
+                if t.maxSendHeaderListSize == nil {
+                        return true
+                }
+                hdrFrame := it.(*headerFrame)
+                var sz int64
+                for _, f := range hdrFrame.hf {
+                        if sz += int64(f.Size()); sz > int64(*t.maxSendHeaderListSize) {
+                                hdrListSizeErr = status.Errorf(codes.Internal, "header list size to send violates the maximum size (%d bytes) set by server", *t.maxSendHeaderListSize)
+                                return false
+                        }
+                }
+                return true
+        }
+        for {
+                success, err := t.controlBuf.executeAndPut(func(it interface{}) bool {
+                        if !checkForStreamQuota(it) {
+                                return false
+                        }
+                        if !checkForHeaderListSize(it) {
+                                return false
+                        }
+                        return true
+                }, hdr)
+                if err != nil {
+                        return nil, err
+                }
+                if success {
+                        break
+                }
+                if hdrListSizeErr != nil {
+                        return nil, hdrListSizeErr
+                }
+                firstTry = false
+                select {
+                case <-ch:
+                case <-s.ctx.Done():
+                        return nil, ContextErr(s.ctx.Err())
+                case <-t.goAway:
+                        return nil, errStreamDrain
+                case <-t.ctx.Done():
+                        return nil, ErrConnClosing
+                }
+        }
+        if t.statsHandler != nil {
+                outHeader := &stats.OutHeader{
+                        Client:      true,
+                        FullMethod:  callHdr.Method,
+                        RemoteAddr:  t.remoteAddr,
+                        LocalAddr:   t.localAddr,
+                        Compression: callHdr.SendCompress,
+                }
+                t.statsHandler.HandleRPC(s.ctx, outHeader)
+        }
+        return s, nil
+}
+
+// CloseStream clears the footprint of a stream when the stream is not needed any more.
+// This must not be executed in reader's goroutine.
+func (t *http2Client) CloseStream(s *Stream, err error) {
+        var (
+                rst     bool
+                rstCode http2.ErrCode
+        )
+        if err != nil {
+                rst = true
+                rstCode = http2.ErrCodeCancel
+        }
+        t.closeStream(s, err, rst, rstCode, status.Convert(err), nil, false)
+}
+
+func (t *http2Client) closeStream(s *Stream, err error, rst bool, rstCode http2.ErrCode, st *status.Status, mdata map[string][]string, eosReceived bool) {
+        // Set stream status to done.
+        if s.swapState(streamDone) == streamDone {
+                // If it was already done, return.  If multiple closeStream calls
+                // happen simultaneously, wait for the first to finish.
+                <-s.done
+                return
+        }
+        // status and trailers can be updated here without any synchronization because the stream goroutine will
+        // only read it after it sees an io.EOF error from read or write and we'll write those errors
+        // only after updating this.
+        s.status = st
+        if len(mdata) > 0 {
+                s.trailer = mdata
+        }
+        if err != nil {
+                // This will unblock reads eventually.
+                s.write(recvMsg{err: err})
+        }
+        // If headerChan isn't closed, then close it.
+        if atomic.SwapUint32(&s.headerDone, 1) == 0 {
+                s.noHeaders = true
+                close(s.headerChan)
+        }
+        cleanup := &cleanupStream{
+                streamID: s.id,
+                onWrite: func() {
+                        t.mu.Lock()
+                        if t.activeStreams != nil {
+                                delete(t.activeStreams, s.id)
+                        }
+                        t.mu.Unlock()
+                        if channelz.IsOn() {
+                                if eosReceived {
+                                        atomic.AddInt64(&t.czData.streamsSucceeded, 1)
+                                } else {
+                                        atomic.AddInt64(&t.czData.streamsFailed, 1)
+                                }
+                        }
+                },
+                rst:     rst,
+                rstCode: rstCode,
+        }
+        addBackStreamQuota := func(interface{}) bool {
+                t.streamQuota++
+                if t.streamQuota > 0 && t.waitingStreams > 0 {
+                        select {
+                        case t.streamsQuotaAvailable <- struct{}{}:
+                        default:
+                        }
+                }
+                return true
+        }
+        t.controlBuf.executeAndPut(addBackStreamQuota, cleanup)
+        // This will unblock write.
+        close(s.done)
+}
+
+// Close kicks off the shutdown process of the transport. This should be called
+// only once on a transport. Once it is called, the transport should not be
+// accessed any more.
+//
+// This method blocks until the addrConn that initiated this transport is
+// re-connected. This happens because t.onClose() begins reconnect logic at the
+// addrConn level and blocks until the addrConn is successfully connected.
+func (t *http2Client) Close() error {
+        t.mu.Lock()
+        // Make sure we only Close once.
+        if t.state == closing {
+                t.mu.Unlock()
+                return nil
+        }
+        t.state = closing
+        streams := t.activeStreams
+        t.activeStreams = nil
+        t.mu.Unlock()
+        t.controlBuf.finish()
+        t.cancel()
+        err := t.conn.Close()
+        if channelz.IsOn() {
+                channelz.RemoveEntry(t.channelzID)
+        }
+        // Notify all active streams.
+        for _, s := range streams {
+                t.closeStream(s, ErrConnClosing, false, http2.ErrCodeNo, status.New(codes.Unavailable, ErrConnClosing.Desc), nil, false)
+        }
+        if t.statsHandler != nil {
+                connEnd := &stats.ConnEnd{
+                        Client: true,
+                }
+                t.statsHandler.HandleConn(t.ctx, connEnd)
+        }
+        t.onClose()
+        return err
+}
+
+// GracefulClose sets the state to draining, which prevents new streams from
+// being created and causes the transport to be closed when the last active
+// stream is closed.  If there are no active streams, the transport is closed
+// immediately.  This does nothing if the transport is already draining or
+// closing.
+func (t *http2Client) GracefulClose() error {
+        t.mu.Lock()
+        // Make sure we move to draining only from active.
+        if t.state == draining || t.state == closing {
+                t.mu.Unlock()
+                return nil
+        }
+        t.state = draining
+        active := len(t.activeStreams)
+        t.mu.Unlock()
+        if active == 0 {
+                return t.Close()
+        }
+        t.controlBuf.put(&incomingGoAway{})
+        return nil
+}
+
+// Write formats the data into HTTP2 data frame(s) and sends it out. The caller
+// should proceed only if Write returns nil.
+func (t *http2Client) Write(s *Stream, hdr []byte, data []byte, opts *Options) error {
+        if opts.Last {
+                // If it's the last message, update stream state.
+                if !s.compareAndSwapState(streamActive, streamWriteDone) {
+                        return errStreamDone
+                }
+        } else if s.getState() != streamActive {
+                return errStreamDone
+        }
+        df := &dataFrame{
+                streamID:  s.id,
+                endStream: opts.Last,
+        }
+        if hdr != nil || data != nil { // If it's not an empty data frame.
+                // Add some data to grpc message header so that we can equally
+                // distribute bytes across frames.
+                emptyLen := http2MaxFrameLen - len(hdr)
+                if emptyLen > len(data) {
+                        emptyLen = len(data)
+                }
+                hdr = append(hdr, data[:emptyLen]...)
+                data = data[emptyLen:]
+                df.h, df.d = hdr, data
+                // TODO(mmukhi): The above logic in this if can be moved to loopyWriter's data handler.
+                if err := s.wq.get(int32(len(hdr) + len(data))); err != nil {
+                        return err
+                }
+        }
+        return t.controlBuf.put(df)
+}
+
+func (t *http2Client) getStream(f http2.Frame) (*Stream, bool) {
+        t.mu.Lock()
+        defer t.mu.Unlock()
+        s, ok := t.activeStreams[f.Header().StreamID]
+        return s, ok
+}
+
+// adjustWindow sends out extra window update over the initial window size
+// of stream if the application is requesting data larger in size than
+// the window.
+func (t *http2Client) adjustWindow(s *Stream, n uint32) {
+        if w := s.fc.maybeAdjust(n); w > 0 {
+                t.controlBuf.put(&outgoingWindowUpdate{streamID: s.id, increment: w})
+        }
+}
+
+// updateWindow adjusts the inbound quota for the stream.
+// Window updates will be sent out when the cumulative quota
+// exceeds the corresponding threshold.
+func (t *http2Client) updateWindow(s *Stream, n uint32) {
+        if w := s.fc.onRead(n); w > 0 {
+                t.controlBuf.put(&outgoingWindowUpdate{streamID: s.id, increment: w})
+        }
+}
+
+// updateFlowControl updates the incoming flow control windows
+// for the transport and the stream based on the current bdp
+// estimation.
+func (t *http2Client) updateFlowControl(n uint32) {
+        t.mu.Lock()
+        for _, s := range t.activeStreams {
+                s.fc.newLimit(n)
+        }
+        t.mu.Unlock()
+        updateIWS := func(interface{}) bool {
+                t.initialWindowSize = int32(n)
+                return true
+        }
+        t.controlBuf.executeAndPut(updateIWS, &outgoingWindowUpdate{streamID: 0, increment: t.fc.newLimit(n)})
+        t.controlBuf.put(&outgoingSettings{
+                ss: []http2.Setting{
+                        {
+                                ID:  http2.SettingInitialWindowSize,
+                                Val: n,
+                        },
+                },
+        })
+}
+
+func (t *http2Client) handleData(f *http2.DataFrame) {
+        size := f.Header().Length
+        var sendBDPPing bool
+        if t.bdpEst != nil {
+                sendBDPPing = t.bdpEst.add(size)
+        }
+        // Decouple connection's flow control from application's read.
+        // An update on connection's flow control should not depend on
+        // whether user application has read the data or not. Such a
+        // restriction is already imposed on the stream's flow control,
+        // and therefore the sender will be blocked anyways.
+        // Decoupling the connection flow control will prevent other
+        // active(fast) streams from starving in presence of slow or
+        // inactive streams.
+        //
+        if w := t.fc.onData(size); w > 0 {
+                t.controlBuf.put(&outgoingWindowUpdate{
+                        streamID:  0,
+                        increment: w,
+                })
+        }
+        if sendBDPPing {
+                // Avoid excessive ping detection (e.g. in an L7 proxy)
+                // by sending a window update prior to the BDP ping.
+
+                if w := t.fc.reset(); w > 0 {
+                        t.controlBuf.put(&outgoingWindowUpdate{
+                                streamID:  0,
+                                increment: w,
+                        })
+                }
+
+                t.controlBuf.put(bdpPing)
+        }
+        // Select the right stream to dispatch.
+        s, ok := t.getStream(f)
+        if !ok {
+                return
+        }
+        if size > 0 {
+                if err := s.fc.onData(size); err != nil {
+                        t.closeStream(s, io.EOF, true, http2.ErrCodeFlowControl, status.New(codes.Internal, err.Error()), nil, false)
+                        return
+                }
+                if f.Header().Flags.Has(http2.FlagDataPadded) {
+                        if w := s.fc.onRead(size - uint32(len(f.Data()))); w > 0 {
+                                t.controlBuf.put(&outgoingWindowUpdate{s.id, w})
+                        }
+                }
+                // TODO(bradfitz, zhaoq): A copy is required here because there is no
+                // guarantee f.Data() is consumed before the arrival of next frame.
+                // Can this copy be eliminated?
+                if len(f.Data()) > 0 {
+                        data := make([]byte, len(f.Data()))
+                        copy(data, f.Data())
+                        s.write(recvMsg{data: data})
+                }
+        }
+        // The server has closed the stream without sending trailers.  Record that
+        // the read direction is closed, and set the status appropriately.
+        if f.FrameHeader.Flags.Has(http2.FlagDataEndStream) {
+                t.closeStream(s, io.EOF, false, http2.ErrCodeNo, status.New(codes.Internal, "server closed the stream without sending trailers"), nil, true)
+        }
+}
+
+func (t *http2Client) handleRSTStream(f *http2.RSTStreamFrame) {
+        s, ok := t.getStream(f)
+        if !ok {
+                return
+        }
+        if f.ErrCode == http2.ErrCodeRefusedStream {
+                // The stream was unprocessed by the server.
+                atomic.StoreUint32(&s.unprocessed, 1)
+        }
+        statusCode, ok := http2ErrConvTab[f.ErrCode]
+        if !ok {
+                warningf("transport: http2Client.handleRSTStream found no mapped gRPC status for the received http2 error %v", f.ErrCode)
+                statusCode = codes.Unknown
+        }
+        if statusCode == codes.Canceled {
+                // Our deadline was already exceeded, and that was likely the cause of
+                // this cancelation.  Alter the status code accordingly.
+                if d, ok := s.ctx.Deadline(); ok && d.After(time.Now()) {
+                        statusCode = codes.DeadlineExceeded
+                }
+        }
+        t.closeStream(s, io.EOF, false, http2.ErrCodeNo, status.Newf(statusCode, "stream terminated by RST_STREAM with error code: %v", f.ErrCode), nil, false)
+}
+
+func (t *http2Client) handleSettings(f *http2.SettingsFrame, isFirst bool) {
+        if f.IsAck() {
+                return
+        }
+        var maxStreams *uint32
+        var ss []http2.Setting
+        var updateFuncs []func()
+        f.ForeachSetting(func(s http2.Setting) error {
+                switch s.ID {
+                case http2.SettingMaxConcurrentStreams:
+                        maxStreams = new(uint32)
+                        *maxStreams = s.Val
+                case http2.SettingMaxHeaderListSize:
+                        updateFuncs = append(updateFuncs, func() {
+                                t.maxSendHeaderListSize = new(uint32)
+                                *t.maxSendHeaderListSize = s.Val
+                        })
+                default:
+                        ss = append(ss, s)
+                }
+                return nil
+        })
+        if isFirst && maxStreams == nil {
+                maxStreams = new(uint32)
+                *maxStreams = math.MaxUint32
+        }
+        sf := &incomingSettings{
+                ss: ss,
+        }
+        if maxStreams != nil {
+                updateStreamQuota := func() {
+                        delta := int64(*maxStreams) - int64(t.maxConcurrentStreams)
+                        t.maxConcurrentStreams = *maxStreams
+                        t.streamQuota += delta
+                        if delta > 0 && t.waitingStreams > 0 {
+                                close(t.streamsQuotaAvailable) // wake all of them up.
+                                t.streamsQuotaAvailable = make(chan struct{}, 1)
+                        }
+                }
+                updateFuncs = append(updateFuncs, updateStreamQuota)
+        }
+        t.controlBuf.executeAndPut(func(interface{}) bool {
+                for _, f := range updateFuncs {
+                        f()
+                }
+                return true
+        }, sf)
+}
+
+func (t *http2Client) handlePing(f *http2.PingFrame) {
+        if f.IsAck() {
+                // Maybe it's a BDP ping.
+                if t.bdpEst != nil {
+                        t.bdpEst.calculate(f.Data)
+                }
+                return
+        }
+        pingAck := &ping{ack: true}
+        copy(pingAck.data[:], f.Data[:])
+        t.controlBuf.put(pingAck)
+}
+
+func (t *http2Client) handleGoAway(f *http2.GoAwayFrame) {
+        t.mu.Lock()
+        if t.state == closing {
+                t.mu.Unlock()
+                return
+        }
+        if f.ErrCode == http2.ErrCodeEnhanceYourCalm {
+                infof("Client received GoAway with http2.ErrCodeEnhanceYourCalm.")
+        }
+        id := f.LastStreamID
+        if id > 0 && id%2 != 1 {
+                t.mu.Unlock()
+                t.Close()
+                return
+        }
+        // A client can receive multiple GoAways from the server (see
+        // https://github.com/grpc/grpc-go/issues/1387).  The idea is that the first
+        // GoAway will be sent with an ID of MaxInt32 and the second GoAway will be
+        // sent after an RTT delay with the ID of the last stream the server will
+        // process.
+        //
+        // Therefore, when we get the first GoAway we don't necessarily close any
+        // streams. While in case of second GoAway we close all streams created after
+        // the GoAwayId. This way streams that were in-flight while the GoAway from
+        // server was being sent don't get killed.
+        select {
+        case <-t.goAway: // t.goAway has been closed (i.e.,multiple GoAways).
+                // If there are multiple GoAways the first one should always have an ID greater than the following ones.
+                if id > t.prevGoAwayID {
+                        t.mu.Unlock()
+                        t.Close()
+                        return
+                }
+        default:
+                t.setGoAwayReason(f)
+                close(t.goAway)
+                t.state = draining
+                t.controlBuf.put(&incomingGoAway{})
+
+                // This has to be a new goroutine because we're still using the current goroutine to read in the transport.
+                t.onGoAway(t.goAwayReason)
+        }
+        // All streams with IDs greater than the GoAwayId
+        // and smaller than the previous GoAway ID should be killed.
+        upperLimit := t.prevGoAwayID
+        if upperLimit == 0 { // This is the first GoAway Frame.
+                upperLimit = math.MaxUint32 // Kill all streams after the GoAway ID.
+        }
+        for streamID, stream := range t.activeStreams {
+                if streamID > id && streamID <= upperLimit {
+                        // The stream was unprocessed by the server.
+                        atomic.StoreUint32(&stream.unprocessed, 1)
+                        t.closeStream(stream, errStreamDrain, false, http2.ErrCodeNo, statusGoAway, nil, false)
+                }
+        }
+        t.prevGoAwayID = id
+        active := len(t.activeStreams)
+        t.mu.Unlock()
+        if active == 0 {
+                t.Close()
+        }
+}
+
+// setGoAwayReason sets the value of t.goAwayReason based
+// on the GoAway frame received.
+// It expects a lock on transport's mutext to be held by
+// the caller.
+func (t *http2Client) setGoAwayReason(f *http2.GoAwayFrame) {
+        t.goAwayReason = GoAwayNoReason
+        switch f.ErrCode {
+        case http2.ErrCodeEnhanceYourCalm:
+                if string(f.DebugData()) == "too_many_pings" {
+                        t.goAwayReason = GoAwayTooManyPings
+                }
+        }
+}
+
+func (t *http2Client) GetGoAwayReason() GoAwayReason {
+        t.mu.Lock()
+        defer t.mu.Unlock()
+        return t.goAwayReason
+}
+
+func (t *http2Client) handleWindowUpdate(f *http2.WindowUpdateFrame) {
+        t.controlBuf.put(&incomingWindowUpdate{
+                streamID:  f.Header().StreamID,
+                increment: f.Increment,
+        })
+}
+
+// operateHeaders takes action on the decoded headers.
+func (t *http2Client) operateHeaders(frame *http2.MetaHeadersFrame) {
+        s, ok := t.getStream(frame)
+        if !ok {
+                return
+        }
+        atomic.StoreUint32(&s.bytesReceived, 1)
+        var state decodeState
+        if err := state.decodeHeader(frame); err != nil {
+                t.closeStream(s, err, true, http2.ErrCodeProtocol, status.New(codes.Internal, err.Error()), nil, false)
+                // Something wrong. Stops reading even when there is remaining.
+                return
+        }
+
+        endStream := frame.StreamEnded()
+        var isHeader bool
+        defer func() {
+                if t.statsHandler != nil {
+                        if isHeader {
+                                inHeader := &stats.InHeader{
+                                        Client:     true,
+                                        WireLength: int(frame.Header().Length),
+                                }
+                                t.statsHandler.HandleRPC(s.ctx, inHeader)
+                        } else {
+                                inTrailer := &stats.InTrailer{
+                                        Client:     true,
+                                        WireLength: int(frame.Header().Length),
+                                }
+                                t.statsHandler.HandleRPC(s.ctx, inTrailer)
+                        }
+                }
+        }()
+        // If headers haven't been received yet.
+        if atomic.SwapUint32(&s.headerDone, 1) == 0 {
+                if !endStream {
+                        // Headers frame is not actually a trailers-only frame.
+                        isHeader = true
+                        // These values can be set without any synchronization because
+                        // stream goroutine will read it only after seeing a closed
+                        // headerChan which we'll close after setting this.
+                        s.recvCompress = state.encoding
+                        if len(state.mdata) > 0 {
+                                s.header = state.mdata
+                        }
+                } else {
+                        s.noHeaders = true
+                }
+                close(s.headerChan)
+        }
+        if !endStream {
+                return
+        }
+        // if client received END_STREAM from server while stream was still active, send RST_STREAM
+        rst := s.getState() == streamActive
+        t.closeStream(s, io.EOF, rst, http2.ErrCodeNo, state.status(), state.mdata, true)
+}
+
+// reader runs as a separate goroutine in charge of reading data from network
+// connection.
+//
+// TODO(zhaoq): currently one reader per transport. Investigate whether this is
+// optimal.
+// TODO(zhaoq): Check the validity of the incoming frame sequence.
+func (t *http2Client) reader() {
+        defer close(t.readerDone)
+        // Check the validity of server preface.
+        frame, err := t.framer.fr.ReadFrame()
+        if err != nil {
+                t.Close() // this kicks off resetTransport, so must be last before return
+                return
+        }
+        t.conn.SetReadDeadline(time.Time{}) // reset deadline once we get the settings frame (we didn't time out, yay!)
+        if t.keepaliveEnabled {
+                atomic.CompareAndSwapUint32(&t.activity, 0, 1)
+        }
+        sf, ok := frame.(*http2.SettingsFrame)
+        if !ok {
+                t.Close() // this kicks off resetTransport, so must be last before return
+                return
+        }
+        t.onPrefaceReceipt()
+        t.handleSettings(sf, true)
+
+        // loop to keep reading incoming messages on this transport.
+        for {
+                frame, err := t.framer.fr.ReadFrame()
+                if t.keepaliveEnabled {
+                        atomic.CompareAndSwapUint32(&t.activity, 0, 1)
+                }
+                if err != nil {
+                        // Abort an active stream if the http2.Framer returns a
+                        // http2.StreamError. This can happen only if the server's response
+                        // is malformed http2.
+                        if se, ok := err.(http2.StreamError); ok {
+                                t.mu.Lock()
+                                s := t.activeStreams[se.StreamID]
+                                t.mu.Unlock()
+                                if s != nil {
+                                        // use error detail to provide better err message
+                                        code := http2ErrConvTab[se.Code]
+                                        msg := t.framer.fr.ErrorDetail().Error()
+                                        t.closeStream(s, status.Error(code, msg), true, http2.ErrCodeProtocol, status.New(code, msg), nil, false)
+                                }
+                                continue
+                        } else {
+                                // Transport error.
+                                t.Close()
+                                return
+                        }
+                }
+                switch frame := frame.(type) {
+                case *http2.MetaHeadersFrame:
+                        t.operateHeaders(frame)
+                case *http2.DataFrame:
+                        t.handleData(frame)
+                case *http2.RSTStreamFrame:
+                        t.handleRSTStream(frame)
+                case *http2.SettingsFrame:
+                        t.handleSettings(frame, false)
+                case *http2.PingFrame:
+                        t.handlePing(frame)
+                case *http2.GoAwayFrame:
+                        t.handleGoAway(frame)
+                case *http2.WindowUpdateFrame:
+                        t.handleWindowUpdate(frame)
+                default:
+                        errorf("transport: http2Client.reader got unhandled frame type %v.", frame)
+                }
+        }
+}
+
+// keepalive running in a separate goroutune makes sure the connection is alive by sending pings.
+func (t *http2Client) keepalive() {
+        p := &ping{data: [8]byte{}}
+        timer := time.NewTimer(t.kp.Time)
+        for {
+                select {
+                case <-timer.C:
+                        if atomic.CompareAndSwapUint32(&t.activity, 1, 0) {
+                                timer.Reset(t.kp.Time)
+                                continue
+                        }
+                        // Check if keepalive should go dormant.
+                        t.mu.Lock()
+                        if len(t.activeStreams) < 1 && !t.kp.PermitWithoutStream {
+                                // Make awakenKeepalive writable.
+                                <-t.awakenKeepalive
+                                t.mu.Unlock()
+                                select {
+                                case <-t.awakenKeepalive:
+                                        // If the control gets here a ping has been sent
+                                        // need to reset the timer with keepalive.Timeout.
+                                case <-t.ctx.Done():
+                                        return
+                                }
+                        } else {
+                                t.mu.Unlock()
+                                if channelz.IsOn() {
+                                        atomic.AddInt64(&t.czData.kpCount, 1)
+                                }
+                                // Send ping.
+                                t.controlBuf.put(p)
+                        }
+
+                        // By the time control gets here a ping has been sent one way or the other.
+                        timer.Reset(t.kp.Timeout)
+                        select {
+                        case <-timer.C:
+                                if atomic.CompareAndSwapUint32(&t.activity, 1, 0) {
+                                        timer.Reset(t.kp.Time)
+                                        continue
+                                }
+                                t.Close()
+                                return
+                        case <-t.ctx.Done():
+                                if !timer.Stop() {
+                                        <-timer.C
+                                }
+                                return
+                        }
+                case <-t.ctx.Done():
+                        if !timer.Stop() {
+                                <-timer.C
+                        }
+                        return
+                }
+        }
+}
+
+func (t *http2Client) Error() <-chan struct{} {
+        return t.ctx.Done()
+}
+
+func (t *http2Client) GoAway() <-chan struct{} {
+        return t.goAway
+}
+
+func (t *http2Client) ChannelzMetric() *channelz.SocketInternalMetric {
+        s := channelz.SocketInternalMetric{
+                StreamsStarted:                  atomic.LoadInt64(&t.czData.streamsStarted),
+                StreamsSucceeded:                atomic.LoadInt64(&t.czData.streamsSucceeded),
+                StreamsFailed:                   atomic.LoadInt64(&t.czData.streamsFailed),
+                MessagesSent:                    atomic.LoadInt64(&t.czData.msgSent),
+                MessagesReceived:                atomic.LoadInt64(&t.czData.msgRecv),
+                KeepAlivesSent:                  atomic.LoadInt64(&t.czData.kpCount),
+                LastLocalStreamCreatedTimestamp: time.Unix(0, atomic.LoadInt64(&t.czData.lastStreamCreatedTime)),
+                LastMessageSentTimestamp:        time.Unix(0, atomic.LoadInt64(&t.czData.lastMsgSentTime)),
+                LastMessageReceivedTimestamp:    time.Unix(0, atomic.LoadInt64(&t.czData.lastMsgRecvTime)),
+                LocalFlowControlWindow:          int64(t.fc.getSize()),
+                SocketOptions:                   channelz.GetSocketOption(t.conn),
+                LocalAddr:                       t.localAddr,
+                RemoteAddr:                      t.remoteAddr,
+                // RemoteName :
+        }
+        if au, ok := t.authInfo.(credentials.ChannelzSecurityInfo); ok {
+                s.Security = au.GetSecurityValue()
+        }
+        s.RemoteFlowControlWindow = t.getOutFlowWindow()
+        return &s
+}
+
+func (t *http2Client) IncrMsgSent() {
+        atomic.AddInt64(&t.czData.msgSent, 1)
+        atomic.StoreInt64(&t.czData.lastMsgSentTime, time.Now().UnixNano())
+}
+
+func (t *http2Client) IncrMsgRecv() {
+        atomic.AddInt64(&t.czData.msgRecv, 1)
+        atomic.StoreInt64(&t.czData.lastMsgRecvTime, time.Now().UnixNano())
+}
+
+func (t *http2Client) getOutFlowWindow() int64 {
+        resp := make(chan uint32, 1)
+        timer := time.NewTimer(time.Second)
+        defer timer.Stop()
+        t.controlBuf.put(&outFlowControlSizeRequest{resp})
+        select {
+        case sz := <-resp:
+                return int64(sz)
+        case <-t.ctxDone:
+                return -1
+        case <-timer.C:
+                return -2
+        }
+}
diff --git a/vendor/google.golang.org/grpc/transport/http2_server.go b/vendor/google.golang.org/grpc/internal/transport/http2_server.go
index b6f93e3..df27403 100644
--- a/vendor/google.golang.org/grpc/transport/http2_server.go
+++ b/vendor/google.golang.org/grpc/internal/transport/http2_server.go
@@ -20,10 +20,11 @@ package transport
 
 import (
         "bytes"
+        "context"
         "errors"
+        "fmt"
         "io"
         "math"
-        "math/rand"
         "net"
         "strconv"
         "sync"
@@ -31,11 +32,14 @@ import (
         "time"
 
         "github.com/golang/protobuf/proto"
-        "golang.org/x/net/context"
         "golang.org/x/net/http2"
         "golang.org/x/net/http2/hpack"
+
         "google.golang.org/grpc/codes"
         "google.golang.org/grpc/credentials"
+        "google.golang.org/grpc/grpclog"
+        "google.golang.org/grpc/internal/channelz"
+        "google.golang.org/grpc/internal/grpcrand"
         "google.golang.org/grpc/keepalive"
         "google.golang.org/grpc/metadata"
         "google.golang.org/grpc/peer"
@@ -44,39 +48,37 @@ import (
         "google.golang.org/grpc/tap"
 )
 
-// ErrIllegalHeaderWrite indicates that setting header is illegal because of
-// the stream's state.
-var ErrIllegalHeaderWrite = errors.New("transport: the stream is done or WriteHeader was already called")
+var (
+        // ErrIllegalHeaderWrite indicates that setting header is illegal because of
+        // the stream's state.
+        ErrIllegalHeaderWrite = errors.New("transport: the stream is done or WriteHeader was already called")
+        // ErrHeaderListSizeLimitViolation indicates that the header list size is larger
+        // than the limit set by peer.
+        ErrHeaderListSizeLimitViolation = errors.New("transport: trying to send header list size larger than the limit set by peer")
+)
 
 // http2Server implements the ServerTransport interface with HTTP2.
 type http2Server struct {
         ctx         context.Context
+        ctxDone     <-chan struct{} // Cache the context.Done() chan
+        cancel      context.CancelFunc
         conn        net.Conn
+        loopy       *loopyWriter
+        readerDone  chan struct{} // sync point to enable testing.
+        writerDone  chan struct{} // sync point to enable testing.
         remoteAddr  net.Addr
         localAddr   net.Addr
         maxStreamID uint32               // max stream ID ever seen
         authInfo    credentials.AuthInfo // auth info about the connection
         inTapHandle tap.ServerInHandle
-        // writableChan synchronizes write access to the transport.
-        // A writer acquires the write lock by receiving a value on writableChan
-        // and releases it by sending on writableChan.
-        writableChan chan int
-        // shutdownChan is closed when Close is called.
-        // Blocking operations should select on shutdownChan to avoid
-        // blocking forever after Close.
-        shutdownChan chan struct{}
-        framer       *framer
-        hBuf         *bytes.Buffer  // the buffer for HPACK encoding
-        hEnc         *hpack.Encoder // HPACK encoder
+        framer      *framer
         // The max number of concurrent streams.
         maxStreams uint32
         // controlBuf delivers all the control related tasks (e.g., window
         // updates, reset streams, and various settings) to the controller.
         controlBuf *controlBuffer
-        fc         *inFlow
-        // sendQuotaPool provides flow control to outbound message.
-        sendQuotaPool *quotaPool
-        stats         stats.Handler
+        fc         *trInFlow
+        stats      stats.Handler
         // Flag to keep track of reading activity on transport.
         // 1 is true and 0 is false.
         activity uint32 // Accessed atomically.
@@ -92,11 +94,10 @@ type http2Server struct {
         // Flag to signify that number of ping strikes should be reset to 0.
         // This is set whenever data or header frames are sent.
         // 1 means yes.
-        resetPingStrikes  uint32 // Accessed atomically.
-        initialWindowSize int32
-        bdpEst            *bdpEstimator
-
-        outQuotaVersion uint32
+        resetPingStrikes      uint32 // Accessed atomically.
+        initialWindowSize     int32
+        bdpEst                *bdpEstimator
+        maxSendHeaderListSize *uint32
 
         mu sync.Mutex // guard the following
 
@@ -109,19 +110,27 @@ type http2Server struct {
         drainChan     chan struct{}
         state         transportState
         activeStreams map[uint32]*Stream
-        // the per-stream outbound flow control window size set by the peer.
-        streamSendQuota uint32
         // idle is the time instant when the connection went idle.
-        // This is either the begining of the connection or when the number of
+        // This is either the beginning of the connection or when the number of
         // RPCs go down to 0.
         // When the connection is busy, this value is set to 0.
         idle time.Time
+
+        // Fields below are for channelz metric collection.
+        channelzID int64 // channelz unique identification number
+        czData     *channelzData
 }
 
 // newHTTP2Server constructs a ServerTransport based on HTTP2. ConnectionError is
 // returned if something goes wrong.
 func newHTTP2Server(conn net.Conn, config *ServerConfig) (_ ServerTransport, err error) {
-        framer := newFramer(conn)
+        writeBufSize := config.WriteBufferSize
+        readBufSize := config.ReadBufferSize
+        maxHeaderListSize := defaultServerMaxHeaderListSize
+        if config.MaxHeaderListSize != nil {
+                maxHeaderListSize = *config.MaxHeaderListSize
+        }
+        framer := newFramer(conn, writeBufSize, readBufSize, maxHeaderListSize)
         // Send initial settings as connection preface to client.
         var isettings []http2.Setting
         // TODO(zhaoq): Have a better way to signal "no limit" because 0 is
@@ -151,13 +160,19 @@ func newHTTP2Server(conn net.Conn, config *ServerConfig) (_ ServerTransport, err
                         ID:  http2.SettingInitialWindowSize,
                         Val: uint32(iwz)})
         }
-        if err := framer.writeSettings(true, isettings...); err != nil {
-                return nil, connectionErrorf(true, err, "transport: %v", err)
+        if config.MaxHeaderListSize != nil {
+                isettings = append(isettings, http2.Setting{
+                        ID:  http2.SettingMaxHeaderListSize,
+                        Val: *config.MaxHeaderListSize,
+                })
+        }
+        if err := framer.fr.WriteSettings(isettings...); err != nil {
+                return nil, connectionErrorf(false, err, "transport: %v", err)
         }
         // Adjust the connection flow control window if needed.
         if delta := uint32(icwz - defaultWindowSize); delta > 0 {
-                if err := framer.writeWindowUpdate(true, 0, delta); err != nil {
-                        return nil, connectionErrorf(true, err, "transport: %v", err)
+                if err := framer.fr.WriteWindowUpdate(0, delta); err != nil {
+                        return nil, connectionErrorf(false, err, "transport: %v", err)
                 }
         }
         kp := config.KeepaliveParams
@@ -182,32 +197,31 @@ func newHTTP2Server(conn net.Conn, config *ServerConfig) (_ ServerTransport, err
         if kep.MinTime == 0 {
                 kep.MinTime = defaultKeepalivePolicyMinTime
         }
-        var buf bytes.Buffer
+        ctx, cancel := context.WithCancel(context.Background())
         t := &http2Server{
-                ctx:               context.Background(),
+                ctx:               ctx,
+                cancel:            cancel,
+                ctxDone:           ctx.Done(),
                 conn:              conn,
                 remoteAddr:        conn.RemoteAddr(),
                 localAddr:         conn.LocalAddr(),
                 authInfo:          config.AuthInfo,
                 framer:            framer,
-                hBuf:              &buf,
-                hEnc:              hpack.NewEncoder(&buf),
+                readerDone:        make(chan struct{}),
+                writerDone:        make(chan struct{}),
                 maxStreams:        maxStreams,
                 inTapHandle:       config.InTapHandle,
-                controlBuf:        newControlBuffer(),
-                fc:                &inFlow{limit: uint32(icwz)},
-                sendQuotaPool:     newQuotaPool(defaultWindowSize),
+                fc:                &trInFlow{limit: uint32(icwz)},
                 state:             reachable,
-                writableChan:      make(chan int, 1),
-                shutdownChan:      make(chan struct{}),
                 activeStreams:     make(map[uint32]*Stream),
-                streamSendQuota:   defaultWindowSize,
                 stats:             config.StatsHandler,
                 kp:                kp,
                 idle:              time.Now(),
                 kep:               kep,
                 initialWindowSize: iwz,
+                czData:            new(channelzData),
         }
+        t.controlBuf = newControlBuffer(t.ctxDone)
         if dynamicWindow {
                 t.bdpEst = &bdpEstimator{
                         bdp:               initialWindowSize,
@@ -222,37 +236,83 @@ func newHTTP2Server(conn net.Conn, config *ServerConfig) (_ ServerTransport, err
                 connBegin := &stats.ConnBegin{}
                 t.stats.HandleConn(t.ctx, connBegin)
         }
-        go t.controller()
+        if channelz.IsOn() {
+                t.channelzID = channelz.RegisterNormalSocket(t, config.ChannelzParentID, fmt.Sprintf("%s -> %s", t.remoteAddr, t.localAddr))
+        }
+        t.framer.writer.Flush()
+
+        defer func() {
+                if err != nil {
+                        t.Close()
+                }
+        }()
+
+        // Check the validity of client preface.
+        preface := make([]byte, len(clientPreface))
+        if _, err := io.ReadFull(t.conn, preface); err != nil {
+                return nil, connectionErrorf(false, err, "transport: http2Server.HandleStreams failed to receive the preface from client: %v", err)
+        }
+        if !bytes.Equal(preface, clientPreface) {
+                return nil, connectionErrorf(false, nil, "transport: http2Server.HandleStreams received bogus greeting from client: %q", preface)
+        }
+
+        frame, err := t.framer.fr.ReadFrame()
+        if err == io.EOF || err == io.ErrUnexpectedEOF {
+                return nil, err
+        }
+        if err != nil {
+                return nil, connectionErrorf(false, err, "transport: http2Server.HandleStreams failed to read initial settings frame: %v", err)
+        }
+        atomic.StoreUint32(&t.activity, 1)
+        sf, ok := frame.(*http2.SettingsFrame)
+        if !ok {
+                return nil, connectionErrorf(false, nil, "transport: http2Server.HandleStreams saw invalid preface type %T from client", frame)
+        }
+        t.handleSettings(sf)
+
+        go func() {
+                t.loopy = newLoopyWriter(serverSide, t.framer, t.controlBuf, t.bdpEst)
+                t.loopy.ssGoAwayHandler = t.outgoingGoAwayHandler
+                if err := t.loopy.run(); err != nil {
+                        errorf("transport: loopyWriter.run returning. Err: %v", err)
+                }
+                t.conn.Close()
+                close(t.writerDone)
+        }()
         go t.keepalive()
-        t.writableChan <- 0
         return t, nil
 }
 
 // operateHeader takes action on the decoded headers.
-func (t *http2Server) operateHeaders(frame *http2.MetaHeadersFrame, handle func(*Stream), traceCtx func(context.Context, string) context.Context) (close bool) {
-        buf := newRecvBuffer()
-        s := &Stream{
-                id:  frame.Header().StreamID,
-                st:  t,
-                buf: buf,
-                fc:  &inFlow{limit: uint32(t.initialWindowSize)},
-        }
-
-        var state decodeState
-        for _, hf := range frame.Fields {
-                if err := state.processHeaderField(hf); err != nil {
-                        if se, ok := err.(StreamError); ok {
-                                t.controlBuf.put(&resetStream{s.id, statusCodeConvTab[se.Code]})
-                        }
-                        return
+func (t *http2Server) operateHeaders(frame *http2.MetaHeadersFrame, handle func(*Stream), traceCtx func(context.Context, string) context.Context) (fatal bool) {
+        streamID := frame.Header().StreamID
+        state := decodeState{serverSide: true}
+        if err := state.decodeHeader(frame); err != nil {
+                if se, ok := status.FromError(err); ok {
+                        t.controlBuf.put(&cleanupStream{
+                                streamID: streamID,
+                                rst:      true,
+                                rstCode:  statusCodeConvTab[se.Code()],
+                                onWrite:  func() {},
+                        })
                 }
+                return false
         }
 
+        buf := newRecvBuffer()
+        s := &Stream{
+                id:             streamID,
+                st:             t,
+                buf:            buf,
+                fc:             &inFlow{limit: uint32(t.initialWindowSize)},
+                recvCompress:   state.encoding,
+                method:         state.method,
+                contentSubtype: state.contentSubtype,
+        }
         if frame.StreamEnded() {
                 // s is just created by the caller. No lock needed.
                 s.state = streamReadDone
         }
-        s.recvCompress = state.encoding
         if state.timeoutSet {
                 s.ctx, s.cancel = context.WithTimeout(t.ctx, state.timeout)
         } else {
@@ -266,25 +326,16 @@ func (t *http2Server) operateHeaders(frame *http2.MetaHeadersFrame, handle func(
                 pr.AuthInfo = t.authInfo
         }
         s.ctx = peer.NewContext(s.ctx, pr)
-        // Cache the current stream to the context so that the server application
-        // can find out. Required when the server wants to send some metadata
-        // back to the client (unary call only).
-        s.ctx = newContextWithStream(s.ctx, s)
         // Attach the received metadata to the context.
         if len(state.mdata) > 0 {
                 s.ctx = metadata.NewIncomingContext(s.ctx, state.mdata)
         }
-        s.trReader = &transportReader{
-                reader: &recvBufferReader{
-                        ctx:  s.ctx,
-                        recv: s.buf,
-                },
-                windowHandler: func(n int) {
-                        t.updateWindow(s, uint32(n))
-                },
+        if state.statsTags != nil {
+                s.ctx = stats.SetIncomingTags(s.ctx, state.statsTags)
+        }
+        if state.statsTrace != nil {
+                s.ctx = stats.SetIncomingTrace(s.ctx, state.statsTrace)
         }
-        s.recvCompress = state.encoding
-        s.method = state.method
         if t.inTapHandle != nil {
                 var err error
                 info := &tap.Info{
@@ -293,33 +344,46 @@ func (t *http2Server) operateHeaders(frame *http2.MetaHeadersFrame, handle func(
                 s.ctx, err = t.inTapHandle(s.ctx, info)
                 if err != nil {
                         warningf("transport: http2Server.operateHeaders got an error from InTapHandle: %v", err)
-                        t.controlBuf.put(&resetStream{s.id, http2.ErrCodeRefusedStream})
-                        return
+                        t.controlBuf.put(&cleanupStream{
+                                streamID: s.id,
+                                rst:      true,
+                                rstCode:  http2.ErrCodeRefusedStream,
+                                onWrite:  func() {},
+                        })
+                        return false
                 }
         }
         t.mu.Lock()
         if t.state != reachable {
                 t.mu.Unlock()
-                return
+                return false
         }
         if uint32(len(t.activeStreams)) >= t.maxStreams {
                 t.mu.Unlock()
-                t.controlBuf.put(&resetStream{s.id, http2.ErrCodeRefusedStream})
-                return
+                t.controlBuf.put(&cleanupStream{
+                        streamID: streamID,
+                        rst:      true,
+                        rstCode:  http2.ErrCodeRefusedStream,
+                        onWrite:  func() {},
+                })
+                return false
         }
-        if s.id%2 != 1 || s.id <= t.maxStreamID {
+        if streamID%2 != 1 || streamID <= t.maxStreamID {
                 t.mu.Unlock()
                 // illegal gRPC stream id.
-                errorf("transport: http2Server.HandleStreams received an illegal stream id: %v", s.id)
+                errorf("transport: http2Server.HandleStreams received an illegal stream id: %v", streamID)
                 return true
         }
-        t.maxStreamID = s.id
-        s.sendQuotaPool = newQuotaPool(int(t.streamSendQuota))
-        t.activeStreams[s.id] = s
+        t.maxStreamID = streamID
+        t.activeStreams[streamID] = s
         if len(t.activeStreams) == 1 {
                 t.idle = time.Time{}
         }
         t.mu.Unlock()
+        if channelz.IsOn() {
+                atomic.AddInt64(&t.czData.streamsStarted, 1)
+                atomic.StoreInt64(&t.czData.lastStreamCreatedTime, time.Now().UnixNano())
+        }
         s.requestRead = func(n int) {
                 t.adjustWindow(s, uint32(n))
         }
@@ -335,61 +399,51 @@ func (t *http2Server) operateHeaders(frame *http2.MetaHeadersFrame, handle func(
                 }
                 t.stats.HandleRPC(s.ctx, inHeader)
         }
+        s.ctxDone = s.ctx.Done()
+        s.wq = newWriteQuota(defaultWriteQuota, s.ctxDone)
+        s.trReader = &transportReader{
+                reader: &recvBufferReader{
+                        ctx:     s.ctx,
+                        ctxDone: s.ctxDone,
+                        recv:    s.buf,
+                },
+                windowHandler: func(n int) {
+                        t.updateWindow(s, uint32(n))
+                },
+        }
+        // Register the stream with loopy.
+        t.controlBuf.put(&registerStream{
+                streamID: s.id,
+                wq:       s.wq,
+        })
         handle(s)
-        return
+        return false
 }
 
 // HandleStreams receives incoming streams using the given handler. This is
 // typically run in a separate goroutine.
 // traceCtx attaches trace to ctx and returns the new context.
 func (t *http2Server) HandleStreams(handle func(*Stream), traceCtx func(context.Context, string) context.Context) {
-        // Check the validity of client preface.
-        preface := make([]byte, len(clientPreface))
-        if _, err := io.ReadFull(t.conn, preface); err != nil {
-                // Only log if it isn't a simple tcp accept check (ie: tcp balancer doing open/close socket)
-                if err != io.EOF {
-                        errorf("transport: http2Server.HandleStreams failed to receive the preface from client: %v", err)
-                }
-                t.Close()
-                return
-        }
-        if !bytes.Equal(preface, clientPreface) {
-                errorf("transport: http2Server.HandleStreams received bogus greeting from client: %q", preface)
-                t.Close()
-                return
-        }
-
-        frame, err := t.framer.readFrame()
-        if err == io.EOF || err == io.ErrUnexpectedEOF {
-                t.Close()
-                return
-        }
-        if err != nil {
-                errorf("transport: http2Server.HandleStreams failed to read initial settings frame: %v", err)
-                t.Close()
-                return
-        }
-        atomic.StoreUint32(&t.activity, 1)
-        sf, ok := frame.(*http2.SettingsFrame)
-        if !ok {
-                errorf("transport: http2Server.HandleStreams saw invalid preface type %T from client", frame)
-                t.Close()
-                return
-        }
-        t.handleSettings(sf)
-
+        defer close(t.readerDone)
         for {
-                frame, err := t.framer.readFrame()
+                frame, err := t.framer.fr.ReadFrame()
                 atomic.StoreUint32(&t.activity, 1)
                 if err != nil {
                         if se, ok := err.(http2.StreamError); ok {
+                                warningf("transport: http2Server.HandleStreams encountered http2.StreamError: %v", se)
                                 t.mu.Lock()
                                 s := t.activeStreams[se.StreamID]
                                 t.mu.Unlock()
                                 if s != nil {
-                                        t.closeStream(s)
+                                        t.closeStream(s, true, se.Code, nil, false)
+                                } else {
+                                        t.controlBuf.put(&cleanupStream{
+                                                streamID: se.StreamID,
+                                                rst:      true,
+                                                rstCode:  se.Code,
+                                                onWrite:  func() {},
+                                        })
                                 }
-                                t.controlBuf.put(&resetStream{se.StreamID, se.Code})
                                 continue
                         }
                         if err == io.EOF || err == io.ErrUnexpectedEOF {
@@ -443,33 +497,20 @@ func (t *http2Server) getStream(f http2.Frame) (*Stream, bool) {
 // of stream if the application is requesting data larger in size than
 // the window.
 func (t *http2Server) adjustWindow(s *Stream, n uint32) {
-        s.mu.Lock()
-        defer s.mu.Unlock()
-        if s.state == streamDone {
-                return
-        }
         if w := s.fc.maybeAdjust(n); w > 0 {
-                if cw := t.fc.resetPendingUpdate(); cw > 0 {
-                        t.controlBuf.put(&windowUpdate{0, cw, false})
-                }
-                t.controlBuf.put(&windowUpdate{s.id, w, true})
+                t.controlBuf.put(&outgoingWindowUpdate{streamID: s.id, increment: w})
         }
+
 }
 
 // updateWindow adjusts the inbound quota for the stream and the transport.
 // Window updates will deliver to the controller for sending when
 // the cumulative quota exceeds the corresponding threshold.
 func (t *http2Server) updateWindow(s *Stream, n uint32) {
-        s.mu.Lock()
-        defer s.mu.Unlock()
-        if s.state == streamDone {
-                return
-        }
         if w := s.fc.onRead(n); w > 0 {
-                if cw := t.fc.resetPendingUpdate(); cw > 0 {
-                        t.controlBuf.put(&windowUpdate{0, cw, false})
-                }
-                t.controlBuf.put(&windowUpdate{s.id, w, true})
+                t.controlBuf.put(&outgoingWindowUpdate{streamID: s.id,
+                        increment: w,
+                })
         }
 }
 
@@ -483,13 +524,15 @@ func (t *http2Server) updateFlowControl(n uint32) {
         }
         t.initialWindowSize = int32(n)
         t.mu.Unlock()
-        t.controlBuf.put(&windowUpdate{0, t.fc.newLimit(n), false})
-        t.controlBuf.put(&settings{
-                ack: false,
+        t.controlBuf.put(&outgoingWindowUpdate{
+                streamID:  0,
+                increment: t.fc.newLimit(n),
+        })
+        t.controlBuf.put(&outgoingSettings{
                 ss: []http2.Setting{
                         {
                                 ID:  http2.SettingInitialWindowSize,
-                                Val: uint32(n),
+                                Val: n,
                         },
                 },
         })
@@ -500,7 +543,7 @@ func (t *http2Server) handleData(f *http2.DataFrame) {
         size := f.Header().Length
         var sendBDPPing bool
         if t.bdpEst != nil {
-                sendBDPPing = t.bdpEst.add(uint32(size))
+                sendBDPPing = t.bdpEst.add(size)
         }
         // Decouple connection's flow control from application's read.
         // An update on connection's flow control should not depend on
@@ -510,21 +553,22 @@ func (t *http2Server) handleData(f *http2.DataFrame) {
         // Decoupling the connection flow control will prevent other
         // active(fast) streams from starving in presence of slow or
         // inactive streams.
-        //
-        // Furthermore, if a bdpPing is being sent out we can piggyback
-        // connection's window update for the bytes we just received.
+        if w := t.fc.onData(size); w > 0 {
+                t.controlBuf.put(&outgoingWindowUpdate{
+                        streamID:  0,
+                        increment: w,
+                })
+        }
         if sendBDPPing {
-                t.controlBuf.put(&windowUpdate{0, uint32(size), false})
-                t.controlBuf.put(bdpPing)
-        } else {
-                if err := t.fc.onData(uint32(size)); err != nil {
-                        errorf("transport: http2Server %v", err)
-                        t.Close()
-                        return
-                }
-                if w := t.fc.onRead(uint32(size)); w > 0 {
-                        t.controlBuf.put(&windowUpdate{0, w, true})
+                // Avoid excessive ping detection (e.g. in an L7 proxy)
+                // by sending a window update prior to the BDP ping.
+                if w := t.fc.reset(); w > 0 {
+                        t.controlBuf.put(&outgoingWindowUpdate{
+                                streamID:  0,
+                                increment: w,
+                        })
                 }
+                t.controlBuf.put(bdpPing)
         }
         // Select the right stream to dispatch.
         s, ok := t.getStream(f)
@@ -532,23 +576,15 @@ func (t *http2Server) handleData(f *http2.DataFrame) {
                 return
         }
         if size > 0 {
-                s.mu.Lock()
-                if s.state == streamDone {
-                        s.mu.Unlock()
-                        return
-                }
-                if err := s.fc.onData(uint32(size)); err != nil {
-                        s.mu.Unlock()
-                        t.closeStream(s)
-                        t.controlBuf.put(&resetStream{s.id, http2.ErrCodeFlowControl})
+                if err := s.fc.onData(size); err != nil {
+                        t.closeStream(s, true, http2.ErrCodeFlowControl, nil, false)
                         return
                 }
                 if f.Header().Flags.Has(http2.FlagDataPadded) {
-                        if w := s.fc.onRead(uint32(size) - uint32(len(f.Data()))); w > 0 {
-                                t.controlBuf.put(&windowUpdate{s.id, w, true})
+                        if w := s.fc.onRead(size - uint32(len(f.Data()))); w > 0 {
+                                t.controlBuf.put(&outgoingWindowUpdate{s.id, w})
                         }
                 }
-                s.mu.Unlock()
                 // TODO(bradfitz, zhaoq): A copy is required here because there is no
                 // guarantee f.Data() is consumed before the arrival of next frame.
                 // Can this copy be eliminated?
@@ -560,11 +596,7 @@ func (t *http2Server) handleData(f *http2.DataFrame) {
         }
         if f.Header().Flags.Has(http2.FlagDataEndStream) {
                 // Received the end of stream from the client.
-                s.mu.Lock()
-                if s.state != streamDone {
-                        s.state = streamReadDone
-                }
-                s.mu.Unlock()
+                s.compareAndSwapState(streamActive, streamReadDone)
                 s.write(recvMsg{err: io.EOF})
         }
 }
@@ -574,7 +606,7 @@ func (t *http2Server) handleRSTStream(f *http2.RSTStreamFrame) {
         if !ok {
                 return
         }
-        t.closeStream(s)
+        t.closeStream(s, false, 0, nil, false)
 }
 
 func (t *http2Server) handleSettings(f *http2.SettingsFrame) {
@@ -582,12 +614,27 @@ func (t *http2Server) handleSettings(f *http2.SettingsFrame) {
                 return
         }
         var ss []http2.Setting
+        var updateFuncs []func()
         f.ForeachSetting(func(s http2.Setting) error {
-                ss = append(ss, s)
+                switch s.ID {
+                case http2.SettingMaxHeaderListSize:
+                        updateFuncs = append(updateFuncs, func() {
+                                t.maxSendHeaderListSize = new(uint32)
+                                *t.maxSendHeaderListSize = s.Val
+                        })
+                default:
+                        ss = append(ss, s)
+                }
                 return nil
         })
-        // The settings will be applied once the ack is sent.
-        t.controlBuf.put(&settings{ack: true, ss: ss})
+        t.controlBuf.executeAndPut(func(interface{}) bool {
+                for _, f := range updateFuncs {
+                        f()
+                }
+                return true
+        }, &incomingSettings{
+                ss: ss,
+        })
 }
 
 const (
@@ -627,7 +674,7 @@ func (t *http2Server) handlePing(f *http2.PingFrame) {
         t.mu.Unlock()
         if ns < 1 && !t.kep.PermitWithoutStream {
                 // Keepalive shouldn't be active thus, this new ping should
-                // have come after atleast defaultPingTimeout.
+                // have come after at least defaultPingTimeout.
                 if t.lastPingAt.Add(defaultPingTimeout).After(now) {
                         t.pingStrikes++
                 }
@@ -640,69 +687,52 @@ func (t *http2Server) handlePing(f *http2.PingFrame) {
 
         if t.pingStrikes > maxPingStrikes {
                 // Send goaway and close the connection.
+                errorf("transport: Got too many pings from the client, closing the connection.")
                 t.controlBuf.put(&goAway{code: http2.ErrCodeEnhanceYourCalm, debugData: []byte("too_many_pings"), closeConn: true})
         }
 }
 
 func (t *http2Server) handleWindowUpdate(f *http2.WindowUpdateFrame) {
-        id := f.Header().StreamID
-        incr := f.Increment
-        if id == 0 {
-                t.sendQuotaPool.add(int(incr))
-                return
-        }
-        if s, ok := t.getStream(f); ok {
-                s.sendQuotaPool.add(int(incr))
-        }
+        t.controlBuf.put(&incomingWindowUpdate{
+                streamID:  f.Header().StreamID,
+                increment: f.Increment,
+        })
 }
 
-func (t *http2Server) writeHeaders(s *Stream, b *bytes.Buffer, endStream bool) error {
-        first := true
-        endHeaders := false
-        var err error
-        defer func() {
-                if err == nil {
-                        // Reset ping strikes when seding headers since that might cause the
-                        // peer to send ping.
-                        atomic.StoreUint32(&t.resetPingStrikes, 1)
-                }
-        }()
-        // Sends the headers in a single batch.
-        for !endHeaders {
-                size := t.hBuf.Len()
-                if size > http2MaxFrameLen {
-                        size = http2MaxFrameLen
-                } else {
-                        endHeaders = true
+func appendHeaderFieldsFromMD(headerFields []hpack.HeaderField, md metadata.MD) []hpack.HeaderField {
+        for k, vv := range md {
+                if isReservedHeader(k) {
+                        // Clients don't tolerate reading restricted headers after some non restricted ones were sent.
+                        continue
                 }
-                if first {
-                        p := http2.HeadersFrameParam{
-                                StreamID:      s.id,
-                                BlockFragment: b.Next(size),
-                                EndStream:     endStream,
-                                EndHeaders:    endHeaders,
-                        }
-                        err = t.framer.writeHeaders(endHeaders, p)
-                        first = false
-                } else {
-                        err = t.framer.writeContinuation(endHeaders, s.id, endHeaders, b.Next(size))
+                for _, v := range vv {
+                        headerFields = append(headerFields, hpack.HeaderField{Name: k, Value: encodeMetadataHeader(k, v)})
                 }
-                if err != nil {
-                        t.Close()
-                        return connectionErrorf(true, err, "transport: %v", err)
+        }
+        return headerFields
+}
+
+func (t *http2Server) checkForHeaderListSize(it interface{}) bool {
+        if t.maxSendHeaderListSize == nil {
+                return true
+        }
+        hdrFrame := it.(*headerFrame)
+        var sz int64
+        for _, f := range hdrFrame.hf {
+                if sz += int64(f.Size()); sz > int64(*t.maxSendHeaderListSize) {
+                        errorf("header list size to send violates the maximum size (%d bytes) set by client", *t.maxSendHeaderListSize)
+                        return false
                 }
         }
-        return nil
+        return true
 }
 
 // WriteHeader sends the header metedata md back to the client.
 func (t *http2Server) WriteHeader(s *Stream, md metadata.MD) error {
-        s.mu.Lock()
-        if s.headerOk || s.state == streamDone {
-                s.mu.Unlock()
+        if s.updateHeaderSent() || s.getState() == streamDone {
                 return ErrIllegalHeaderWrite
         }
-        s.headerOk = true
+        s.hdrMu.Lock()
         if md.Len() > 0 {
                 if s.header.Len() > 0 {
                         s.header = metadata.Join(s.header, md)
@@ -710,37 +740,45 @@ func (t *http2Server) WriteHeader(s *Stream, md metadata.MD) error {
                         s.header = md
                 }
         }
-        md = s.header
-        s.mu.Unlock()
-        if _, err := wait(s.ctx, nil, nil, t.shutdownChan, t.writableChan); err != nil {
+        if err := t.writeHeaderLocked(s); err != nil {
+                s.hdrMu.Unlock()
                 return err
         }
-        t.hBuf.Reset()
-        t.hEnc.WriteField(hpack.HeaderField{Name: ":status", Value: "200"})
-        t.hEnc.WriteField(hpack.HeaderField{Name: "content-type", Value: "application/grpc"})
+        s.hdrMu.Unlock()
+        return nil
+}
+
+func (t *http2Server) writeHeaderLocked(s *Stream) error {
+        // TODO(mmukhi): Benchmark if the performance gets better if count the metadata and other header fields
+        // first and create a slice of that exact size.
+        headerFields := make([]hpack.HeaderField, 0, 2) // at least :status, content-type will be there if none else.
+        headerFields = append(headerFields, hpack.HeaderField{Name: ":status", Value: "200"})
+        headerFields = append(headerFields, hpack.HeaderField{Name: "content-type", Value: contentType(s.contentSubtype)})
         if s.sendCompress != "" {
-                t.hEnc.WriteField(hpack.HeaderField{Name: "grpc-encoding", Value: s.sendCompress})
-        }
-        for k, vv := range md {
-                if isReservedHeader(k) {
-                        // Clients don't tolerate reading restricted headers after some non restricted ones were sent.
-                        continue
-                }
-                for _, v := range vv {
-                        t.hEnc.WriteField(hpack.HeaderField{Name: k, Value: encodeMetadataHeader(k, v)})
+                headerFields = append(headerFields, hpack.HeaderField{Name: "grpc-encoding", Value: s.sendCompress})
+        }
+        headerFields = appendHeaderFieldsFromMD(headerFields, s.header)
+        success, err := t.controlBuf.executeAndPut(t.checkForHeaderListSize, &headerFrame{
+                streamID:  s.id,
+                hf:        headerFields,
+                endStream: false,
+                onWrite: func() {
+                        atomic.StoreUint32(&t.resetPingStrikes, 1)
+                },
+        })
+        if !success {
+                if err != nil {
+                        return err
                 }
-        }
-        bufLen := t.hBuf.Len()
-        if err := t.writeHeaders(s, t.hBuf, false); err != nil {
-                return err
+                t.closeStream(s, true, http2.ErrCodeInternal, nil, false)
+                return ErrHeaderListSizeLimitViolation
         }
         if t.stats != nil {
-                outHeader := &stats.OutHeader{
-                        WireLength: bufLen,
-                }
+                // Note: WireLength is not set in outHeader.
+                // TODO(mmukhi): Revisit this later, if needed.
+                outHeader := &stats.OutHeader{}
                 t.stats.HandleRPC(s.Context(), outHeader)
         }
-        t.writableChan <- 0
         return nil
 }
 
@@ -749,204 +787,108 @@ func (t *http2Server) WriteHeader(s *Stream, md metadata.MD) error {
 // TODO(zhaoq): Now it indicates the end of entire stream. Revisit if early
 // OK is adopted.
 func (t *http2Server) WriteStatus(s *Stream, st *status.Status) error {
-        var headersSent, hasHeader bool
-        s.mu.Lock()
-        if s.state == streamDone {
-                s.mu.Unlock()
+        if s.getState() == streamDone {
                 return nil
         }
-        if s.headerOk {
-                headersSent = true
-        }
-        if s.header.Len() > 0 {
-                hasHeader = true
-        }
-        s.mu.Unlock()
-
-        if !headersSent && hasHeader {
-                t.WriteHeader(s, nil)
-                headersSent = true
-        }
-
-        if _, err := wait(s.ctx, nil, nil, t.shutdownChan, t.writableChan); err != nil {
-                return err
-        }
-        t.hBuf.Reset()
-        if !headersSent {
-                t.hEnc.WriteField(hpack.HeaderField{Name: ":status", Value: "200"})
-                t.hEnc.WriteField(hpack.HeaderField{Name: "content-type", Value: "application/grpc"})
+        s.hdrMu.Lock()
+        // TODO(mmukhi): Benchmark if the performance gets better if count the metadata and other header fields
+        // first and create a slice of that exact size.
+        headerFields := make([]hpack.HeaderField, 0, 2) // grpc-status and grpc-message will be there if none else.
+        if !s.updateHeaderSent() {                      // No headers have been sent.
+                if len(s.header) > 0 { // Send a separate header frame.
+                        if err := t.writeHeaderLocked(s); err != nil {
+                                s.hdrMu.Unlock()
+                                return err
+                        }
+                } else { // Send a trailer only response.
+                        headerFields = append(headerFields, hpack.HeaderField{Name: ":status", Value: "200"})
+                        headerFields = append(headerFields, hpack.HeaderField{Name: "content-type", Value: contentType(s.contentSubtype)})
+                }
         }
-        t.hEnc.WriteField(
-                hpack.HeaderField{
-                        Name:  "grpc-status",
-                        Value: strconv.Itoa(int(st.Code())),
-                })
-        t.hEnc.WriteField(hpack.HeaderField{Name: "grpc-message", Value: encodeGrpcMessage(st.Message())})
+        headerFields = append(headerFields, hpack.HeaderField{Name: "grpc-status", Value: strconv.Itoa(int(st.Code()))})
+        headerFields = append(headerFields, hpack.HeaderField{Name: "grpc-message", Value: encodeGrpcMessage(st.Message())})
 
         if p := st.Proto(); p != nil && len(p.Details) > 0 {
                 stBytes, err := proto.Marshal(p)
                 if err != nil {
                         // TODO: return error instead, when callers are able to handle it.
-                        panic(err)
+                        grpclog.Errorf("transport: failed to marshal rpc status: %v, error: %v", p, err)
+                } else {
+                        headerFields = append(headerFields, hpack.HeaderField{Name: "grpc-status-details-bin", Value: encodeBinHeader(stBytes)})
                 }
-
-                t.hEnc.WriteField(hpack.HeaderField{Name: "grpc-status-details-bin", Value: encodeBinHeader(stBytes)})
         }
 
         // Attach the trailer metadata.
-        for k, vv := range s.trailer {
-                // Clients don't tolerate reading restricted headers after some non restricted ones were sent.
-                if isReservedHeader(k) {
-                        continue
-                }
-                for _, v := range vv {
-                        t.hEnc.WriteField(hpack.HeaderField{Name: k, Value: encodeMetadataHeader(k, v)})
-                }
+        headerFields = appendHeaderFieldsFromMD(headerFields, s.trailer)
+        trailingHeader := &headerFrame{
+                streamID:  s.id,
+                hf:        headerFields,
+                endStream: true,
+                onWrite: func() {
+                        atomic.StoreUint32(&t.resetPingStrikes, 1)
+                },
         }
-        bufLen := t.hBuf.Len()
-        if err := t.writeHeaders(s, t.hBuf, true); err != nil {
-                t.Close()
-                return err
+        s.hdrMu.Unlock()
+        success, err := t.controlBuf.execute(t.checkForHeaderListSize, trailingHeader)
+        if !success {
+                if err != nil {
+                        return err
+                }
+                t.closeStream(s, true, http2.ErrCodeInternal, nil, false)
+                return ErrHeaderListSizeLimitViolation
         }
+        t.closeStream(s, false, 0, trailingHeader, true)
         if t.stats != nil {
-                outTrailer := &stats.OutTrailer{
-                        WireLength: bufLen,
-                }
-                t.stats.HandleRPC(s.Context(), outTrailer)
+                t.stats.HandleRPC(s.Context(), &stats.OutTrailer{})
         }
-        t.closeStream(s)
-        t.writableChan <- 0
         return nil
 }
 
 // Write converts the data into HTTP2 data frame and sends it out. Non-nil error
 // is returns if it fails (e.g., framing error, transport error).
-func (t *http2Server) Write(s *Stream, data []byte, opts *Options) (err error) {
-        // TODO(zhaoq): Support multi-writers for a single stream.
-        var writeHeaderFrame bool
-        s.mu.Lock()
-        if s.state == streamDone {
-                s.mu.Unlock()
-                return streamErrorf(codes.Unknown, "the stream has been done")
-        }
-        if !s.headerOk {
-                writeHeaderFrame = true
-        }
-        s.mu.Unlock()
-        if writeHeaderFrame {
-                t.WriteHeader(s, nil)
-        }
-        r := bytes.NewBuffer(data)
-        var (
-                p   []byte
-                oqv uint32
-        )
-        for {
-                if r.Len() == 0 && p == nil {
-                        return nil
-                }
-                oqv = atomic.LoadUint32(&t.outQuotaVersion)
-                size := http2MaxFrameLen
-                // Wait until the stream has some quota to send the data.
-                sq, err := wait(s.ctx, nil, nil, t.shutdownChan, s.sendQuotaPool.acquire())
-                if err != nil {
-                        return err
-                }
-                // Wait until the transport has some quota to send the data.
-                tq, err := wait(s.ctx, nil, nil, t.shutdownChan, t.sendQuotaPool.acquire())
-                if err != nil {
-                        return err
-                }
-                if sq < size {
-                        size = sq
-                }
-                if tq < size {
-                        size = tq
+func (t *http2Server) Write(s *Stream, hdr []byte, data []byte, opts *Options) error {
+        if !s.isHeaderSent() { // Headers haven't been written yet.
+                if err := t.WriteHeader(s, nil); err != nil {
+                        // TODO(mmukhi, dfawley): Make sure this is the right code to return.
+                        return status.Errorf(codes.Internal, "transport: %v", err)
                 }
-                if p == nil {
-                        p = r.Next(size)
-                }
-                ps := len(p)
-                if ps < sq {
-                        // Overbooked stream quota. Return it back.
-                        s.sendQuotaPool.add(sq - ps)
-                }
-                if ps < tq {
-                        // Overbooked transport quota. Return it back.
-                        t.sendQuotaPool.add(tq - ps)
-                }
-                t.framer.adjustNumWriters(1)
-                // Got some quota. Try to acquire writing privilege on the
-                // transport.
-                if _, err := wait(s.ctx, nil, nil, t.shutdownChan, t.writableChan); err != nil {
-                        if _, ok := err.(StreamError); ok {
-                                // Return the connection quota back.
-                                t.sendQuotaPool.add(ps)
-                        }
-                        if t.framer.adjustNumWriters(-1) == 0 {
-                                // This writer is the last one in this batch and has the
-                                // responsibility to flush the buffered frames. It queues
-                                // a flush request to controlBuf instead of flushing directly
-                                // in order to avoid the race with other writing or flushing.
-                                t.controlBuf.put(&flushIO{})
-                        }
-                        return err
-                }
-                select {
-                case <-s.ctx.Done():
-                        t.sendQuotaPool.add(ps)
-                        if t.framer.adjustNumWriters(-1) == 0 {
-                                t.controlBuf.put(&flushIO{})
+        } else {
+                // Writing headers checks for this condition.
+                if s.getState() == streamDone {
+                        // TODO(mmukhi, dfawley): Should the server write also return io.EOF?
+                        s.cancel()
+                        select {
+                        case <-t.ctx.Done():
+                                return ErrConnClosing
+                        default:
                         }
-                        t.writableChan <- 0
                         return ContextErr(s.ctx.Err())
-                default:
-                }
-                if oqv != atomic.LoadUint32(&t.outQuotaVersion) {
-                        // InitialWindowSize settings frame must have been received after we
-                        // acquired send quota but before we got the writable channel.
-                        // We must forsake this write.
-                        t.sendQuotaPool.add(ps)
-                        s.sendQuotaPool.add(ps)
-                        if t.framer.adjustNumWriters(-1) == 0 {
-                                t.controlBuf.put(&flushIO{})
-                        }
-                        t.writableChan <- 0
-                        continue
-                }
-                var forceFlush bool
-                if r.Len() == 0 && t.framer.adjustNumWriters(0) == 1 && !opts.Last {
-                        forceFlush = true
-                }
-                // Reset ping strikes when sending data since this might cause
-                // the peer to send ping.
-                atomic.StoreUint32(&t.resetPingStrikes, 1)
-                if err := t.framer.writeData(forceFlush, s.id, false, p); err != nil {
-                        t.Close()
-                        return connectionErrorf(true, err, "transport: %v", err)
                 }
-                p = nil
-                if t.framer.adjustNumWriters(-1) == 0 {
-                        t.framer.flushWrite()
-                }
-                t.writableChan <- 0
         }
-
-}
-
-func (t *http2Server) applySettings(ss []http2.Setting) {
-        for _, s := range ss {
-                if s.ID == http2.SettingInitialWindowSize {
-                        t.mu.Lock()
-                        defer t.mu.Unlock()
-                        for _, stream := range t.activeStreams {
-                                stream.sendQuotaPool.add(int(s.Val) - int(t.streamSendQuota))
-                        }
-                        t.streamSendQuota = s.Val
-                        atomic.AddUint32(&t.outQuotaVersion, 1)
+        // Add some data to header frame so that we can equally distribute bytes across frames.
+        emptyLen := http2MaxFrameLen - len(hdr)
+        if emptyLen > len(data) {
+                emptyLen = len(data)
+        }
+        hdr = append(hdr, data[:emptyLen]...)
+        data = data[emptyLen:]
+        df := &dataFrame{
+                streamID: s.id,
+                h:        hdr,
+                d:        data,
+                onEachWrite: func() {
+                        atomic.StoreUint32(&t.resetPingStrikes, 1)
+                },
+        }
+        if err := s.wq.get(int32(len(hdr) + len(data))); err != nil {
+                select {
+                case <-t.ctx.Done():
+                        return ErrConnClosing
+                default:
                 }
-
+                return ContextErr(s.ctx.Err())
         }
+        return t.controlBuf.put(df)
 }
 
 // keepalive running in a separate goroutine does the following:
@@ -962,7 +904,7 @@ func (t *http2Server) keepalive() {
         maxAge := time.NewTimer(t.kp.MaxConnectionAge)
         keepalive := time.NewTimer(t.kp.Time)
         // NOTE: All exit paths of this function should reset their
-        // respecitve timers. A failure to do so will cause the
+        // respective timers. A failure to do so will cause the
         // following clean-up to deadlock and eventually leak.
         defer func() {
                 if !maxIdle.Stop() {
@@ -991,7 +933,7 @@ func (t *http2Server) keepalive() {
                                 // The connection has been idle for a duration of keepalive.MaxConnectionIdle or more.
                                 // Gracefully close the connection.
                                 t.drain(http2.ErrCodeNo, []byte{})
-                                // Reseting the timer so that the clean-up doesn't deadlock.
+                                // Resetting the timer so that the clean-up doesn't deadlock.
                                 maxIdle.Reset(infinity)
                                 return
                         }
@@ -1003,9 +945,9 @@ func (t *http2Server) keepalive() {
                         case <-maxAge.C:
                                 // Close the connection after grace period.
                                 t.Close()
-                                // Reseting the timer so that the clean-up doesn't deadlock.
+                                // Resetting the timer so that the clean-up doesn't deadlock.
                                 maxAge.Reset(infinity)
-                        case <-t.shutdownChan:
+                        case <-t.ctx.Done():
                         }
                         return
                 case <-keepalive.C:
@@ -1016,98 +958,17 @@ func (t *http2Server) keepalive() {
                         }
                         if pingSent {
                                 t.Close()
-                                // Reseting the timer so that the clean-up doesn't deadlock.
+                                // Resetting the timer so that the clean-up doesn't deadlock.
                                 keepalive.Reset(infinity)
                                 return
                         }
                         pingSent = true
+                        if channelz.IsOn() {
+                                atomic.AddInt64(&t.czData.kpCount, 1)
+                        }
                         t.controlBuf.put(p)
                         keepalive.Reset(t.kp.Timeout)
-                case <-t.shutdownChan:
-                        return
-                }
-        }
-}
-
-var goAwayPing = &ping{data: [8]byte{1, 6, 1, 8, 0, 3, 3, 9}}
-
-// controller running in a separate goroutine takes charge of sending control
-// frames (e.g., window update, reset stream, setting, etc.) to the server.
-func (t *http2Server) controller() {
-        for {
-                select {
-                case i := <-t.controlBuf.get():
-                        t.controlBuf.load()
-                        select {
-                        case <-t.writableChan:
-                                switch i := i.(type) {
-                                case *windowUpdate:
-                                        t.framer.writeWindowUpdate(i.flush, i.streamID, i.increment)
-                                case *settings:
-                                        if i.ack {
-                                                t.framer.writeSettingsAck(true)
-                                                t.applySettings(i.ss)
-                                        } else {
-                                                t.framer.writeSettings(true, i.ss...)
-                                        }
-                                case *resetStream:
-                                        t.framer.writeRSTStream(true, i.streamID, i.code)
-                                case *goAway:
-                                        t.mu.Lock()
-                                        if t.state == closing {
-                                                t.mu.Unlock()
-                                                // The transport is closing.
-                                                return
-                                        }
-                                        sid := t.maxStreamID
-                                        if !i.headsUp {
-                                                // Stop accepting more streams now.
-                                                t.state = draining
-                                                t.mu.Unlock()
-                                                t.framer.writeGoAway(true, sid, i.code, i.debugData)
-                                                if i.closeConn {
-                                                        // Abruptly close the connection following the GoAway.
-                                                        t.Close()
-                                                }
-                                                t.writableChan <- 0
-                                                continue
-                                        }
-                                        t.mu.Unlock()
-                                        // For a graceful close, send out a GoAway with stream ID of MaxUInt32,
-                                        // Follow that with a ping and wait for the ack to come back or a timer
-                                        // to expire. During this time accept new streams since they might have
-                                        // originated before the GoAway reaches the client.
-                                        // After getting the ack or timer expiration send out another GoAway this
-                                        // time with an ID of the max stream server intends to process.
-                                        t.framer.writeGoAway(true, math.MaxUint32, http2.ErrCodeNo, []byte{})
-                                        t.framer.writePing(true, false, goAwayPing.data)
-                                        go func() {
-                                                timer := time.NewTimer(time.Minute)
-                                                defer timer.Stop()
-                                                select {
-                                                case <-t.drainChan:
-                                                case <-timer.C:
-                                                case <-t.shutdownChan:
-                                                        return
-                                                }
-                                                t.controlBuf.put(&goAway{code: i.code, debugData: i.debugData})
-                                        }()
-                                case *flushIO:
-                                        t.framer.flushWrite()
-                                case *ping:
-                                        if !i.ack {
-                                                t.bdpEst.timesnap(i.data)
-                                        }
-                                        t.framer.writePing(true, i.ack, i.data)
-                                default:
-                                        errorf("transport: http2Server.controller got unexpected item type %v\n", i)
-                                }
-                                t.writableChan <- 0
-                                continue
-                        case <-t.shutdownChan:
-                                return
-                        }
-                case <-t.shutdownChan:
+                case <-t.ctx.Done():
                         return
                 }
         }
@@ -1116,7 +977,7 @@ func (t *http2Server) controller() {
 // Close starts shutting down the http2Server transport.
 // TODO(zhaoq): Now the destruction is not blocked on any pending streams. This
 // could cause some resource issue. Revisit this later.
-func (t *http2Server) Close() (err error) {
+func (t *http2Server) Close() error {
         t.mu.Lock()
         if t.state == closing {
                 t.mu.Unlock()
@@ -1126,8 +987,12 @@ func (t *http2Server) Close() (err error) {
         streams := t.activeStreams
         t.activeStreams = nil
         t.mu.Unlock()
-        close(t.shutdownChan)
-        err = t.conn.Close()
+        t.controlBuf.finish()
+        t.cancel()
+        err := t.conn.Close()
+        if channelz.IsOn() {
+                channelz.RemoveEntry(t.channelzID)
+        }
         // Cancel all active streams.
         for _, s := range streams {
                 s.cancel()
@@ -1136,32 +1001,48 @@ func (t *http2Server) Close() (err error) {
                 connEnd := &stats.ConnEnd{}
                 t.stats.HandleConn(t.ctx, connEnd)
         }
-        return
+        return err
 }
 
 // closeStream clears the footprint of a stream when the stream is not needed
 // any more.
-func (t *http2Server) closeStream(s *Stream) {
-        t.mu.Lock()
-        delete(t.activeStreams, s.id)
-        if len(t.activeStreams) == 0 {
-                t.idle = time.Now()
-        }
-        if t.state == draining && len(t.activeStreams) == 0 {
-                defer t.Close()
+func (t *http2Server) closeStream(s *Stream, rst bool, rstCode http2.ErrCode, hdr *headerFrame, eosReceived bool) {
+        if s.swapState(streamDone) == streamDone {
+                // If the stream was already done, return.
+                return
         }
-        t.mu.Unlock()
         // In case stream sending and receiving are invoked in separate
         // goroutines (e.g., bi-directional streaming), cancel needs to be
         // called to interrupt the potential blocking on other goroutines.
         s.cancel()
-        s.mu.Lock()
-        if s.state == streamDone {
-                s.mu.Unlock()
-                return
+        cleanup := &cleanupStream{
+                streamID: s.id,
+                rst:      rst,
+                rstCode:  rstCode,
+                onWrite: func() {
+                        t.mu.Lock()
+                        if t.activeStreams != nil {
+                                delete(t.activeStreams, s.id)
+                                if len(t.activeStreams) == 0 {
+                                        t.idle = time.Now()
+                                }
+                        }
+                        t.mu.Unlock()
+                        if channelz.IsOn() {
+                                if eosReceived {
+                                        atomic.AddInt64(&t.czData.streamsSucceeded, 1)
+                                } else {
+                                        atomic.AddInt64(&t.czData.streamsFailed, 1)
+                                }
+                        }
+                },
+        }
+        if hdr != nil {
+                hdr.cleanup = cleanup
+                t.controlBuf.put(hdr)
+        } else {
+                t.controlBuf.put(cleanup)
         }
-        s.state = streamDone
-        s.mu.Unlock()
 }
 
 func (t *http2Server) RemoteAddr() net.Addr {
@@ -1182,7 +1063,111 @@ func (t *http2Server) drain(code http2.ErrCode, debugData []byte) {
         t.controlBuf.put(&goAway{code: code, debugData: debugData, headsUp: true})
 }
 
-var rgen = rand.New(rand.NewSource(time.Now().UnixNano()))
+var goAwayPing = &ping{data: [8]byte{1, 6, 1, 8, 0, 3, 3, 9}}
+
+// Handles outgoing GoAway and returns true if loopy needs to put itself
+// in draining mode.
+func (t *http2Server) outgoingGoAwayHandler(g *goAway) (bool, error) {
+        t.mu.Lock()
+        if t.state == closing { // TODO(mmukhi): This seems unnecessary.
+                t.mu.Unlock()
+                // The transport is closing.
+                return false, ErrConnClosing
+        }
+        sid := t.maxStreamID
+        if !g.headsUp {
+                // Stop accepting more streams now.
+                t.state = draining
+                if len(t.activeStreams) == 0 {
+                        g.closeConn = true
+                }
+                t.mu.Unlock()
+                if err := t.framer.fr.WriteGoAway(sid, g.code, g.debugData); err != nil {
+                        return false, err
+                }
+                if g.closeConn {
+                        // Abruptly close the connection following the GoAway (via
+                        // loopywriter).  But flush out what's inside the buffer first.
+                        t.framer.writer.Flush()
+                        return false, fmt.Errorf("transport: Connection closing")
+                }
+                return true, nil
+        }
+        t.mu.Unlock()
+        // For a graceful close, send out a GoAway with stream ID of MaxUInt32,
+        // Follow that with a ping and wait for the ack to come back or a timer
+        // to expire. During this time accept new streams since they might have
+        // originated before the GoAway reaches the client.
+        // After getting the ack or timer expiration send out another GoAway this
+        // time with an ID of the max stream server intends to process.
+        if err := t.framer.fr.WriteGoAway(math.MaxUint32, http2.ErrCodeNo, []byte{}); err != nil {
+                return false, err
+        }
+        if err := t.framer.fr.WritePing(false, goAwayPing.data); err != nil {
+                return false, err
+        }
+        go func() {
+                timer := time.NewTimer(time.Minute)
+                defer timer.Stop()
+                select {
+                case <-t.drainChan:
+                case <-timer.C:
+                case <-t.ctx.Done():
+                        return
+                }
+                t.controlBuf.put(&goAway{code: g.code, debugData: g.debugData})
+        }()
+        return false, nil
+}
+
+func (t *http2Server) ChannelzMetric() *channelz.SocketInternalMetric {
+        s := channelz.SocketInternalMetric{
+                StreamsStarted:                   atomic.LoadInt64(&t.czData.streamsStarted),
+                StreamsSucceeded:                 atomic.LoadInt64(&t.czData.streamsSucceeded),
+                StreamsFailed:                    atomic.LoadInt64(&t.czData.streamsFailed),
+                MessagesSent:                     atomic.LoadInt64(&t.czData.msgSent),
+                MessagesReceived:                 atomic.LoadInt64(&t.czData.msgRecv),
+                KeepAlivesSent:                   atomic.LoadInt64(&t.czData.kpCount),
+                LastRemoteStreamCreatedTimestamp: time.Unix(0, atomic.LoadInt64(&t.czData.lastStreamCreatedTime)),
+                LastMessageSentTimestamp:         time.Unix(0, atomic.LoadInt64(&t.czData.lastMsgSentTime)),
+                LastMessageReceivedTimestamp:     time.Unix(0, atomic.LoadInt64(&t.czData.lastMsgRecvTime)),
+                LocalFlowControlWindow:           int64(t.fc.getSize()),
+                SocketOptions:                    channelz.GetSocketOption(t.conn),
+                LocalAddr:                        t.localAddr,
+                RemoteAddr:                       t.remoteAddr,
+                // RemoteName :
+        }
+        if au, ok := t.authInfo.(credentials.ChannelzSecurityInfo); ok {
+                s.Security = au.GetSecurityValue()
+        }
+        s.RemoteFlowControlWindow = t.getOutFlowWindow()
+        return &s
+}
+
+func (t *http2Server) IncrMsgSent() {
+        atomic.AddInt64(&t.czData.msgSent, 1)
+        atomic.StoreInt64(&t.czData.lastMsgSentTime, time.Now().UnixNano())
+}
+
+func (t *http2Server) IncrMsgRecv() {
+        atomic.AddInt64(&t.czData.msgRecv, 1)
+        atomic.StoreInt64(&t.czData.lastMsgRecvTime, time.Now().UnixNano())
+}
+
+func (t *http2Server) getOutFlowWindow() int64 {
+        resp := make(chan uint32)
+        timer := time.NewTimer(time.Second)
+        defer timer.Stop()
+        t.controlBuf.put(&outFlowControlSizeRequest{resp})
+        select {
+        case sz := <-resp:
+                return int64(sz)
+        case <-t.ctxDone:
+                return -1
+        case <-timer.C:
+                return -2
+        }
+}
 
 func getJitter(v time.Duration) time.Duration {
         if v == infinity {
@@ -1190,6 +1175,6 @@ func getJitter(v time.Duration) time.Duration {
         }
         // Generate a jitter between +/- 10% of the value.
         r := int64(v / 10)
-        j := rgen.Int63n(2*r) - r
+        j := grpcrand.Int63n(2*r) - r
         return time.Duration(j)
 }
diff --git a/vendor/google.golang.org/grpc/transport/http_util.go b/vendor/google.golang.org/grpc/internal/transport/http_util.go
index 685c6fb..77a2cfa 100644
--- a/vendor/google.golang.org/grpc/transport/http_util.go
+++ b/vendor/google.golang.org/grpc/internal/transport/http_util.go
@@ -24,12 +24,13 @@ import (
         "encoding/base64"
         "fmt"
         "io"
+        "math"
         "net"
         "net/http"
         "strconv"
         "strings"
-        "sync/atomic"
         "time"
+        "unicode/utf8"
 
         "github.com/golang/protobuf/proto"
         "golang.org/x/net/http2"
@@ -44,8 +45,12 @@ const (
         http2MaxFrameLen = 16384 // 16KB frame
         // http://http2.github.io/http2-spec/#SettingValues
         http2InitHeaderTableSize = 4096
-        // http2IOBufSize specifies the buffer size for sending frames.
-        http2IOBufSize = 32 * 1024
+        // baseContentType is the base content-type for gRPC.  This is a valid
+        // content-type on it's own, but can also include a content-subtype such as
+        // "proto" as a suffix after "+" or ";".  See
+        // https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#requests
+        // for more details.
+        baseContentType = "application/grpc"
 )
 
 var (
@@ -64,7 +69,7 @@ var (
                 http2.ErrCodeConnect:            codes.Internal,
                 http2.ErrCodeEnhanceYourCalm:    codes.ResourceExhausted,
                 http2.ErrCodeInadequateSecurity: codes.PermissionDenied,
-                http2.ErrCodeHTTP11Required:     codes.FailedPrecondition,
+                http2.ErrCodeHTTP11Required:     codes.Internal,
         }
         statusCodeConvTab = map[codes.Code]http2.ErrCode{
                 codes.Internal:          http2.ErrCodeInternal,
@@ -111,7 +116,12 @@ type decodeState struct {
         timeout    time.Duration
         method     string
         // key-value metadata map from the peer.
-        mdata map[string][]string
+        mdata          map[string][]string
+        statsTags      []byte
+        statsTrace     []byte
+        contentSubtype string
+        // whether decoding on server side or not
+        serverSide bool
 }
 
 // isReservedHeader checks whether hdr belongs to HTTP2 headers
@@ -123,12 +133,16 @@ func isReservedHeader(hdr string) bool {
         }
         switch hdr {
         case "content-type",
+                "user-agent",
                 "grpc-message-type",
                 "grpc-encoding",
                 "grpc-message",
                 "grpc-status",
                 "grpc-timeout",
                 "grpc-status-details-bin",
+                // Intentionally exclude grpc-previous-rpc-attempts and
+                // grpc-retry-pushback-ms, which are "reserved", but their API
+                // intentionally works via metadata.
                 "te":
                 return true
         default:
@@ -136,28 +150,55 @@ func isReservedHeader(hdr string) bool {
         }
 }
 
-// isWhitelistedPseudoHeader checks whether hdr belongs to HTTP2 pseudoheaders
-// that should be propagated into metadata visible to users.
-func isWhitelistedPseudoHeader(hdr string) bool {
+// isWhitelistedHeader checks whether hdr should be propagated into metadata
+// visible to users, even though it is classified as "reserved", above.
+func isWhitelistedHeader(hdr string) bool {
         switch hdr {
-        case ":authority":
+        case ":authority", "user-agent":
                 return true
         default:
                 return false
         }
 }
 
-func validContentType(t string) bool {
-        e := "application/grpc"
-        if !strings.HasPrefix(t, e) {
-                return false
+// contentSubtype returns the content-subtype for the given content-type.  The
+// given content-type must be a valid content-type that starts with
+// "application/grpc". A content-subtype will follow "application/grpc" after a
+// "+" or ";". See
+// https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#requests for
+// more details.
+//
+// If contentType is not a valid content-type for gRPC, the boolean
+// will be false, otherwise true. If content-type == "application/grpc",
+// "application/grpc+", or "application/grpc;", the boolean will be true,
+// but no content-subtype will be returned.
+//
+// contentType is assumed to be lowercase already.
+func contentSubtype(contentType string) (string, bool) {
+        if contentType == baseContentType {
+                return "", true
+        }
+        if !strings.HasPrefix(contentType, baseContentType) {
+                return "", false
+        }
+        // guaranteed since != baseContentType and has baseContentType prefix
+        switch contentType[len(baseContentType)] {
+        case '+', ';':
+                // this will return true for "application/grpc+" or "application/grpc;"
+                // which the previous validContentType function tested to be valid, so we
+                // just say that no content-subtype is specified in this case
+                return contentType[len(baseContentType)+1:], true
+        default:
+                return "", false
         }
-        // Support variations on the content-type
-        // (e.g. "application/grpc+blah", "application/grpc;blah").
-        if len(t) > len(e) && t[len(e)] != '+' && t[len(e)] != ';' {
-                return false
+}
+
+// contentSubtype is assumed to be lowercase
+func contentType(contentSubtype string) string {
+        if contentSubtype == "" {
+                return baseContentType
         }
-        return true
+        return baseContentType + "+" + contentSubtype
 }
 
 func (d *decodeState) status() *status.Status {
@@ -197,13 +238,22 @@ func decodeMetadataHeader(k, v string) (string, error) {
         return v, nil
 }
 
-func (d *decodeState) decodeResponseHeader(frame *http2.MetaHeadersFrame) error {
+func (d *decodeState) decodeHeader(frame *http2.MetaHeadersFrame) error {
+        // frame.Truncated is set to true when framer detects that the current header
+        // list size hits MaxHeaderListSize limit.
+        if frame.Truncated {
+                return status.Error(codes.Internal, "peer header list size exceeded limit")
+        }
         for _, hf := range frame.Fields {
                 if err := d.processHeaderField(hf); err != nil {
                         return err
                 }
         }
 
+        if d.serverSide {
+                return nil
+        }
+
         // If grpc status exists, no need to check further.
         if d.rawStatusCode != nil || d.statusGen != nil {
                 return nil
@@ -212,7 +262,7 @@ func (d *decodeState) decodeResponseHeader(frame *http2.MetaHeadersFrame) error
         // If grpc status doesn't exist and http status doesn't exist,
         // then it's a malformed header.
         if d.httpStatus == nil {
-                return streamErrorf(codes.Internal, "malformed header: doesn't contain status(gRPC or HTTP)")
+                return status.Error(codes.Internal, "malformed header: doesn't contain status(gRPC or HTTP)")
         }
 
         if *(d.httpStatus) != http.StatusOK {
@@ -220,33 +270,46 @@ func (d *decodeState) decodeResponseHeader(frame *http2.MetaHeadersFrame) error
                 if !ok {
                         code = codes.Unknown
                 }
-                return streamErrorf(code, http.StatusText(*(d.httpStatus)))
+                return status.Error(code, http.StatusText(*(d.httpStatus)))
         }
 
         // gRPC status doesn't exist and http status is OK.
         // Set rawStatusCode to be unknown and return nil error.
         // So that, if the stream has ended this Unknown status
-        // will be propogated to the user.
+        // will be propagated to the user.
         // Otherwise, it will be ignored. In which case, status from
-        // a later trailer, that has StreamEnded flag set, is propogated.
+        // a later trailer, that has StreamEnded flag set, is propagated.
         code := int(codes.Unknown)
         d.rawStatusCode = &code
         return nil
+}
 
+func (d *decodeState) addMetadata(k, v string) {
+        if d.mdata == nil {
+                d.mdata = make(map[string][]string)
+        }
+        d.mdata[k] = append(d.mdata[k], v)
 }
 
 func (d *decodeState) processHeaderField(f hpack.HeaderField) error {
         switch f.Name {
         case "content-type":
-                if !validContentType(f.Value) {
-                        return streamErrorf(codes.FailedPrecondition, "transport: received the unexpected content-type %q", f.Value)
+                contentSubtype, validContentType := contentSubtype(f.Value)
+                if !validContentType {
+                        return status.Errorf(codes.Internal, "transport: received the unexpected content-type %q", f.Value)
                 }
+                d.contentSubtype = contentSubtype
+                // TODO: do we want to propagate the whole content-type in the metadata,
+                // or come up with a way to just propagate the content-subtype if it was set?
+                // ie {"content-type": "application/grpc+proto"} or {"content-subtype": "proto"}
+                // in the metadata?
+                d.addMetadata(f.Name, f.Value)
         case "grpc-encoding":
                 d.encoding = f.Value
         case "grpc-status":
                 code, err := strconv.Atoi(f.Value)
                 if err != nil {
-                        return streamErrorf(codes.Internal, "transport: malformed grpc-status: %v", err)
+                        return status.Errorf(codes.Internal, "transport: malformed grpc-status: %v", err)
                 }
                 d.rawStatusCode = &code
         case "grpc-message":
@@ -254,39 +317,51 @@ func (d *decodeState) processHeaderField(f hpack.HeaderField) error {
         case "grpc-status-details-bin":
                 v, err := decodeBinHeader(f.Value)
                 if err != nil {
-                        return streamErrorf(codes.Internal, "transport: malformed grpc-status-details-bin: %v", err)
+                        return status.Errorf(codes.Internal, "transport: malformed grpc-status-details-bin: %v", err)
                 }
                 s := &spb.Status{}
                 if err := proto.Unmarshal(v, s); err != nil {
-                        return streamErrorf(codes.Internal, "transport: malformed grpc-status-details-bin: %v", err)
+                        return status.Errorf(codes.Internal, "transport: malformed grpc-status-details-bin: %v", err)
                 }
                 d.statusGen = status.FromProto(s)
         case "grpc-timeout":
                 d.timeoutSet = true
                 var err error
                 if d.timeout, err = decodeTimeout(f.Value); err != nil {
-                        return streamErrorf(codes.Internal, "transport: malformed time-out: %v", err)
+                        return status.Errorf(codes.Internal, "transport: malformed time-out: %v", err)
                 }
         case ":path":
                 d.method = f.Value
         case ":status":
                 code, err := strconv.Atoi(f.Value)
                 if err != nil {
-                        return streamErrorf(codes.Internal, "transport: malformed http-status: %v", err)
+                        return status.Errorf(codes.Internal, "transport: malformed http-status: %v", err)
                 }
                 d.httpStatus = &code
+        case "grpc-tags-bin":
+                v, err := decodeBinHeader(f.Value)
+                if err != nil {
+                        return status.Errorf(codes.Internal, "transport: malformed grpc-tags-bin: %v", err)
+                }
+                d.statsTags = v
+                d.addMetadata(f.Name, string(v))
+        case "grpc-trace-bin":
+                v, err := decodeBinHeader(f.Value)
+                if err != nil {
+                        return status.Errorf(codes.Internal, "transport: malformed grpc-trace-bin: %v", err)
+                }
+                d.statsTrace = v
+                d.addMetadata(f.Name, string(v))
         default:
-                if !isReservedHeader(f.Name) || isWhitelistedPseudoHeader(f.Name) {
-                        if d.mdata == nil {
-                                d.mdata = make(map[string][]string)
-                        }
-                        v, err := decodeMetadataHeader(f.Name, f.Value)
-                        if err != nil {
-                                errorf("Failed to decode metadata header (%q, %q): %v", f.Name, f.Value, err)
-                                return nil
-                        }
-                        d.mdata[f.Name] = append(d.mdata[f.Name], v)
+                if isReservedHeader(f.Name) && !isWhitelistedHeader(f.Name) {
+                        break
+                }
+                v, err := decodeMetadataHeader(f.Name, f.Value)
+                if err != nil {
+                        errorf("Failed to decode metadata header (%q, %q): %v", f.Name, f.Value, err)
+                        return nil
                 }
+                d.addMetadata(f.Name, v)
         }
         return nil
 }
@@ -361,6 +436,10 @@ func decodeTimeout(s string) (time.Duration, error) {
         if size < 2 {
                 return 0, fmt.Errorf("transport: timeout string is too short: %q", s)
         }
+        if size > 9 {
+                // Spec allows for 8 digits plus the unit.
+                return 0, fmt.Errorf("transport: timeout string is too long: %q", s)
+        }
         unit := timeoutUnit(s[size-1])
         d, ok := timeoutUnitToDuration(unit)
         if !ok {
@@ -370,21 +449,27 @@ func decodeTimeout(s string) (time.Duration, error) {
         if err != nil {
                 return 0, err
         }
+        const maxHours = math.MaxInt64 / int64(time.Hour)
+        if d == time.Hour && t > maxHours {
+                // This timeout would overflow math.MaxInt64; clamp it.
+                return time.Duration(math.MaxInt64), nil
+        }
         return d * time.Duration(t), nil
 }
 
 const (
         spaceByte   = ' '
-        tildaByte   = '~'
+        tildeByte   = '~'
         percentByte = '%'
 )
 
 // encodeGrpcMessage is used to encode status code in header field
-// "grpc-message".
-// It checks to see if each individual byte in msg is an
-// allowable byte, and then either percent encoding or passing it through.
-// When percent encoding, the byte is converted into hexadecimal notation
-// with a '%' prepended.
+// "grpc-message". It does percent encoding and also replaces invalid utf-8
+// characters with Unicode replacement character.
+//
+// It checks to see if each individual byte in msg is an allowable byte, and
+// then either percent encoding or passing it through. When percent encoding,
+// the byte is converted into hexadecimal notation with a '%' prepended.
 func encodeGrpcMessage(msg string) string {
         if msg == "" {
                 return ""
@@ -392,7 +477,7 @@ func encodeGrpcMessage(msg string) string {
         lenMsg := len(msg)
         for i := 0; i < lenMsg; i++ {
                 c := msg[i]
-                if !(c >= spaceByte && c < tildaByte && c != percentByte) {
+                if !(c >= spaceByte && c <= tildeByte && c != percentByte) {
                         return encodeGrpcMessageUnchecked(msg)
                 }
         }
@@ -401,14 +486,26 @@ func encodeGrpcMessage(msg string) string {
 
 func encodeGrpcMessageUnchecked(msg string) string {
         var buf bytes.Buffer
-        lenMsg := len(msg)
-        for i := 0; i < lenMsg; i++ {
-                c := msg[i]
-                if c >= spaceByte && c < tildaByte && c != percentByte {
-                        buf.WriteByte(c)
-                } else {
-                        buf.WriteString(fmt.Sprintf("%%%02X", c))
+        for len(msg) > 0 {
+                r, size := utf8.DecodeRuneInString(msg)
+                for _, b := range []byte(string(r)) {
+                        if size > 1 {
+                                // If size > 1, r is not ascii. Always do percent encoding.
+                                buf.WriteString(fmt.Sprintf("%%%02X", b))
+                                continue
+                        }
+
+                        // The for loop is necessary even if size == 1. r could be
+                        // utf8.RuneError.
+                        //
+                        // fmt.Sprintf("%%%02X", utf8.RuneError) gives "%FFFD".
+                        if b >= spaceByte && b <= tildeByte && b != percentByte {
+                                buf.WriteByte(b)
+                        } else {
+                                buf.WriteString(fmt.Sprintf("%%%02X", b))
+                        }
                 }
+                msg = msg[size:]
         }
         return buf.String()
 }
@@ -447,151 +544,80 @@ func decodeGrpcMessageUnchecked(msg string) string {
         return buf.String()
 }
 
-type framer struct {
-        numWriters int32
-        reader     io.Reader
-        writer     *bufio.Writer
-        fr         *http2.Framer
-}
-
-func newFramer(conn net.Conn) *framer {
-        f := &framer{
-                reader: bufio.NewReaderSize(conn, http2IOBufSize),
-                writer: bufio.NewWriterSize(conn, http2IOBufSize),
-        }
-        f.fr = http2.NewFramer(f.writer, f.reader)
-        // Opt-in to Frame reuse API on framer to reduce garbage.
-        // Frames aren't safe to read from after a subsequent call to ReadFrame.
-        f.fr.SetReuseFrames()
-        f.fr.ReadMetaHeaders = hpack.NewDecoder(http2InitHeaderTableSize, nil)
-        return f
-}
+type bufWriter struct {
+        buf       []byte
+        offset    int
+        batchSize int
+        conn      net.Conn
+        err       error
 
-func (f *framer) adjustNumWriters(i int32) int32 {
-        return atomic.AddInt32(&f.numWriters, i)
+        onFlush func()
 }
 
-// The following writeXXX functions can only be called when the caller gets
-// unblocked from writableChan channel (i.e., owns the privilege to write).
-
-func (f *framer) writeContinuation(forceFlush bool, streamID uint32, endHeaders bool, headerBlockFragment []byte) error {
-        if err := f.fr.WriteContinuation(streamID, endHeaders, headerBlockFragment); err != nil {
-                return err
+func newBufWriter(conn net.Conn, batchSize int) *bufWriter {
+        return &bufWriter{
+                buf:       make([]byte, batchSize*2),
+                batchSize: batchSize,
+                conn:      conn,
         }
-        if forceFlush {
-                return f.writer.Flush()
-        }
-        return nil
 }
 
-func (f *framer) writeData(forceFlush bool, streamID uint32, endStream bool, data []byte) error {
-        if err := f.fr.WriteData(streamID, endStream, data); err != nil {
-                return err
+func (w *bufWriter) Write(b []byte) (n int, err error) {
+        if w.err != nil {
+                return 0, w.err
         }
-        if forceFlush {
-                return f.writer.Flush()
+        if w.batchSize == 0 { // Buffer has been disabled.
+                return w.conn.Write(b)
         }
-        return nil
-}
-
-func (f *framer) writeGoAway(forceFlush bool, maxStreamID uint32, code http2.ErrCode, debugData []byte) error {
-        if err := f.fr.WriteGoAway(maxStreamID, code, debugData); err != nil {
-                return err
-        }
-        if forceFlush {
-                return f.writer.Flush()
-        }
-        return nil
-}
-
-func (f *framer) writeHeaders(forceFlush bool, p http2.HeadersFrameParam) error {
-        if err := f.fr.WriteHeaders(p); err != nil {
-                return err
-        }
-        if forceFlush {
-                return f.writer.Flush()
-        }
-        return nil
-}
-
-func (f *framer) writePing(forceFlush, ack bool, data [8]byte) error {
-        if err := f.fr.WritePing(ack, data); err != nil {
-                return err
-        }
-        if forceFlush {
-                return f.writer.Flush()
-        }
-        return nil
-}
-
-func (f *framer) writePriority(forceFlush bool, streamID uint32, p http2.PriorityParam) error {
-        if err := f.fr.WritePriority(streamID, p); err != nil {
-                return err
-        }
-        if forceFlush {
-                return f.writer.Flush()
+        for len(b) > 0 {
+                nn := copy(w.buf[w.offset:], b)
+                b = b[nn:]
+                w.offset += nn
+                n += nn
+                if w.offset >= w.batchSize {
+                        err = w.Flush()
+                }
         }
-        return nil
+        return n, err
 }
 
-func (f *framer) writePushPromise(forceFlush bool, p http2.PushPromiseParam) error {
-        if err := f.fr.WritePushPromise(p); err != nil {
-                return err
-        }
-        if forceFlush {
-                return f.writer.Flush()
+func (w *bufWriter) Flush() error {
+        if w.err != nil {
+                return w.err
         }
-        return nil
-}
-
-func (f *framer) writeRSTStream(forceFlush bool, streamID uint32, code http2.ErrCode) error {
-        if err := f.fr.WriteRSTStream(streamID, code); err != nil {
-                return err
+        if w.offset == 0 {
+                return nil
         }
-        if forceFlush {
-                return f.writer.Flush()
+        if w.onFlush != nil {
+                w.onFlush()
         }
-        return nil
+        _, w.err = w.conn.Write(w.buf[:w.offset])
+        w.offset = 0
+        return w.err
 }
 
-func (f *framer) writeSettings(forceFlush bool, settings ...http2.Setting) error {
-        if err := f.fr.WriteSettings(settings...); err != nil {
-                return err
-        }
-        if forceFlush {
-                return f.writer.Flush()
-        }
-        return nil
+type framer struct {
+        writer *bufWriter
+        fr     *http2.Framer
 }
 
-func (f *framer) writeSettingsAck(forceFlush bool) error {
-        if err := f.fr.WriteSettingsAck(); err != nil {
-                return err
+func newFramer(conn net.Conn, writeBufferSize, readBufferSize int, maxHeaderListSize uint32) *framer {
+        if writeBufferSize < 0 {
+                writeBufferSize = 0
         }
-        if forceFlush {
-                return f.writer.Flush()
+        var r io.Reader = conn
+        if readBufferSize > 0 {
+                r = bufio.NewReaderSize(r, readBufferSize)
         }
-        return nil
-}
-
-func (f *framer) writeWindowUpdate(forceFlush bool, streamID, incr uint32) error {
-        if err := f.fr.WriteWindowUpdate(streamID, incr); err != nil {
-                return err
-        }
-        if forceFlush {
-                return f.writer.Flush()
+        w := newBufWriter(conn, writeBufferSize)
+        f := &framer{
+                writer: w,
+                fr:     http2.NewFramer(w, r),
         }
-        return nil
-}
-
-func (f *framer) flushWrite() error {
-        return f.writer.Flush()
-}
-
-func (f *framer) readFrame() (http2.Frame, error) {
-        return f.fr.ReadFrame()
-}
-
-func (f *framer) errorDetail() error {
-        return f.fr.ErrorDetail()
+        // Opt-in to Frame reuse API on framer to reduce garbage.
+        // Frames aren't safe to read from after a subsequent call to ReadFrame.
+        f.fr.SetReuseFrames()
+        f.fr.MaxHeaderListSize = maxHeaderListSize
+        f.fr.ReadMetaHeaders = hpack.NewDecoder(http2InitHeaderTableSize, nil)
+        return f
 }
diff --git a/vendor/google.golang.org/grpc/transport/log.go b/vendor/google.golang.org/grpc/internal/transport/log.go
index ac8e358..879df80 100644
--- a/vendor/google.golang.org/grpc/transport/log.go
+++ b/vendor/google.golang.org/grpc/internal/transport/log.go
@@ -42,9 +42,3 @@ func errorf(format string, args ...interface{}) {
                 grpclog.Errorf(format, args...)
         }
 }
-
-func fatalf(format string, args ...interface{}) {
-        if grpclog.V(logLevel) {
-                grpclog.Fatalf(format, args...)
-        }
-}
diff --git a/vendor/google.golang.org/grpc/transport/transport.go b/vendor/google.golang.org/grpc/internal/transport/transport.go
index ec0fe67..2580aa7 100644
--- a/vendor/google.golang.org/grpc/transport/transport.go
+++ b/vendor/google.golang.org/grpc/internal/transport/transport.go
@@ -17,17 +17,19 @@
  */
 
 // Package transport defines and implements message oriented communication
-// channel to complete various transactions (e.g., an RPC).
-package transport // import "google.golang.org/grpc/transport"
+// channel to complete various transactions (e.g., an RPC).  It is meant for
+// grpc-internal usage and is not intended to be imported directly by users.
+package transport
 
 import (
+        "context"
+        "errors"
         "fmt"
         "io"
         "net"
         "sync"
+        "sync/atomic"
 
-        "golang.org/x/net/context"
-        "golang.org/x/net/http2"
         "google.golang.org/grpc/codes"
         "google.golang.org/grpc/credentials"
         "google.golang.org/grpc/keepalive"
@@ -56,6 +58,7 @@ type recvBuffer struct {
         c       chan recvMsg
         mu      sync.Mutex
         backlog []recvMsg
+        err     error
 }
 
 func newRecvBuffer() *recvBuffer {
@@ -67,20 +70,27 @@ func newRecvBuffer() *recvBuffer {
 
 func (b *recvBuffer) put(r recvMsg) {
         b.mu.Lock()
-        defer b.mu.Unlock()
+        if b.err != nil {
+                b.mu.Unlock()
+                // An error had occurred earlier, don't accept more
+                // data or errors.
+                return
+        }
+        b.err = r.err
         if len(b.backlog) == 0 {
                 select {
                 case b.c <- r:
+                        b.mu.Unlock()
                         return
                 default:
                 }
         }
         b.backlog = append(b.backlog, r)
+        b.mu.Unlock()
 }
 
 func (b *recvBuffer) load() {
         b.mu.Lock()
-        defer b.mu.Unlock()
         if len(b.backlog) > 0 {
                 select {
                 case b.c <- b.backlog[0]:
@@ -89,6 +99,7 @@ func (b *recvBuffer) load() {
                 default:
                 }
         }
+        b.mu.Unlock()
 }
 
 // get returns the channel that receives a recvMsg in the buffer.
@@ -102,11 +113,12 @@ func (b *recvBuffer) get() <-chan recvMsg {
 // recvBufferReader implements io.Reader interface to read the data from
 // recvBuffer.
 type recvBufferReader struct {
-        ctx    context.Context
-        goAway chan struct{}
-        recv   *recvBuffer
-        last   []byte // Stores the remaining data in the previous calls.
-        err    error
+        closeStream func(error) // Closes the client transport stream with the given error and nil trailer metadata.
+        ctx         context.Context
+        ctxDone     <-chan struct{} // cache of ctx.Done() (for performance).
+        recv        *recvBuffer
+        last        []byte // Stores the remaining data in the previous calls.
+        err         error
 }
 
 // Read reads the next len(p) bytes from last. If last is drained, it tries to
@@ -116,87 +128,54 @@ func (r *recvBufferReader) Read(p []byte) (n int, err error) {
         if r.err != nil {
                 return 0, r.err
         }
-        n, r.err = r.read(p)
-        return n, r.err
-}
-
-func (r *recvBufferReader) read(p []byte) (n int, err error) {
         if r.last != nil && len(r.last) > 0 {
                 // Read remaining data left in last call.
                 copied := copy(p, r.last)
                 r.last = r.last[copied:]
                 return copied, nil
         }
+        if r.closeStream != nil {
+                n, r.err = r.readClient(p)
+        } else {
+                n, r.err = r.read(p)
+        }
+        return n, r.err
+}
+
+func (r *recvBufferReader) read(p []byte) (n int, err error) {
         select {
-        case <-r.ctx.Done():
+        case <-r.ctxDone:
                 return 0, ContextErr(r.ctx.Err())
-        case <-r.goAway:
-                return 0, ErrStreamDrain
         case m := <-r.recv.get():
-                r.recv.load()
-                if m.err != nil {
-                        return 0, m.err
-                }
-                copied := copy(p, m.data)
-                r.last = m.data[copied:]
-                return copied, nil
+                return r.readAdditional(m, p)
         }
 }
 
-// All items in an out of a controlBuffer should be the same type.
-type item interface {
-        item()
-}
-
-// controlBuffer is an unbounded channel of item.
-type controlBuffer struct {
-        c       chan item
-        mu      sync.Mutex
-        backlog []item
-}
-
-func newControlBuffer() *controlBuffer {
-        b := &controlBuffer{
-                c: make(chan item, 1),
+func (r *recvBufferReader) readClient(p []byte) (n int, err error) {
+        // If the context is canceled, then closes the stream with nil metadata.
+        // closeStream writes its error parameter to r.recv as a recvMsg.
+        // r.readAdditional acts on that message and returns the necessary error.
+        select {
+        case <-r.ctxDone:
+                r.closeStream(ContextErr(r.ctx.Err()))
+                m := <-r.recv.get()
+                return r.readAdditional(m, p)
+        case m := <-r.recv.get():
+                return r.readAdditional(m, p)
         }
-        return b
 }
 
-func (b *controlBuffer) put(r item) {
-        b.mu.Lock()
-        defer b.mu.Unlock()
-        if len(b.backlog) == 0 {
-                select {
-                case b.c <- r:
-                        return
-                default:
-                }
+func (r *recvBufferReader) readAdditional(m recvMsg, p []byte) (n int, err error) {
+        r.recv.load()
+        if m.err != nil {
+                return 0, m.err
         }
-        b.backlog = append(b.backlog, r)
+        copied := copy(p, m.data)
+        r.last = m.data[copied:]
+        return copied, nil
 }
 
-func (b *controlBuffer) load() {
-        b.mu.Lock()
-        defer b.mu.Unlock()
-        if len(b.backlog) > 0 {
-                select {
-                case b.c <- b.backlog[0]:
-                        b.backlog[0] = nil
-                        b.backlog = b.backlog[1:]
-                default:
-                }
-        }
-}
-
-// get returns the channel that receives an item in the buffer.
-//
-// Upon receipt of an item, the caller should call load to send another
-// item onto the channel if there is any.
-func (b *controlBuffer) get() <-chan item {
-        return b.c
-}
-
-type streamState uint8
+type streamState uint32
 
 const (
         streamActive    streamState = iota
@@ -207,65 +186,98 @@ const (
 
 // Stream represents an RPC in the transport layer.
 type Stream struct {
-        id uint32
-        // nil for client side Stream.
-        st ServerTransport
-        // ctx is the associated context of the stream.
-        ctx context.Context
-        // cancel is always nil for client side Stream.
-        cancel context.CancelFunc
-        // done is closed when the final status arrives.
-        done chan struct{}
-        // goAway is closed when the server sent GoAways signal before this stream was initiated.
-        goAway chan struct{}
-        // method records the associated RPC method of the stream.
-        method       string
+        id           uint32
+        st           ServerTransport    // nil for client side Stream
+        ctx          context.Context    // the associated context of the stream
+        cancel       context.CancelFunc // always nil for client side Stream
+        done         chan struct{}      // closed at the end of stream to unblock writers. On the client side.
+        ctxDone      <-chan struct{}    // same as done chan but for server side. Cache of ctx.Done() (for performance)
+        method       string             // the associated RPC method of the stream
         recvCompress string
         sendCompress string
         buf          *recvBuffer
         trReader     io.Reader
         fc           *inFlow
-        recvQuota    uint32
-
-        // TODO: Remote this unused variable.
-        // The accumulated inbound quota pending for window update.
-        updateQuota uint32
+        wq           *writeQuota
 
         // Callback to state application's intentions to read data. This
-        // is used to adjust flow control, if need be.
+        // is used to adjust flow control, if needed.
         requestRead func(int)
 
-        sendQuotaPool *quotaPool
-        // Close headerChan to indicate the end of reception of header metadata.
-        headerChan chan struct{}
-        // header caches the received header metadata.
-        header metadata.MD
-        // The key-value map of trailer metadata.
-        trailer metadata.MD
-
-        mu sync.RWMutex // guard the following
-        // headerOK becomes true from the first header is about to send.
-        headerOk bool
-        state    streamState
-        // true iff headerChan is closed. Used to avoid closing headerChan
-        // multiple times.
-        headerDone bool
-        // the status error received from the server.
+        headerChan chan struct{} // closed to indicate the end of header metadata.
+        headerDone uint32        // set when headerChan is closed. Used to avoid closing headerChan multiple times.
+
+        // hdrMu protects header and trailer metadata on the server-side.
+        hdrMu sync.Mutex
+        // On client side, header keeps the received header metadata.
+        //
+        // On server side, header keeps the header set by SetHeader(). The complete
+        // header will merged into this after t.WriteHeader() is called.
+        header  metadata.MD
+        trailer metadata.MD // the key-value map of trailer metadata.
+
+        noHeaders bool // set if the client never received headers (set only after the stream is done).
+
+        // On the server-side, headerSent is atomically set to 1 when the headers are sent out.
+        headerSent uint32
+
+        state streamState
+
+        // On client-side it is the status error received from the server.
+        // On server-side it is unused.
         status *status.Status
-        // rstStream indicates whether a RST_STREAM frame needs to be sent
-        // to the server to signify that this stream is closing.
-        rstStream bool
-        // rstError is the error that needs to be sent along with the RST_STREAM frame.
-        rstError http2.ErrCode
-        // bytesSent and bytesReceived indicates whether any bytes have been sent or
-        // received on this stream.
-        bytesSent     bool
-        bytesReceived bool
+
+        bytesReceived uint32 // indicates whether any bytes have been received on this stream
+        unprocessed   uint32 // set if the server sends a refused stream or GOAWAY including this stream
+
+        // contentSubtype is the content-subtype for requests.
+        // this must be lowercase or the behavior is undefined.
+        contentSubtype string
+}
+
+// isHeaderSent is only valid on the server-side.
+func (s *Stream) isHeaderSent() bool {
+        return atomic.LoadUint32(&s.headerSent) == 1
+}
+
+// updateHeaderSent updates headerSent and returns true
+// if it was alreay set. It is valid only on server-side.
+func (s *Stream) updateHeaderSent() bool {
+        return atomic.SwapUint32(&s.headerSent, 1) == 1
+}
+
+func (s *Stream) swapState(st streamState) streamState {
+        return streamState(atomic.SwapUint32((*uint32)(&s.state), uint32(st)))
+}
+
+func (s *Stream) compareAndSwapState(oldState, newState streamState) bool {
+        return atomic.CompareAndSwapUint32((*uint32)(&s.state), uint32(oldState), uint32(newState))
+}
+
+func (s *Stream) getState() streamState {
+        return streamState(atomic.LoadUint32((*uint32)(&s.state)))
+}
+
+func (s *Stream) waitOnHeader() error {
+        if s.headerChan == nil {
+                // On the server headerChan is always nil since a stream originates
+                // only after having received headers.
+                return nil
+        }
+        select {
+        case <-s.ctx.Done():
+                return ContextErr(s.ctx.Err())
+        case <-s.headerChan:
+                return nil
+        }
 }
 
 // RecvCompress returns the compression algorithm applied to the inbound
 // message. It is empty string if there is no compression applied.
 func (s *Stream) RecvCompress() string {
+        if err := s.waitOnHeader(); err != nil {
+                return ""
+        }
         return s.recvCompress
 }
 
@@ -274,53 +286,68 @@ func (s *Stream) SetSendCompress(str string) {
         s.sendCompress = str
 }
 
-// Done returns a chanel which is closed when it receives the final status
+// Done returns a channel which is closed when it receives the final status
 // from the server.
 func (s *Stream) Done() <-chan struct{} {
         return s.done
 }
 
-// GoAway returns a channel which is closed when the server sent GoAways signal
-// before this stream was initiated.
-func (s *Stream) GoAway() <-chan struct{} {
-        return s.goAway
-}
-
-// Header acquires the key-value pairs of header metadata once it
-// is available. It blocks until i) the metadata is ready or ii) there is no
-// header metadata or iii) the stream is canceled/expired.
+// Header returns the header metadata of the stream.
+//
+// On client side, it acquires the key-value pairs of header metadata once it is
+// available. It blocks until i) the metadata is ready or ii) there is no header
+// metadata or iii) the stream is canceled/expired.
+//
+// On server side, it returns the out header after t.WriteHeader is called.
 func (s *Stream) Header() (metadata.MD, error) {
-        var err error
-        select {
-        case <-s.ctx.Done():
-                err = ContextErr(s.ctx.Err())
-        case <-s.goAway:
-                err = ErrStreamDrain
-        case <-s.headerChan:
+        if s.headerChan == nil && s.header != nil {
+                // On server side, return the header in stream. It will be the out
+                // header after t.WriteHeader is called.
                 return s.header.Copy(), nil
         }
+        err := s.waitOnHeader()
         // Even if the stream is closed, header is returned if available.
         select {
         case <-s.headerChan:
+                if s.header == nil {
+                        return nil, nil
+                }
                 return s.header.Copy(), nil
         default:
         }
         return nil, err
 }
 
+// TrailersOnly blocks until a header or trailers-only frame is received and
+// then returns true if the stream was trailers-only.  If the stream ends
+// before headers are received, returns true, nil.  If a context error happens
+// first, returns it as a status error.  Client-side only.
+func (s *Stream) TrailersOnly() (bool, error) {
+        err := s.waitOnHeader()
+        if err != nil {
+                return false, err
+        }
+        // if !headerDone, some other connection error occurred.
+        return s.noHeaders && atomic.LoadUint32(&s.headerDone) == 1, nil
+}
+
 // Trailer returns the cached trailer metedata. Note that if it is not called
 // after the entire stream is done, it could return an empty MD. Client
 // side only.
+// It can be safely read only after stream has ended that is either read
+// or write have returned io.EOF.
 func (s *Stream) Trailer() metadata.MD {
-        s.mu.RLock()
-        defer s.mu.RUnlock()
-        return s.trailer.Copy()
+        c := s.trailer.Copy()
+        return c
 }
 
-// ServerTransport returns the underlying ServerTransport for the stream.
-// The client side stream always returns nil.
-func (s *Stream) ServerTransport() ServerTransport {
-        return s.st
+// ContentSubtype returns the content-subtype for a request. For example, a
+// content-subtype of "proto" will result in a content-type of
+// "application/grpc+proto". This will always be lowercase.  See
+// https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#requests for
+// more details.
+func (s *Stream) ContentSubtype() string {
+        return s.contentSubtype
 }
 
 // Context returns the context of the stream.
@@ -334,34 +361,48 @@ func (s *Stream) Method() string {
 }
 
 // Status returns the status received from the server.
+// Status can be read safely only after the stream has ended,
+// that is, after Done() is closed.
 func (s *Stream) Status() *status.Status {
         return s.status
 }
 
 // SetHeader sets the header metadata. This can be called multiple times.
 // Server side only.
+// This should not be called in parallel to other data writes.
 func (s *Stream) SetHeader(md metadata.MD) error {
-        s.mu.Lock()
-        defer s.mu.Unlock()
-        if s.headerOk || s.state == streamDone {
-                return ErrIllegalHeaderWrite
-        }
         if md.Len() == 0 {
                 return nil
         }
+        if s.isHeaderSent() || s.getState() == streamDone {
+                return ErrIllegalHeaderWrite
+        }
+        s.hdrMu.Lock()
         s.header = metadata.Join(s.header, md)
+        s.hdrMu.Unlock()
         return nil
 }
 
+// SendHeader sends the given header metadata. The given metadata is
+// combined with any metadata set by previous calls to SetHeader and
+// then written to the transport stream.
+func (s *Stream) SendHeader(md metadata.MD) error {
+        return s.st.WriteHeader(s, md)
+}
+
 // SetTrailer sets the trailer metadata which will be sent with the RPC status
 // by the server. This can be called multiple times. Server side only.
+// This should not be called parallel to other data writes.
 func (s *Stream) SetTrailer(md metadata.MD) error {
         if md.Len() == 0 {
                 return nil
         }
-        s.mu.Lock()
-        defer s.mu.Unlock()
+        if s.getState() == streamDone {
+                return ErrIllegalHeaderWrite
+        }
+        s.hdrMu.Lock()
         s.trailer = metadata.Join(s.trailer, md)
+        s.hdrMu.Unlock()
         return nil
 }
 
@@ -401,26 +442,15 @@ func (t *transportReader) Read(p []byte) (n int, err error) {
         return
 }
 
-// finish sets the stream's state and status, and closes the done channel.
-// s.mu must be held by the caller.  st must always be non-nil.
-func (s *Stream) finish(st *status.Status) {
-        s.status = st
-        s.state = streamDone
-        close(s.done)
-}
-
-// BytesSent indicates whether any bytes have been sent on this stream.
-func (s *Stream) BytesSent() bool {
-        s.mu.Lock()
-        defer s.mu.Unlock()
-        return s.bytesSent
-}
-
 // BytesReceived indicates whether any bytes have been received on this stream.
 func (s *Stream) BytesReceived() bool {
-        s.mu.Lock()
-        defer s.mu.Unlock()
-        return s.bytesReceived
+        return atomic.LoadUint32(&s.bytesReceived) == 1
+}
+
+// Unprocessed indicates whether the server did not process this stream --
+// i.e. it sent a refused stream or GOAWAY including this stream ID.
+func (s *Stream) Unprocessed() bool {
+        return atomic.LoadUint32(&s.unprocessed) == 1
 }
 
 // GoString is implemented by Stream so context.String() won't
@@ -429,27 +459,11 @@ func (s *Stream) GoString() string {
         return fmt.Sprintf("<stream: %p, %v>", s, s.method)
 }
 
-// The key to save transport.Stream in the context.
-type streamKey struct{}
-
-// newContextWithStream creates a new context from ctx and attaches stream
-// to it.
-func newContextWithStream(ctx context.Context, stream *Stream) context.Context {
-        return context.WithValue(ctx, streamKey{}, stream)
-}
-
-// StreamFromContext returns the stream saved in ctx.
-func StreamFromContext(ctx context.Context) (s *Stream, ok bool) {
-        s, ok = ctx.Value(streamKey{}).(*Stream)
-        return
-}
-
 // state of transport
 type transportState int
 
 const (
         reachable transportState = iota
-        unreachable
         closing
         draining
 )
@@ -464,6 +478,10 @@ type ServerConfig struct {
         KeepalivePolicy       keepalive.EnforcementPolicy
         InitialWindowSize     int32
         InitialConnWindowSize int32
+        WriteBufferSize       int
+        ReadBufferSize        int
+        ChannelzParentID      int64
+        MaxHeaderListSize     *uint32
 }
 
 // NewServerTransport creates a ServerTransport with conn or non-nil error
@@ -476,37 +494,47 @@ func NewServerTransport(protocol string, conn net.Conn, config *ServerConfig) (S
 type ConnectOptions struct {
         // UserAgent is the application user agent.
         UserAgent string
-        // Authority is the :authority pseudo-header to use. This field has no effect if
-        // TransportCredentials is set.
-        Authority string
         // Dialer specifies how to dial a network address.
         Dialer func(context.Context, string) (net.Conn, error)
         // FailOnNonTempDialError specifies if gRPC fails on non-temporary dial errors.
         FailOnNonTempDialError bool
         // PerRPCCredentials stores the PerRPCCredentials required to issue RPCs.
         PerRPCCredentials []credentials.PerRPCCredentials
-        // TransportCredentials stores the Authenticator required to setup a client connection.
+        // TransportCredentials stores the Authenticator required to setup a client
+        // connection. Only one of TransportCredentials and CredsBundle is non-nil.
         TransportCredentials credentials.TransportCredentials
+        // CredsBundle is the credentials bundle to be used. Only one of
+        // TransportCredentials and CredsBundle is non-nil.
+        CredsBundle credentials.Bundle
         // KeepaliveParams stores the keepalive parameters.
         KeepaliveParams keepalive.ClientParameters
         // StatsHandler stores the handler for stats.
         StatsHandler stats.Handler
-        // InitialWindowSize sets the intial window size for a stream.
+        // InitialWindowSize sets the initial window size for a stream.
         InitialWindowSize int32
-        // InitialConnWindowSize sets the intial window size for a connection.
+        // InitialConnWindowSize sets the initial window size for a connection.
         InitialConnWindowSize int32
+        // WriteBufferSize sets the size of write buffer which in turn determines how much data can be batched before it's written on the wire.
+        WriteBufferSize int
+        // ReadBufferSize sets the size of read buffer, which in turn determines how much data can be read at most for one read syscall.
+        ReadBufferSize int
+        // ChannelzParentID sets the addrConn id which initiate the creation of this client transport.
+        ChannelzParentID int64
+        // MaxHeaderListSize sets the max (uncompressed) size of header list that is prepared to be received.
+        MaxHeaderListSize *uint32
 }
 
 // TargetInfo contains the information of the target such as network address and metadata.
 type TargetInfo struct {
-        Addr     string
-        Metadata interface{}
+        Addr      string
+        Metadata  interface{}
+        Authority string
 }
 
 // NewClientTransport establishes the transport with the required ConnectOptions
 // and returns it to the caller.
-func NewClientTransport(ctx context.Context, target TargetInfo, opts ConnectOptions) (ClientTransport, error) {
-        return newHTTP2Client(ctx, target, opts)
+func NewClientTransport(connectCtx, ctx context.Context, target TargetInfo, opts ConnectOptions, onPrefaceReceipt func(), onGoAway func(GoAwayReason), onClose func()) (ClientTransport, error) {
+        return newHTTP2Client(connectCtx, ctx, target, opts, onPrefaceReceipt, onGoAway, onClose)
 }
 
 // Options provides additional hints and information for message
@@ -515,11 +543,6 @@ type Options struct {
         // Last indicates whether this write is the last piece for
         // this stream.
         Last bool
-
-        // Delay is a hint to the transport implementation for whether
-        // the data could be buffered for a batching write. The
-        // Transport implementation may ignore the hint.
-        Delay bool
 }
 
 // CallHdr carries the information of a particular RPC.
@@ -530,10 +553,6 @@ type CallHdr struct {
         // Method specifies the operation to perform.
         Method string
 
-        // RecvCompress specifies the compression algorithm applied on
-        // inbound messages.
-        RecvCompress string
-
         // SendCompress specifies the compression algorithm applied on
         // outbound message.
         SendCompress string
@@ -541,13 +560,15 @@ type CallHdr struct {
         // Creds specifies credentials.PerRPCCredentials for a call.
         Creds credentials.PerRPCCredentials
 
-        // Flush indicates whether a new stream command should be sent
-        // to the peer without waiting for the first data. This is
-        // only a hint.
-        // If it's true, the transport may modify the flush decision
-        // for performance purposes.
-        // If it's false, new stream will never be flushed.
-        Flush bool
+        // ContentSubtype specifies the content-subtype for a request. For example, a
+        // content-subtype of "proto" will result in a content-type of
+        // "application/grpc+proto". The value of ContentSubtype must be all
+        // lowercase, otherwise the behavior is undefined. See
+        // https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#requests
+        // for more details.
+        ContentSubtype string
+
+        PreviousAttempts int // value of grpc-previous-rpc-attempts header to set
 }
 
 // ClientTransport is the common interface for all gRPC client-side transport
@@ -564,7 +585,7 @@ type ClientTransport interface {
 
         // Write sends the data for the given stream. A nil stream indicates
         // the write is to be performed on the transport as a whole.
-        Write(s *Stream, data []byte, opts *Options) error
+        Write(s *Stream, hdr []byte, data []byte, opts *Options) error
 
         // NewStream creates a Stream for an RPC.
         NewStream(ctx context.Context, callHdr *CallHdr) (*Stream, error)
@@ -589,6 +610,12 @@ type ClientTransport interface {
 
         // GetGoAwayReason returns the reason why GoAway frame was received.
         GetGoAwayReason() GoAwayReason
+
+        // IncrMsgSent increments the number of message sent through this transport.
+        IncrMsgSent()
+
+        // IncrMsgRecv increments the number of message received through this transport.
+        IncrMsgRecv()
 }
 
 // ServerTransport is the common interface for all gRPC server-side transport
@@ -606,7 +633,7 @@ type ServerTransport interface {
 
         // Write sends the data for the given stream.
         // Write may not be called on all streams.
-        Write(s *Stream, data []byte, opts *Options) error
+        Write(s *Stream, hdr []byte, data []byte, opts *Options) error
 
         // WriteStatus sends the status of a stream to the client.  WriteStatus is
         // the final call made on a stream and always occurs.
@@ -622,14 +649,12 @@ type ServerTransport interface {
 
         // Drain notifies the client this ServerTransport stops accepting new RPCs.
         Drain()
-}
 
-// streamErrorf creates an StreamError with the specified error code and description.
-func streamErrorf(c codes.Code, format string, a ...interface{}) StreamError {
-        return StreamError{
-                Code: c,
-                Desc: fmt.Sprintf(format, a...),
-        }
+        // IncrMsgSent increments the number of message sent through this transport.
+        IncrMsgSent()
+
+        // IncrMsgRecv increments the number of message received through this transport.
+        IncrMsgRecv()
 }
 
 // connectionErrorf creates an ConnectionError with the specified error description.
@@ -671,60 +696,63 @@ func (e ConnectionError) Origin() error {
 var (
         // ErrConnClosing indicates that the transport is closing.
         ErrConnClosing = connectionErrorf(true, nil, "transport is closing")
-        // ErrStreamDrain indicates that the stream is rejected by the server because
-        // the server stops accepting new RPCs.
-        ErrStreamDrain = streamErrorf(codes.Unavailable, "the server stops accepting new RPCs")
+        // errStreamDrain indicates that the stream is rejected because the
+        // connection is draining. This could be caused by goaway or balancer
+        // removing the address.
+        errStreamDrain = status.Error(codes.Unavailable, "the connection is draining")
+        // errStreamDone is returned from write at the client side to indiacte application
+        // layer of an error.
+        errStreamDone = errors.New("the stream is done")
+        // StatusGoAway indicates that the server sent a GOAWAY that included this
+        // stream's ID in unprocessed RPCs.
+        statusGoAway = status.New(codes.Unavailable, "the stream is rejected because server is draining the connection")
 )
 
-// TODO: See if we can replace StreamError with status package errors.
-
-// StreamError is an error that only affects one stream within a connection.
-type StreamError struct {
-        Code codes.Code
-        Desc string
-}
-
-func (e StreamError) Error() string {
-        return fmt.Sprintf("stream error: code = %s desc = %q", e.Code, e.Desc)
-}
-
-// wait blocks until it can receive from ctx.Done, closing, or proceed.
-// If it receives from ctx.Done, it returns 0, the StreamError for ctx.Err.
-// If it receives from done, it returns 0, io.EOF if ctx is not done; otherwise
-// it return the StreamError for ctx.Err.
-// If it receives from goAway, it returns 0, ErrStreamDrain.
-// If it receives from closing, it returns 0, ErrConnClosing.
-// If it receives from proceed, it returns the received integer, nil.
-func wait(ctx context.Context, done, goAway, closing <-chan struct{}, proceed <-chan int) (int, error) {
-        select {
-        case <-ctx.Done():
-                return 0, ContextErr(ctx.Err())
-        case <-done:
-                // User cancellation has precedence.
-                select {
-                case <-ctx.Done():
-                        return 0, ContextErr(ctx.Err())
-                default:
-                }
-                return 0, io.EOF
-        case <-goAway:
-                return 0, ErrStreamDrain
-        case <-closing:
-                return 0, ErrConnClosing
-        case i := <-proceed:
-                return i, nil
-        }
-}
-
 // GoAwayReason contains the reason for the GoAway frame received.
 type GoAwayReason uint8
 
 const (
-        // Invalid indicates that no GoAway frame is received.
-        Invalid GoAwayReason = 0
-        // NoReason is the default value when GoAway frame is received.
-        NoReason GoAwayReason = 1
-        // TooManyPings indicates that a GoAway frame with ErrCodeEnhanceYourCalm
-        // was recieved and that the debug data said "too_many_pings".
-        TooManyPings GoAwayReason = 2
+        // GoAwayInvalid indicates that no GoAway frame is received.
+        GoAwayInvalid GoAwayReason = 0
+        // GoAwayNoReason is the default value when GoAway frame is received.
+        GoAwayNoReason GoAwayReason = 1
+        // GoAwayTooManyPings indicates that a GoAway frame with
+        // ErrCodeEnhanceYourCalm was received and that the debug data said
+        // "too_many_pings".
+        GoAwayTooManyPings GoAwayReason = 2
 )
+
+// channelzData is used to store channelz related data for http2Client and http2Server.
+// These fields cannot be embedded in the original structs (e.g. http2Client), since to do atomic
+// operation on int64 variable on 32-bit machine, user is responsible to enforce memory alignment.
+// Here, by grouping those int64 fields inside a struct, we are enforcing the alignment.
+type channelzData struct {
+        kpCount int64
+        // The number of streams that have started, including already finished ones.
+        streamsStarted int64
+        // Client side: The number of streams that have ended successfully by receiving
+        // EoS bit set frame from server.
+        // Server side: The number of streams that have ended successfully by sending
+        // frame with EoS bit set.
+        streamsSucceeded int64
+        streamsFailed    int64
+        // lastStreamCreatedTime stores the timestamp that the last stream gets created. It is of int64 type
+        // instead of time.Time since it's more costly to atomically update time.Time variable than int64
+        // variable. The same goes for lastMsgSentTime and lastMsgRecvTime.
+        lastStreamCreatedTime int64
+        msgSent               int64
+        msgRecv               int64
+        lastMsgSentTime       int64
+        lastMsgRecvTime       int64
+}
+
+// ContextErr converts the error from context package into a status error.
+func ContextErr(err error) error {
+        switch err {
+        case context.DeadlineExceeded:
+                return status.Error(codes.DeadlineExceeded, err.Error())
+        case context.Canceled:
+                return status.Error(codes.Canceled, err.Error())
+        }
+        return status.Errorf(codes.Internal, "Unexpected error from context packet: %v", err)
+}
diff --git a/vendor/google.golang.org/grpc/keepalive/keepalive.go b/vendor/google.golang.org/grpc/keepalive/keepalive.go
index f8adc7e..899e72d 100644
--- a/vendor/google.golang.org/grpc/keepalive/keepalive.go
+++ b/vendor/google.golang.org/grpc/keepalive/keepalive.go
@@ -16,7 +16,8 @@
  *
  */
 
-// Package keepalive defines configurable parameters for point-to-point healthcheck.
+// Package keepalive defines configurable parameters for point-to-point
+// healthcheck.
 package keepalive
 
 import (
@@ -24,42 +25,59 @@ import (
 )
 
 // ClientParameters is used to set keepalive parameters on the client-side.
-// These configure how the client will actively probe to notice when a connection is broken
-// and send pings so intermediaries will be aware of the liveness of the connection.
-// Make sure these parameters are set in coordination with the keepalive policy on the server,
-// as incompatible settings can result in closing of connection.
+// These configure how the client will actively probe to notice when a
+// connection is broken and send pings so intermediaries will be aware of the
+// liveness of the connection. Make sure these parameters are set in
+// coordination with the keepalive policy on the server, as incompatible
+// settings can result in closing of connection.
 type ClientParameters struct {
-        // After a duration of this time if the client doesn't see any activity it pings the server to see if the transport is still alive.
+        // After a duration of this time if the client doesn't see any activity it
+        // pings the server to see if the transport is still alive.
         Time time.Duration // The current default value is infinity.
-        // After having pinged for keepalive check, the client waits for a duration of Timeout and if no activity is seen even after that
-        // the connection is closed.
+        // After having pinged for keepalive check, the client waits for a duration
+        // of Timeout and if no activity is seen even after that the connection is
+        // closed.
         Timeout time.Duration // The current default value is 20 seconds.
-        // If true, client runs keepalive checks even with no active RPCs.
+        // If true, client sends keepalive pings even with no active RPCs. If false,
+        // when there are no active RPCs, Time and Timeout will be ignored and no
+        // keepalive pings will be sent.
         PermitWithoutStream bool // false by default.
 }
 
-// ServerParameters is used to set keepalive and max-age parameters on the server-side.
+// ServerParameters is used to set keepalive and max-age parameters on the
+// server-side.
 type ServerParameters struct {
-        // MaxConnectionIdle is a duration for the amount of time after which an idle connection would be closed by sending a GoAway.
-        // Idleness duration is defined since the most recent time the number of outstanding RPCs became zero or the connection establishment.
+        // MaxConnectionIdle is a duration for the amount of time after which an
+        // idle connection would be closed by sending a GoAway. Idleness duration is
+        // defined since the most recent time the number of outstanding RPCs became
+        // zero or the connection establishment.
         MaxConnectionIdle time.Duration // The current default value is infinity.
-        // MaxConnectionAge is a duration for the maximum amount of time a connection may exist before it will be closed by sending a GoAway.
-        // A random jitter of +/-10% will be added to MaxConnectionAge to spread out connection storms.
+        // MaxConnectionAge is a duration for the maximum amount of time a
+        // connection may exist before it will be closed by sending a GoAway. A
+        // random jitter of +/-10% will be added to MaxConnectionAge to spread out
+        // connection storms.
         MaxConnectionAge time.Duration // The current default value is infinity.
-        // MaxConnectinoAgeGrace is an additive period after MaxConnectionAge after which the connection will be forcibly closed.
+        // MaxConnectionAgeGrace is an additive period after MaxConnectionAge after
+        // which the connection will be forcibly closed.
         MaxConnectionAgeGrace time.Duration // The current default value is infinity.
-        // After a duration of this time if the server doesn't see any activity it pings the client to see if the transport is still alive.
+        // After a duration of this time if the server doesn't see any activity it
+        // pings the client to see if the transport is still alive.
         Time time.Duration // The current default value is 2 hours.
-        // After having pinged for keepalive check, the server waits for a duration of Timeout and if no activity is seen even after that
-        // the connection is closed.
+        // After having pinged for keepalive check, the server waits for a duration
+        // of Timeout and if no activity is seen even after that the connection is
+        // closed.
         Timeout time.Duration // The current default value is 20 seconds.
 }
 
-// EnforcementPolicy is used to set keepalive enforcement policy on the server-side.
-// Server will close connection with a client that violates this policy.
+// EnforcementPolicy is used to set keepalive enforcement policy on the
+// server-side. Server will close connection with a client that violates this
+// policy.
 type EnforcementPolicy struct {
-        // MinTime is the minimum amount of time a client should wait before sending a keepalive ping.
+        // MinTime is the minimum amount of time a client should wait before sending
+        // a keepalive ping.
         MinTime time.Duration // The current default value is 5 minutes.
-        // If true, server expects keepalive pings even when there are no active streams(RPCs).
+        // If true, server allows keepalive pings even when there are no active
+        // streams(RPCs). If false, and client sends ping when there are no active
+        // streams, server will send GOAWAY and close the connection.
         PermitWithoutStream bool // false by default.
 }
diff --git a/vendor/google.golang.org/grpc/metadata/metadata.go b/vendor/google.golang.org/grpc/metadata/metadata.go
index be4f9e7..cf6d1b9 100644
--- a/vendor/google.golang.org/grpc/metadata/metadata.go
+++ b/vendor/google.golang.org/grpc/metadata/metadata.go
@@ -17,17 +17,19 @@
  */
 
 // Package metadata define the structure of the metadata supported by gRPC library.
-// Please refer to https://grpc.io/docs/guides/wire.html for more information about custom-metadata.
+// Please refer to https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md
+// for more information about custom-metadata.
 package metadata // import "google.golang.org/grpc/metadata"
 
 import (
+        "context"
         "fmt"
         "strings"
-
-        "golang.org/x/net/context"
 )
 
-// DecodeKeyValue returns k, v, nil.  It is deprecated and should not be used.
+// DecodeKeyValue returns k, v, nil.
+//
+// Deprecated: use k and v directly instead.
 func DecodeKeyValue(k, v string) (string, string, error) {
         return k, v, nil
 }
@@ -44,6 +46,9 @@ type MD map[string][]string
 //  - lowercase letters: a-z
 //  - special characters: -_.
 // Uppercase letters are automatically converted to lowercase.
+//
+// Keys beginning with "grpc-" are reserved for grpc-internal use only and may
+// result in errors if set in metadata.
 func New(m map[string]string) MD {
         md := MD{}
         for k, val := range m {
@@ -62,6 +67,9 @@ func New(m map[string]string) MD {
 //  - lowercase letters: a-z
 //  - special characters: -_.
 // Uppercase letters are automatically converted to lowercase.
+//
+// Keys beginning with "grpc-" are reserved for grpc-internal use only and may
+// result in errors if set in metadata.
 func Pairs(kv ...string) MD {
         if len(kv)%2 == 1 {
                 panic(fmt.Sprintf("metadata: Pairs got the odd number of input pairs for metadata: %d", len(kv)))
@@ -88,6 +96,30 @@ func (md MD) Copy() MD {
         return Join(md)
 }
 
+// Get obtains the values for a given key.
+func (md MD) Get(k string) []string {
+        k = strings.ToLower(k)
+        return md[k]
+}
+
+// Set sets the value of a given key with a slice of values.
+func (md MD) Set(k string, vals ...string) {
+        if len(vals) == 0 {
+                return
+        }
+        k = strings.ToLower(k)
+        md[k] = vals
+}
+
+// Append adds the values to key k, not overwriting what was already stored at that key.
+func (md MD) Append(k string, vals ...string) {
+        if len(vals) == 0 {
+                return
+        }
+        k = strings.ToLower(k)
+        md[k] = append(md[k], vals...)
+}
+
 // Join joins any number of mds into a single MD.
 // The order of values for each key is determined by the order in which
 // the mds containing those values are presented to Join.
@@ -104,24 +136,31 @@ func Join(mds ...MD) MD {
 type mdIncomingKey struct{}
 type mdOutgoingKey struct{}
 
-// NewContext is a wrapper for NewOutgoingContext(ctx, md).  Deprecated.
-func NewContext(ctx context.Context, md MD) context.Context {
-        return NewOutgoingContext(ctx, md)
-}
-
 // NewIncomingContext creates a new context with incoming md attached.
 func NewIncomingContext(ctx context.Context, md MD) context.Context {
         return context.WithValue(ctx, mdIncomingKey{}, md)
 }
 
-// NewOutgoingContext creates a new context with outgoing md attached.
+// NewOutgoingContext creates a new context with outgoing md attached. If used
+// in conjunction with AppendToOutgoingContext, NewOutgoingContext will
+// overwrite any previously-appended metadata.
 func NewOutgoingContext(ctx context.Context, md MD) context.Context {
-        return context.WithValue(ctx, mdOutgoingKey{}, md)
+        return context.WithValue(ctx, mdOutgoingKey{}, rawMD{md: md})
 }
 
-// FromContext is a wrapper for FromIncomingContext(ctx).  Deprecated.
-func FromContext(ctx context.Context) (md MD, ok bool) {
-        return FromIncomingContext(ctx)
+// AppendToOutgoingContext returns a new context with the provided kv merged
+// with any existing metadata in the context. Please refer to the
+// documentation of Pairs for a description of kv.
+func AppendToOutgoingContext(ctx context.Context, kv ...string) context.Context {
+        if len(kv)%2 == 1 {
+                panic(fmt.Sprintf("metadata: AppendToOutgoingContext got an odd number of input pairs for metadata: %d", len(kv)))
+        }
+        md, _ := ctx.Value(mdOutgoingKey{}).(rawMD)
+        added := make([][]string, len(md.added)+1)
+        copy(added, md.added)
+        added[len(added)-1] = make([]string, len(kv))
+        copy(added[len(added)-1], kv)
+        return context.WithValue(ctx, mdOutgoingKey{}, rawMD{md: md.md, added: added})
 }
 
 // FromIncomingContext returns the incoming metadata in ctx if it exists.  The
@@ -132,10 +171,39 @@ func FromIncomingContext(ctx context.Context) (md MD, ok bool) {
         return
 }
 
+// FromOutgoingContextRaw returns the un-merged, intermediary contents
+// of rawMD. Remember to perform strings.ToLower on the keys. The returned
+// MD should not be modified. Writing to it may cause races. Modification
+// should be made to copies of the returned MD.
+//
+// This is intended for gRPC-internal use ONLY.
+func FromOutgoingContextRaw(ctx context.Context) (MD, [][]string, bool) {
+        raw, ok := ctx.Value(mdOutgoingKey{}).(rawMD)
+        if !ok {
+                return nil, nil, false
+        }
+
+        return raw.md, raw.added, true
+}
+
 // FromOutgoingContext returns the outgoing metadata in ctx if it exists.  The
 // returned MD should not be modified. Writing to it may cause races.
-// Modification should be made to the copies of the returned MD.
-func FromOutgoingContext(ctx context.Context) (md MD, ok bool) {
-        md, ok = ctx.Value(mdOutgoingKey{}).(MD)
-        return
+// Modification should be made to copies of the returned MD.
+func FromOutgoingContext(ctx context.Context) (MD, bool) {
+        raw, ok := ctx.Value(mdOutgoingKey{}).(rawMD)
+        if !ok {
+                return nil, false
+        }
+
+        mds := make([]MD, 0, len(raw.added)+1)
+        mds = append(mds, raw.md)
+        for _, vv := range raw.added {
+                mds = append(mds, Pairs(vv...))
+        }
+        return Join(mds...), ok
+}
+
+type rawMD struct {
+        md    MD
+        added [][]string
 }
diff --git a/vendor/google.golang.org/grpc/naming/dns_resolver.go b/vendor/google.golang.org/grpc/naming/dns_resolver.go
index efd37e3..fd8cd3b 100644
--- a/vendor/google.golang.org/grpc/naming/dns_resolver.go
+++ b/vendor/google.golang.org/grpc/naming/dns_resolver.go
@@ -19,13 +19,13 @@
 package naming
 
 import (
+        "context"
         "errors"
         "fmt"
         "net"
         "strconv"
         "time"
 
-        "golang.org/x/net/context"
         "google.golang.org/grpc/grpclog"
 )
 
@@ -37,6 +37,9 @@ const (
 var (
         errMissingAddr  = errors.New("missing address")
         errWatcherClose = errors.New("watcher has been closed")
+
+        lookupHost = net.DefaultResolver.LookupHost
+        lookupSRV  = net.DefaultResolver.LookupSRV
 )
 
 // NewDNSResolverWithFreq creates a DNS Resolver that can resolve DNS names, and
@@ -141,8 +144,8 @@ type dnsWatcher struct {
         r    *dnsResolver
         host string
         port string
-        // The latest resolved address list
-        curAddrs []*Update
+        // The latest resolved address set
+        curAddrs map[string]*Update
         ctx      context.Context
         cancel   context.CancelFunc
         t        *time.Timer
@@ -153,10 +156,10 @@ type ipWatcher struct {
         updateChan chan *Update
 }
 
-// Next returns the adrress resolution Update for the target. For IP address,
-// the resolution is itself, thus polling name server is unncessary. Therefore,
+// Next returns the address resolution Update for the target. For IP address,
+// the resolution is itself, thus polling name server is unnecessary. Therefore,
 // Next() will return an Update the first time it is called, and will be blocked
-// for all following calls as no Update exisits until watcher is closed.
+// for all following calls as no Update exists until watcher is closed.
 func (i *ipWatcher) Next() ([]*Update, error) {
         u, ok := <-i.updateChan
         if !ok {
@@ -192,28 +195,24 @@ type AddrMetadataGRPCLB struct {
 
 // compileUpdate compares the old resolved addresses and newly resolved addresses,
 // and generates an update list
-func (w *dnsWatcher) compileUpdate(newAddrs []*Update) []*Update {
-        update := make(map[Update]bool)
-        for _, u := range newAddrs {
-                update[*u] = true
-        }
-        for _, u := range w.curAddrs {
-                if _, ok := update[*u]; ok {
-                        delete(update, *u)
-                        continue
+func (w *dnsWatcher) compileUpdate(newAddrs map[string]*Update) []*Update {
+        var res []*Update
+        for a, u := range w.curAddrs {
+                if _, ok := newAddrs[a]; !ok {
+                        u.Op = Delete
+                        res = append(res, u)
                 }
-                update[Update{Addr: u.Addr, Op: Delete, Metadata: u.Metadata}] = true
         }
-        res := make([]*Update, 0, len(update))
-        for k := range update {
-                tmp := k
-                res = append(res, &tmp)
+        for a, u := range newAddrs {
+                if _, ok := w.curAddrs[a]; !ok {
+                        res = append(res, u)
+                }
         }
         return res
 }
 
-func (w *dnsWatcher) lookupSRV() []*Update {
-        var newAddrs []*Update
+func (w *dnsWatcher) lookupSRV() map[string]*Update {
+        newAddrs := make(map[string]*Update)
         _, srvs, err := lookupSRV(w.ctx, "grpclb", "tcp", w.host)
         if err != nil {
                 grpclog.Infof("grpc: failed dns SRV record lookup due to %v.\n", err)
@@ -231,15 +230,16 @@ func (w *dnsWatcher) lookupSRV() []*Update {
                                 grpclog.Errorf("grpc: failed IP parsing due to %v.\n", err)
                                 continue
                         }
-                        newAddrs = append(newAddrs, &Update{Addr: a + ":" + strconv.Itoa(int(s.Port)),
-                                Metadata: AddrMetadataGRPCLB{AddrType: GRPCLB, ServerName: s.Target}})
+                        addr := a + ":" + strconv.Itoa(int(s.Port))
+                        newAddrs[addr] = &Update{Addr: addr,
+                                Metadata: AddrMetadataGRPCLB{AddrType: GRPCLB, ServerName: s.Target}}
                 }
         }
         return newAddrs
 }
 
-func (w *dnsWatcher) lookupHost() []*Update {
-        var newAddrs []*Update
+func (w *dnsWatcher) lookupHost() map[string]*Update {
+        newAddrs := make(map[string]*Update)
         addrs, err := lookupHost(w.ctx, w.host)
         if err != nil {
                 grpclog.Warningf("grpc: failed dns A record lookup due to %v.\n", err)
@@ -251,7 +251,8 @@ func (w *dnsWatcher) lookupHost() []*Update {
                         grpclog.Errorf("grpc: failed IP parsing due to %v.\n", err)
                         continue
                 }
-                newAddrs = append(newAddrs, &Update{Addr: a + ":" + w.port})
+                addr := a + ":" + w.port
+                newAddrs[addr] = &Update{Addr: addr}
         }
         return newAddrs
 }
diff --git a/vendor/google.golang.org/grpc/naming/naming.go b/vendor/google.golang.org/grpc/naming/naming.go
index 1af7e32..8cc39e9 100644
--- a/vendor/google.golang.org/grpc/naming/naming.go
+++ b/vendor/google.golang.org/grpc/naming/naming.go
@@ -18,20 +18,26 @@
 
 // Package naming defines the naming API and related data structures for gRPC.
 // The interface is EXPERIMENTAL and may be suject to change.
+//
+// Deprecated: please use package resolver.
 package naming
 
 // Operation defines the corresponding operations for a name resolution change.
+//
+// Deprecated: please use package resolver.
 type Operation uint8
 
 const (
         // Add indicates a new address is added.
         Add Operation = iota
-        // Delete indicates an exisiting address is deleted.
+        // Delete indicates an existing address is deleted.
         Delete
 )
 
 // Update defines a name resolution update. Notice that it is not valid having both
 // empty string Addr and nil Metadata in an Update.
+//
+// Deprecated: please use package resolver.
 type Update struct {
         // Op indicates the operation of the update.
         Op Operation
@@ -43,12 +49,16 @@ type Update struct {
 }
 
 // Resolver creates a Watcher for a target to track its resolution changes.
+//
+// Deprecated: please use package resolver.
 type Resolver interface {
         // Resolve creates a Watcher for target.
         Resolve(target string) (Watcher, error)
 }
 
 // Watcher watches for the updates on the specified target.
+//
+// Deprecated: please use package resolver.
 type Watcher interface {
         // Next blocks until an update or error happens. It may return one or more
         // updates. The first call should get the full set of the results. It should
diff --git a/vendor/google.golang.org/grpc/peer/peer.go b/vendor/google.golang.org/grpc/peer/peer.go
index 317b8b9..e01d219 100644
--- a/vendor/google.golang.org/grpc/peer/peer.go
+++ b/vendor/google.golang.org/grpc/peer/peer.go
@@ -21,9 +21,9 @@
 package peer
 
 import (
+        "context"
         "net"
 
-        "golang.org/x/net/context"
         "google.golang.org/grpc/credentials"
 )
 
diff --git a/vendor/google.golang.org/grpc/picker_wrapper.go b/vendor/google.golang.org/grpc/picker_wrapper.go
new file mode 100644
index 0000000..14f915d
--- /dev/null
+++ b/vendor/google.golang.org/grpc/picker_wrapper.go
@@ -0,0 +1,180 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package grpc
+
+import (
+        "context"
+        "io"
+        "sync"
+
+        "google.golang.org/grpc/balancer"
+        "google.golang.org/grpc/codes"
+        "google.golang.org/grpc/grpclog"
+        "google.golang.org/grpc/internal/channelz"
+        "google.golang.org/grpc/internal/transport"
+        "google.golang.org/grpc/status"
+)
+
+// pickerWrapper is a wrapper of balancer.Picker. It blocks on certain pick
+// actions and unblock when there's a picker update.
+type pickerWrapper struct {
+        mu         sync.Mutex
+        done       bool
+        blockingCh chan struct{}
+        picker     balancer.Picker
+
+        // The latest connection happened.
+        connErrMu sync.Mutex
+        connErr   error
+}
+
+func newPickerWrapper() *pickerWrapper {
+        bp := &pickerWrapper{blockingCh: make(chan struct{})}
+        return bp
+}
+
+func (bp *pickerWrapper) updateConnectionError(err error) {
+        bp.connErrMu.Lock()
+        bp.connErr = err
+        bp.connErrMu.Unlock()
+}
+
+func (bp *pickerWrapper) connectionError() error {
+        bp.connErrMu.Lock()
+        err := bp.connErr
+        bp.connErrMu.Unlock()
+        return err
+}
+
+// updatePicker is called by UpdateBalancerState. It unblocks all blocked pick.
+func (bp *pickerWrapper) updatePicker(p balancer.Picker) {
+        bp.mu.Lock()
+        if bp.done {
+                bp.mu.Unlock()
+                return
+        }
+        bp.picker = p
+        // bp.blockingCh should never be nil.
+        close(bp.blockingCh)
+        bp.blockingCh = make(chan struct{})
+        bp.mu.Unlock()
+}
+
+func doneChannelzWrapper(acw *acBalancerWrapper, done func(balancer.DoneInfo)) func(balancer.DoneInfo) {
+        acw.mu.Lock()
+        ac := acw.ac
+        acw.mu.Unlock()
+        ac.incrCallsStarted()
+        return func(b balancer.DoneInfo) {
+                if b.Err != nil && b.Err != io.EOF {
+                        ac.incrCallsFailed()
+                } else {
+                        ac.incrCallsSucceeded()
+                }
+                if done != nil {
+                        done(b)
+                }
+        }
+}
+
+// pick returns the transport that will be used for the RPC.
+// It may block in the following cases:
+// - there's no picker
+// - the current picker returns ErrNoSubConnAvailable
+// - the current picker returns other errors and failfast is false.
+// - the subConn returned by the current picker is not READY
+// When one of these situations happens, pick blocks until the picker gets updated.
+func (bp *pickerWrapper) pick(ctx context.Context, failfast bool, opts balancer.PickOptions) (transport.ClientTransport, func(balancer.DoneInfo), error) {
+        var (
+                p  balancer.Picker
+                ch chan struct{}
+        )
+
+        for {
+                bp.mu.Lock()
+                if bp.done {
+                        bp.mu.Unlock()
+                        return nil, nil, ErrClientConnClosing
+                }
+
+                if bp.picker == nil {
+                        ch = bp.blockingCh
+                }
+                if ch == bp.blockingCh {
+                        // This could happen when either:
+                        // - bp.picker is nil (the previous if condition), or
+                        // - has called pick on the current picker.
+                        bp.mu.Unlock()
+                        select {
+                        case <-ctx.Done():
+                                return nil, nil, ctx.Err()
+                        case <-ch:
+                        }
+                        continue
+                }
+
+                ch = bp.blockingCh
+                p = bp.picker
+                bp.mu.Unlock()
+
+                subConn, done, err := p.Pick(ctx, opts)
+
+                if err != nil {
+                        switch err {
+                        case balancer.ErrNoSubConnAvailable:
+                                continue
+                        case balancer.ErrTransientFailure:
+                                if !failfast {
+                                        continue
+                                }
+                                return nil, nil, status.Errorf(codes.Unavailable, "%v, latest connection error: %v", err, bp.connectionError())
+                        default:
+                                // err is some other error.
+                                return nil, nil, toRPCErr(err)
+                        }
+                }
+
+                acw, ok := subConn.(*acBalancerWrapper)
+                if !ok {
+                        grpclog.Infof("subconn returned from pick is not *acBalancerWrapper")
+                        continue
+                }
+                if t, ok := acw.getAddrConn().getReadyTransport(); ok {
+                        if channelz.IsOn() {
+                                return t, doneChannelzWrapper(acw, done), nil
+                        }
+                        return t, done, nil
+                }
+                grpclog.Infof("blockingPicker: the picked transport is not ready, loop back to repick")
+                // If ok == false, ac.state is not READY.
+                // A valid picker always returns READY subConn. This means the state of ac
+                // just changed, and picker will be updated shortly.
+                // continue back to the beginning of the for loop to repick.
+        }
+}
+
+func (bp *pickerWrapper) close() {
+        bp.mu.Lock()
+        defer bp.mu.Unlock()
+        if bp.done {
+                return
+        }
+        bp.done = true
+        close(bp.blockingCh)
+}
diff --git a/vendor/google.golang.org/grpc/pickfirst.go b/vendor/google.golang.org/grpc/pickfirst.go
new file mode 100644
index 0000000..d1e38aa
--- /dev/null
+++ b/vendor/google.golang.org/grpc/pickfirst.go
@@ -0,0 +1,110 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package grpc
+
+import (
+        "context"
+
+        "google.golang.org/grpc/balancer"
+        "google.golang.org/grpc/connectivity"
+        "google.golang.org/grpc/grpclog"
+        "google.golang.org/grpc/resolver"
+)
+
+// PickFirstBalancerName is the name of the pick_first balancer.
+const PickFirstBalancerName = "pick_first"
+
+func newPickfirstBuilder() balancer.Builder {
+        return &pickfirstBuilder{}
+}
+
+type pickfirstBuilder struct{}
+
+func (*pickfirstBuilder) Build(cc balancer.ClientConn, opt balancer.BuildOptions) balancer.Balancer {
+        return &pickfirstBalancer{cc: cc}
+}
+
+func (*pickfirstBuilder) Name() string {
+        return PickFirstBalancerName
+}
+
+type pickfirstBalancer struct {
+        cc balancer.ClientConn
+        sc balancer.SubConn
+}
+
+func (b *pickfirstBalancer) HandleResolvedAddrs(addrs []resolver.Address, err error) {
+        if err != nil {
+                grpclog.Infof("pickfirstBalancer: HandleResolvedAddrs called with error %v", err)
+                return
+        }
+        if b.sc == nil {
+                b.sc, err = b.cc.NewSubConn(addrs, balancer.NewSubConnOptions{})
+                if err != nil {
+                        //TODO(yuxuanli): why not change the cc state to Idle?
+                        grpclog.Errorf("pickfirstBalancer: failed to NewSubConn: %v", err)
+                        return
+                }
+                b.cc.UpdateBalancerState(connectivity.Idle, &picker{sc: b.sc})
+                b.sc.Connect()
+        } else {
+                b.sc.UpdateAddresses(addrs)
+                b.sc.Connect()
+        }
+}
+
+func (b *pickfirstBalancer) HandleSubConnStateChange(sc balancer.SubConn, s connectivity.State) {
+        grpclog.Infof("pickfirstBalancer: HandleSubConnStateChange: %p, %v", sc, s)
+        if b.sc != sc {
+                grpclog.Infof("pickfirstBalancer: ignored state change because sc is not recognized")
+                return
+        }
+        if s == connectivity.Shutdown {
+                b.sc = nil
+                return
+        }
+
+        switch s {
+        case connectivity.Ready, connectivity.Idle:
+                b.cc.UpdateBalancerState(s, &picker{sc: sc})
+        case connectivity.Connecting:
+                b.cc.UpdateBalancerState(s, &picker{err: balancer.ErrNoSubConnAvailable})
+        case connectivity.TransientFailure:
+                b.cc.UpdateBalancerState(s, &picker{err: balancer.ErrTransientFailure})
+        }
+}
+
+func (b *pickfirstBalancer) Close() {
+}
+
+type picker struct {
+        err error
+        sc  balancer.SubConn
+}
+
+func (p *picker) Pick(ctx context.Context, opts balancer.PickOptions) (balancer.SubConn, func(balancer.DoneInfo), error) {
+        if p.err != nil {
+                return nil, nil, p.err
+        }
+        return p.sc, nil, nil
+}
+
+func init() {
+        balancer.Register(newPickfirstBuilder())
+}
diff --git a/vendor/google.golang.org/grpc/proxy.go b/vendor/google.golang.org/grpc/proxy.go
index 2d40236..f8f69bf 100644
--- a/vendor/google.golang.org/grpc/proxy.go
+++ b/vendor/google.golang.org/grpc/proxy.go
@@ -20,6 +20,8 @@ package grpc
 
 import (
         "bufio"
+        "context"
+        "encoding/base64"
         "errors"
         "fmt"
         "io"
@@ -27,10 +29,10 @@ import (
         "net/http"
         "net/http/httputil"
         "net/url"
-
-        "golang.org/x/net/context"
 )
 
+const proxyAuthHeaderKey = "Proxy-Authorization"
+
 var (
         // errDisabled indicates that proxy is disabled for the address.
         errDisabled = errors.New("proxy is disabled for the address")
@@ -38,7 +40,7 @@ var (
         httpProxyFromEnvironment = http.ProxyFromEnvironment
 )
 
-func mapAddress(ctx context.Context, address string) (string, error) {
+func mapAddress(ctx context.Context, address string) (*url.URL, error) {
         req := &http.Request{
                 URL: &url.URL{
                         Scheme: "https",
@@ -47,12 +49,12 @@ func mapAddress(ctx context.Context, address string) (string, error) {
         }
         url, err := httpProxyFromEnvironment(req)
         if err != nil {
-                return "", err
+                return nil, err
         }
         if url == nil {
-                return "", errDisabled
+                return nil, errDisabled
         }
-        return url.Host, nil
+        return url, nil
 }
 
 // To read a response from a net.Conn, http.ReadResponse() takes a bufio.Reader.
@@ -69,18 +71,28 @@ func (c *bufConn) Read(b []byte) (int, error) {
         return c.r.Read(b)
 }
 
-func doHTTPConnectHandshake(ctx context.Context, conn net.Conn, addr string) (_ net.Conn, err error) {
+func basicAuth(username, password string) string {
+        auth := username + ":" + password
+        return base64.StdEncoding.EncodeToString([]byte(auth))
+}
+
+func doHTTPConnectHandshake(ctx context.Context, conn net.Conn, backendAddr string, proxyURL *url.URL) (_ net.Conn, err error) {
         defer func() {
                 if err != nil {
                         conn.Close()
                 }
         }()
 
-        req := (&http.Request{
+        req := &http.Request{
                 Method: http.MethodConnect,
-                URL:    &url.URL{Host: addr},
+                URL:    &url.URL{Host: backendAddr},
                 Header: map[string][]string{"User-Agent": {grpcUA}},
-        })
+        }
+        if t := proxyURL.User; t != nil {
+                u := t.Username()
+                p, _ := t.Password()
+                req.Header.Add(proxyAuthHeaderKey, "Basic "+basicAuth(u, p))
+        }
 
         if err := sendHTTPRequest(ctx, req, conn); err != nil {
                 return nil, fmt.Errorf("failed to write the HTTP request: %v", err)
@@ -108,23 +120,33 @@ func doHTTPConnectHandshake(ctx context.Context, conn net.Conn, addr string) (_
 // provided dialer, does HTTP CONNECT handshake and returns the connection.
 func newProxyDialer(dialer func(context.Context, string) (net.Conn, error)) func(context.Context, string) (net.Conn, error) {
         return func(ctx context.Context, addr string) (conn net.Conn, err error) {
-                var skipHandshake bool
-                newAddr, err := mapAddress(ctx, addr)
+                var newAddr string
+                proxyURL, err := mapAddress(ctx, addr)
                 if err != nil {
                         if err != errDisabled {
                                 return nil, err
                         }
-                        skipHandshake = true
                         newAddr = addr
+                } else {
+                        newAddr = proxyURL.Host
                 }
 
                 conn, err = dialer(ctx, newAddr)
                 if err != nil {
                         return
                 }
-                if !skipHandshake {
-                        conn, err = doHTTPConnectHandshake(ctx, conn, addr)
+                if proxyURL != nil {
+                        // proxy is disabled if proxyURL is nil.
+                        conn, err = doHTTPConnectHandshake(ctx, conn, addr, proxyURL)
                 }
                 return
         }
 }
+
+func sendHTTPRequest(ctx context.Context, req *http.Request, conn net.Conn) error {
+        req = req.WithContext(ctx)
+        if err := req.Write(conn); err != nil {
+                return fmt.Errorf("failed to write the HTTP request: %v", err)
+        }
+        return nil
+}
diff --git a/vendor/google.golang.org/grpc/resolver/dns/dns_resolver.go b/vendor/google.golang.org/grpc/resolver/dns/dns_resolver.go
new file mode 100644
index 0000000..f33189f
--- /dev/null
+++ b/vendor/google.golang.org/grpc/resolver/dns/dns_resolver.go
@@ -0,0 +1,436 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package dns implements a dns resolver to be installed as the default resolver
+// in grpc.
+package dns
+
+import (
+        "context"
+        "encoding/json"
+        "errors"
+        "fmt"
+        "net"
+        "os"
+        "strconv"
+        "strings"
+        "sync"
+        "time"
+
+        "google.golang.org/grpc/grpclog"
+        "google.golang.org/grpc/internal/backoff"
+        "google.golang.org/grpc/internal/grpcrand"
+        "google.golang.org/grpc/resolver"
+)
+
+func init() {
+        resolver.Register(NewBuilder())
+}
+
+const (
+        defaultPort       = "443"
+        defaultFreq       = time.Minute * 30
+        defaultDNSSvrPort = "53"
+        golang            = "GO"
+        // In DNS, service config is encoded in a TXT record via the mechanism
+        // described in RFC-1464 using the attribute name grpc_config.
+        txtAttribute = "grpc_config="
+)
+
+var (
+        errMissingAddr = errors.New("dns resolver: missing address")
+
+        // Addresses ending with a colon that is supposed to be the separator
+        // between host and port is not allowed.  E.g. "::" is a valid address as
+        // it is an IPv6 address (host only) and "[::]:" is invalid as it ends with
+        // a colon as the host and port separator
+        errEndsWithColon = errors.New("dns resolver: missing port after port-separator colon")
+)
+
+var (
+        defaultResolver netResolver = net.DefaultResolver
+)
+
+var customAuthorityDialler = func(authority string) func(ctx context.Context, network, address string) (net.Conn, error) {
+        return func(ctx context.Context, network, address string) (net.Conn, error) {
+                var dialer net.Dialer
+                return dialer.DialContext(ctx, network, authority)
+        }
+}
+
+var customAuthorityResolver = func(authority string) (netResolver, error) {
+        host, port, err := parseTarget(authority, defaultDNSSvrPort)
+        if err != nil {
+                return nil, err
+        }
+
+        authorityWithPort := net.JoinHostPort(host, port)
+
+        return &net.Resolver{
+                PreferGo: true,
+                Dial:     customAuthorityDialler(authorityWithPort),
+        }, nil
+}
+
+// NewBuilder creates a dnsBuilder which is used to factory DNS resolvers.
+func NewBuilder() resolver.Builder {
+        return &dnsBuilder{minFreq: defaultFreq}
+}
+
+type dnsBuilder struct {
+        // minimum frequency of polling the DNS server.
+        minFreq time.Duration
+}
+
+// Build creates and starts a DNS resolver that watches the name resolution of the target.
+func (b *dnsBuilder) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOption) (resolver.Resolver, error) {
+        host, port, err := parseTarget(target.Endpoint, defaultPort)
+        if err != nil {
+                return nil, err
+        }
+
+        // IP address.
+        if net.ParseIP(host) != nil {
+                host, _ = formatIP(host)
+                addr := []resolver.Address{{Addr: host + ":" + port}}
+                i := &ipResolver{
+                        cc: cc,
+                        ip: addr,
+                        rn: make(chan struct{}, 1),
+                        q:  make(chan struct{}),
+                }
+                cc.NewAddress(addr)
+                go i.watcher()
+                return i, nil
+        }
+
+        // DNS address (non-IP).
+        ctx, cancel := context.WithCancel(context.Background())
+        d := &dnsResolver{
+                freq:                 b.minFreq,
+                backoff:              backoff.Exponential{MaxDelay: b.minFreq},
+                host:                 host,
+                port:                 port,
+                ctx:                  ctx,
+                cancel:               cancel,
+                cc:                   cc,
+                t:                    time.NewTimer(0),
+                rn:                   make(chan struct{}, 1),
+                disableServiceConfig: opts.DisableServiceConfig,
+        }
+
+        if target.Authority == "" {
+                d.resolver = defaultResolver
+        } else {
+                d.resolver, err = customAuthorityResolver(target.Authority)
+                if err != nil {
+                        return nil, err
+                }
+        }
+
+        d.wg.Add(1)
+        go d.watcher()
+        return d, nil
+}
+
+// Scheme returns the naming scheme of this resolver builder, which is "dns".
+func (b *dnsBuilder) Scheme() string {
+        return "dns"
+}
+
+type netResolver interface {
+        LookupHost(ctx context.Context, host string) (addrs []string, err error)
+        LookupSRV(ctx context.Context, service, proto, name string) (cname string, addrs []*net.SRV, err error)
+        LookupTXT(ctx context.Context, name string) (txts []string, err error)
+}
+
+// ipResolver watches for the name resolution update for an IP address.
+type ipResolver struct {
+        cc resolver.ClientConn
+        ip []resolver.Address
+        // rn channel is used by ResolveNow() to force an immediate resolution of the target.
+        rn chan struct{}
+        q  chan struct{}
+}
+
+// ResolveNow resend the address it stores, no resolution is needed.
+func (i *ipResolver) ResolveNow(opt resolver.ResolveNowOption) {
+        select {
+        case i.rn <- struct{}{}:
+        default:
+        }
+}
+
+// Close closes the ipResolver.
+func (i *ipResolver) Close() {
+        close(i.q)
+}
+
+func (i *ipResolver) watcher() {
+        for {
+                select {
+                case <-i.rn:
+                        i.cc.NewAddress(i.ip)
+                case <-i.q:
+                        return
+                }
+        }
+}
+
+// dnsResolver watches for the name resolution update for a non-IP target.
+type dnsResolver struct {
+        freq       time.Duration
+        backoff    backoff.Exponential
+        retryCount int
+        host       string
+        port       string
+        resolver   netResolver
+        ctx        context.Context
+        cancel     context.CancelFunc
+        cc         resolver.ClientConn
+        // rn channel is used by ResolveNow() to force an immediate resolution of the target.
+        rn chan struct{}
+        t  *time.Timer
+        // wg is used to enforce Close() to return after the watcher() goroutine has finished.
+        // Otherwise, data race will be possible. [Race Example] in dns_resolver_test we
+        // replace the real lookup functions with mocked ones to facilitate testing.
+        // If Close() doesn't wait for watcher() goroutine finishes, race detector sometimes
+        // will warns lookup (READ the lookup function pointers) inside watcher() goroutine
+        // has data race with replaceNetFunc (WRITE the lookup function pointers).
+        wg                   sync.WaitGroup
+        disableServiceConfig bool
+}
+
+// ResolveNow invoke an immediate resolution of the target that this dnsResolver watches.
+func (d *dnsResolver) ResolveNow(opt resolver.ResolveNowOption) {
+        select {
+        case d.rn <- struct{}{}:
+        default:
+        }
+}
+
+// Close closes the dnsResolver.
+func (d *dnsResolver) Close() {
+        d.cancel()
+        d.wg.Wait()
+        d.t.Stop()
+}
+
+func (d *dnsResolver) watcher() {
+        defer d.wg.Done()
+        for {
+                select {
+                case <-d.ctx.Done():
+                        return
+                case <-d.t.C:
+                case <-d.rn:
+                }
+                result, sc := d.lookup()
+                // Next lookup should happen within an interval defined by d.freq. It may be
+                // more often due to exponential retry on empty address list.
+                if len(result) == 0 {
+                        d.retryCount++
+                        d.t.Reset(d.backoff.Backoff(d.retryCount))
+                } else {
+                        d.retryCount = 0
+                        d.t.Reset(d.freq)
+                }
+                d.cc.NewServiceConfig(sc)
+                d.cc.NewAddress(result)
+        }
+}
+
+func (d *dnsResolver) lookupSRV() []resolver.Address {
+        var newAddrs []resolver.Address
+        _, srvs, err := d.resolver.LookupSRV(d.ctx, "grpclb", "tcp", d.host)
+        if err != nil {
+                grpclog.Infof("grpc: failed dns SRV record lookup due to %v.\n", err)
+                return nil
+        }
+        for _, s := range srvs {
+                lbAddrs, err := d.resolver.LookupHost(d.ctx, s.Target)
+                if err != nil {
+                        grpclog.Infof("grpc: failed load balancer address dns lookup due to %v.\n", err)
+                        continue
+                }
+                for _, a := range lbAddrs {
+                        a, ok := formatIP(a)
+                        if !ok {
+                                grpclog.Errorf("grpc: failed IP parsing due to %v.\n", err)
+                                continue
+                        }
+                        addr := a + ":" + strconv.Itoa(int(s.Port))
+                        newAddrs = append(newAddrs, resolver.Address{Addr: addr, Type: resolver.GRPCLB, ServerName: s.Target})
+                }
+        }
+        return newAddrs
+}
+
+func (d *dnsResolver) lookupTXT() string {
+        ss, err := d.resolver.LookupTXT(d.ctx, d.host)
+        if err != nil {
+                grpclog.Infof("grpc: failed dns TXT record lookup due to %v.\n", err)
+                return ""
+        }
+        var res string
+        for _, s := range ss {
+                res += s
+        }
+
+        // TXT record must have "grpc_config=" attribute in order to be used as service config.
+        if !strings.HasPrefix(res, txtAttribute) {
+                grpclog.Warningf("grpc: TXT record %v missing %v attribute", res, txtAttribute)
+                return ""
+        }
+        return strings.TrimPrefix(res, txtAttribute)
+}
+
+func (d *dnsResolver) lookupHost() []resolver.Address {
+        var newAddrs []resolver.Address
+        addrs, err := d.resolver.LookupHost(d.ctx, d.host)
+        if err != nil {
+                grpclog.Warningf("grpc: failed dns A record lookup due to %v.\n", err)
+                return nil
+        }
+        for _, a := range addrs {
+                a, ok := formatIP(a)
+                if !ok {
+                        grpclog.Errorf("grpc: failed IP parsing due to %v.\n", err)
+                        continue
+                }
+                addr := a + ":" + d.port
+                newAddrs = append(newAddrs, resolver.Address{Addr: addr})
+        }
+        return newAddrs
+}
+
+func (d *dnsResolver) lookup() ([]resolver.Address, string) {
+        newAddrs := d.lookupSRV()
+        // Support fallback to non-balancer address.
+        newAddrs = append(newAddrs, d.lookupHost()...)
+        if d.disableServiceConfig {
+                return newAddrs, ""
+        }
+        sc := d.lookupTXT()
+        return newAddrs, canaryingSC(sc)
+}
+
+// formatIP returns ok = false if addr is not a valid textual representation of an IP address.
+// If addr is an IPv4 address, return the addr and ok = true.
+// If addr is an IPv6 address, return the addr enclosed in square brackets and ok = true.
+func formatIP(addr string) (addrIP string, ok bool) {
+        ip := net.ParseIP(addr)
+        if ip == nil {
+                return "", false
+        }
+        if ip.To4() != nil {
+                return addr, true
+        }
+        return "[" + addr + "]", true
+}
+
+// parseTarget takes the user input target string and default port, returns formatted host and port info.
+// If target doesn't specify a port, set the port to be the defaultPort.
+// If target is in IPv6 format and host-name is enclosed in sqarue brackets, brackets
+// are strippd when setting the host.
+// examples:
+// target: "www.google.com" defaultPort: "443" returns host: "www.google.com", port: "443"
+// target: "ipv4-host:80" defaultPort: "443" returns host: "ipv4-host", port: "80"
+// target: "[ipv6-host]" defaultPort: "443" returns host: "ipv6-host", port: "443"
+// target: ":80" defaultPort: "443" returns host: "localhost", port: "80"
+func parseTarget(target, defaultPort string) (host, port string, err error) {
+        if target == "" {
+                return "", "", errMissingAddr
+        }
+        if ip := net.ParseIP(target); ip != nil {
+                // target is an IPv4 or IPv6(without brackets) address
+                return target, defaultPort, nil
+        }
+        if host, port, err = net.SplitHostPort(target); err == nil {
+                if port == "" {
+                        // If the port field is empty (target ends with colon), e.g. "[::1]:", this is an error.
+                        return "", "", errEndsWithColon
+                }
+                // target has port, i.e ipv4-host:port, [ipv6-host]:port, host-name:port
+                if host == "" {
+                        // Keep consistent with net.Dial(): If the host is empty, as in ":80", the local system is assumed.
+                        host = "localhost"
+                }
+                return host, port, nil
+        }
+        if host, port, err = net.SplitHostPort(target + ":" + defaultPort); err == nil {
+                // target doesn't have port
+                return host, port, nil
+        }
+        return "", "", fmt.Errorf("invalid target address %v, error info: %v", target, err)
+}
+
+type rawChoice struct {
+        ClientLanguage *[]string        `json:"clientLanguage,omitempty"`
+        Percentage     *int             `json:"percentage,omitempty"`
+        ClientHostName *[]string        `json:"clientHostName,omitempty"`
+        ServiceConfig  *json.RawMessage `json:"serviceConfig,omitempty"`
+}
+
+func containsString(a *[]string, b string) bool {
+        if a == nil {
+                return true
+        }
+        for _, c := range *a {
+                if c == b {
+                        return true
+                }
+        }
+        return false
+}
+
+func chosenByPercentage(a *int) bool {
+        if a == nil {
+                return true
+        }
+        return grpcrand.Intn(100)+1 <= *a
+}
+
+func canaryingSC(js string) string {
+        if js == "" {
+                return ""
+        }
+        var rcs []rawChoice
+        err := json.Unmarshal([]byte(js), &rcs)
+        if err != nil {
+                grpclog.Warningf("grpc: failed to parse service config json string due to %v.\n", err)
+                return ""
+        }
+        cliHostname, err := os.Hostname()
+        if err != nil {
+                grpclog.Warningf("grpc: failed to get client hostname due to %v.\n", err)
+                return ""
+        }
+        var sc string
+        for _, c := range rcs {
+                if !containsString(c.ClientLanguage, golang) ||
+                        !chosenByPercentage(c.Percentage) ||
+                        !containsString(c.ClientHostName, cliHostname) ||
+                        c.ServiceConfig == nil {
+                        continue
+                }
+                sc = string(*c.ServiceConfig)
+                break
+        }
+        return sc
+}
diff --git a/vendor/google.golang.org/grpc/resolver/passthrough/passthrough.go b/vendor/google.golang.org/grpc/resolver/passthrough/passthrough.go
new file mode 100644
index 0000000..b76010d
--- /dev/null
+++ b/vendor/google.golang.org/grpc/resolver/passthrough/passthrough.go
@@ -0,0 +1,57 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package passthrough implements a pass-through resolver. It sends the target
+// name without scheme back to gRPC as resolved address.
+package passthrough
+
+import "google.golang.org/grpc/resolver"
+
+const scheme = "passthrough"
+
+type passthroughBuilder struct{}
+
+func (*passthroughBuilder) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOption) (resolver.Resolver, error) {
+        r := &passthroughResolver{
+                target: target,
+                cc:     cc,
+        }
+        r.start()
+        return r, nil
+}
+
+func (*passthroughBuilder) Scheme() string {
+        return scheme
+}
+
+type passthroughResolver struct {
+        target resolver.Target
+        cc     resolver.ClientConn
+}
+
+func (r *passthroughResolver) start() {
+        r.cc.NewAddress([]resolver.Address{{Addr: r.target.Endpoint}})
+}
+
+func (*passthroughResolver) ResolveNow(o resolver.ResolveNowOption) {}
+
+func (*passthroughResolver) Close() {}
+
+func init() {
+        resolver.Register(&passthroughBuilder{})
+}
diff --git a/vendor/google.golang.org/grpc/resolver/resolver.go b/vendor/google.golang.org/grpc/resolver/resolver.go
new file mode 100644
index 0000000..145cf47
--- /dev/null
+++ b/vendor/google.golang.org/grpc/resolver/resolver.go
@@ -0,0 +1,158 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package resolver defines APIs for name resolution in gRPC.
+// All APIs in this package are experimental.
+package resolver
+
+var (
+        // m is a map from scheme to resolver builder.
+        m = make(map[string]Builder)
+        // defaultScheme is the default scheme to use.
+        defaultScheme = "passthrough"
+)
+
+// TODO(bar) install dns resolver in init(){}.
+
+// Register registers the resolver builder to the resolver map. b.Scheme will be
+// used as the scheme registered with this builder.
+//
+// NOTE: this function must only be called during initialization time (i.e. in
+// an init() function), and is not thread-safe. If multiple Resolvers are
+// registered with the same name, the one registered last will take effect.
+func Register(b Builder) {
+        m[b.Scheme()] = b
+}
+
+// Get returns the resolver builder registered with the given scheme.
+//
+// If no builder is register with the scheme, nil will be returned.
+func Get(scheme string) Builder {
+        if b, ok := m[scheme]; ok {
+                return b
+        }
+        return nil
+}
+
+// SetDefaultScheme sets the default scheme that will be used. The default
+// default scheme is "passthrough".
+//
+// NOTE: this function must only be called during initialization time (i.e. in
+// an init() function), and is not thread-safe. The scheme set last overrides
+// previously set values.
+func SetDefaultScheme(scheme string) {
+        defaultScheme = scheme
+}
+
+// GetDefaultScheme gets the default scheme that will be used.
+func GetDefaultScheme() string {
+        return defaultScheme
+}
+
+// AddressType indicates the address type returned by name resolution.
+type AddressType uint8
+
+const (
+        // Backend indicates the address is for a backend server.
+        Backend AddressType = iota
+        // GRPCLB indicates the address is for a grpclb load balancer.
+        GRPCLB
+)
+
+// Address represents a server the client connects to.
+// This is the EXPERIMENTAL API and may be changed or extended in the future.
+type Address struct {
+        // Addr is the server address on which a connection will be established.
+        Addr string
+        // Type is the type of this address.
+        Type AddressType
+        // ServerName is the name of this address.
+        //
+        // e.g. if Type is GRPCLB, ServerName should be the name of the remote load
+        // balancer, not the name of the backend.
+        ServerName string
+        // Metadata is the information associated with Addr, which may be used
+        // to make load balancing decision.
+        Metadata interface{}
+}
+
+// BuildOption includes additional information for the builder to create
+// the resolver.
+type BuildOption struct {
+        // DisableServiceConfig indicates whether resolver should fetch service config data.
+        DisableServiceConfig bool
+}
+
+// ClientConn contains the callbacks for resolver to notify any updates
+// to the gRPC ClientConn.
+//
+// This interface is to be implemented by gRPC. Users should not need a
+// brand new implementation of this interface. For the situations like
+// testing, the new implementation should embed this interface. This allows
+// gRPC to add new methods to this interface.
+type ClientConn interface {
+        // NewAddress is called by resolver to notify ClientConn a new list
+        // of resolved addresses.
+        // The address list should be the complete list of resolved addresses.
+        NewAddress(addresses []Address)
+        // NewServiceConfig is called by resolver to notify ClientConn a new
+        // service config. The service config should be provided as a json string.
+        NewServiceConfig(serviceConfig string)
+}
+
+// Target represents a target for gRPC, as specified in:
+// https://github.com/grpc/grpc/blob/master/doc/naming.md.
+type Target struct {
+        Scheme    string
+        Authority string
+        Endpoint  string
+}
+
+// Builder creates a resolver that will be used to watch name resolution updates.
+type Builder interface {
+        // Build creates a new resolver for the given target.
+        //
+        // gRPC dial calls Build synchronously, and fails if the returned error is
+        // not nil.
+        Build(target Target, cc ClientConn, opts BuildOption) (Resolver, error)
+        // Scheme returns the scheme supported by this resolver.
+        // Scheme is defined at https://github.com/grpc/grpc/blob/master/doc/naming.md.
+        Scheme() string
+}
+
+// ResolveNowOption includes additional information for ResolveNow.
+type ResolveNowOption struct{}
+
+// Resolver watches for the updates on the specified target.
+// Updates include address updates and service config updates.
+type Resolver interface {
+        // ResolveNow will be called by gRPC to try to resolve the target name
+        // again. It's just a hint, resolver can ignore this if it's not necessary.
+        //
+        // It could be called multiple times concurrently.
+        ResolveNow(ResolveNowOption)
+        // Close closes the resolver.
+        Close()
+}
+
+// UnregisterForTesting removes the resolver builder with the given scheme from the
+// resolver map.
+// This function is for testing only.
+func UnregisterForTesting(scheme string) {
+        delete(m, scheme)
+}
diff --git a/vendor/google.golang.org/grpc/resolver_conn_wrapper.go b/vendor/google.golang.org/grpc/resolver_conn_wrapper.go
new file mode 100644
index 0000000..50991ea
--- /dev/null
+++ b/vendor/google.golang.org/grpc/resolver_conn_wrapper.go
@@ -0,0 +1,155 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package grpc
+
+import (
+        "fmt"
+        "strings"
+
+        "google.golang.org/grpc/grpclog"
+        "google.golang.org/grpc/internal/channelz"
+        "google.golang.org/grpc/resolver"
+)
+
+// ccResolverWrapper is a wrapper on top of cc for resolvers.
+// It implements resolver.ClientConnection interface.
+type ccResolverWrapper struct {
+        cc                 *ClientConn
+        resolver           resolver.Resolver
+        addrCh             chan []resolver.Address
+        scCh               chan string
+        done               chan struct{}
+        lastAddressesCount int
+}
+
+// split2 returns the values from strings.SplitN(s, sep, 2).
+// If sep is not found, it returns ("", "", false) instead.
+func split2(s, sep string) (string, string, bool) {
+        spl := strings.SplitN(s, sep, 2)
+        if len(spl) < 2 {
+                return "", "", false
+        }
+        return spl[0], spl[1], true
+}
+
+// parseTarget splits target into a struct containing scheme, authority and
+// endpoint.
+//
+// If target is not a valid scheme://authority/endpoint, it returns {Endpoint:
+// target}.
+func parseTarget(target string) (ret resolver.Target) {
+        var ok bool
+        ret.Scheme, ret.Endpoint, ok = split2(target, "://")
+        if !ok {
+                return resolver.Target{Endpoint: target}
+        }
+        ret.Authority, ret.Endpoint, ok = split2(ret.Endpoint, "/")
+        if !ok {
+                return resolver.Target{Endpoint: target}
+        }
+        return ret
+}
+
+// newCCResolverWrapper parses cc.target for scheme and gets the resolver
+// builder for this scheme and builds the resolver. The monitoring goroutine
+// for it is not started yet and can be created by calling start().
+//
+// If withResolverBuilder dial option is set, the specified resolver will be
+// used instead.
+func newCCResolverWrapper(cc *ClientConn) (*ccResolverWrapper, error) {
+        rb := cc.dopts.resolverBuilder
+        if rb == nil {
+                return nil, fmt.Errorf("could not get resolver for scheme: %q", cc.parsedTarget.Scheme)
+        }
+
+        ccr := &ccResolverWrapper{
+                cc:     cc,
+                addrCh: make(chan []resolver.Address, 1),
+                scCh:   make(chan string, 1),
+                done:   make(chan struct{}),
+        }
+
+        var err error
+        ccr.resolver, err = rb.Build(cc.parsedTarget, ccr, resolver.BuildOption{DisableServiceConfig: cc.dopts.disableServiceConfig})
+        if err != nil {
+                return nil, err
+        }
+        return ccr, nil
+}
+
+func (ccr *ccResolverWrapper) resolveNow(o resolver.ResolveNowOption) {
+        ccr.resolver.ResolveNow(o)
+}
+
+func (ccr *ccResolverWrapper) close() {
+        ccr.resolver.Close()
+        close(ccr.done)
+}
+
+// NewAddress is called by the resolver implemenetion to send addresses to gRPC.
+func (ccr *ccResolverWrapper) NewAddress(addrs []resolver.Address) {
+        select {
+        case <-ccr.done:
+                return
+        default:
+        }
+        grpclog.Infof("ccResolverWrapper: sending new addresses to cc: %v", addrs)
+        if channelz.IsOn() {
+                ccr.addChannelzTraceEvent(addrs)
+        }
+        ccr.cc.handleResolvedAddrs(addrs, nil)
+}
+
+// NewServiceConfig is called by the resolver implemenetion to send service
+// configs to gRPC.
+func (ccr *ccResolverWrapper) NewServiceConfig(sc string) {
+        select {
+        case <-ccr.done:
+                return
+        default:
+        }
+        grpclog.Infof("ccResolverWrapper: got new service config: %v", sc)
+        ccr.cc.handleServiceConfig(sc)
+}
+
+func (ccr *ccResolverWrapper) addChannelzTraceEvent(addrs []resolver.Address) {
+        if len(addrs) == 0 && ccr.lastAddressesCount != 0 {
+                channelz.AddTraceEvent(ccr.cc.channelzID, &channelz.TraceEventDesc{
+                        Desc:     "Resolver returns an empty address list",
+                        Severity: channelz.CtWarning,
+                })
+        } else if len(addrs) != 0 && ccr.lastAddressesCount == 0 {
+                var s string
+                for i, a := range addrs {
+                        if a.ServerName != "" {
+                                s += a.Addr + "(" + a.ServerName + ")"
+                        } else {
+                                s += a.Addr
+                        }
+                        if i != len(addrs)-1 {
+                                s += " "
+                        }
+                }
+                channelz.AddTraceEvent(ccr.cc.channelzID, &channelz.TraceEventDesc{
+                        Desc:     fmt.Sprintf("Resolver returns a non-empty address list (previous one was empty) %q", s),
+                        Severity: channelz.CtINFO,
+                })
+        }
+        ccr.lastAddressesCount = len(addrs)
+}
diff --git a/vendor/google.golang.org/grpc/rpc_util.go b/vendor/google.golang.org/grpc/rpc_util.go
index 9b9d388..8d0d3dc 100644
--- a/vendor/google.golang.org/grpc/rpc_util.go
+++ b/vendor/google.golang.org/grpc/rpc_util.go
@@ -21,24 +21,31 @@ package grpc
 import (
         "bytes"
         "compress/gzip"
+        "context"
         "encoding/binary"
+        "fmt"
         "io"
         "io/ioutil"
         "math"
+        "net/url"
+        "strings"
         "sync"
         "time"
 
-        "golang.org/x/net/context"
         "google.golang.org/grpc/codes"
         "google.golang.org/grpc/credentials"
+        "google.golang.org/grpc/encoding"
+        "google.golang.org/grpc/encoding/proto"
+        "google.golang.org/grpc/internal/transport"
         "google.golang.org/grpc/metadata"
         "google.golang.org/grpc/peer"
         "google.golang.org/grpc/stats"
         "google.golang.org/grpc/status"
-        "google.golang.org/grpc/transport"
 )
 
 // Compressor defines the interface gRPC uses to compress a message.
+//
+// Deprecated: use package encoding.
 type Compressor interface {
         // Do compresses p into w.
         Do(w io.Writer, p []byte) error
@@ -51,18 +58,39 @@ type gzipCompressor struct {
 }
 
 // NewGZIPCompressor creates a Compressor based on GZIP.
+//
+// Deprecated: use package encoding/gzip.
 func NewGZIPCompressor() Compressor {
+        c, _ := NewGZIPCompressorWithLevel(gzip.DefaultCompression)
+        return c
+}
+
+// NewGZIPCompressorWithLevel is like NewGZIPCompressor but specifies the gzip compression level instead
+// of assuming DefaultCompression.
+//
+// The error returned will be nil if the level is valid.
+//
+// Deprecated: use package encoding/gzip.
+func NewGZIPCompressorWithLevel(level int) (Compressor, error) {
+        if level < gzip.DefaultCompression || level > gzip.BestCompression {
+                return nil, fmt.Errorf("grpc: invalid compression level: %d", level)
+        }
         return &gzipCompressor{
                 pool: sync.Pool{
                         New: func() interface{} {
-                                return gzip.NewWriter(ioutil.Discard)
+                                w, err := gzip.NewWriterLevel(ioutil.Discard, level)
+                                if err != nil {
+                                        panic(err)
+                                }
+                                return w
                         },
                 },
-        }
+        }, nil
 }
 
 func (c *gzipCompressor) Do(w io.Writer, p []byte) error {
         z := c.pool.Get().(*gzip.Writer)
+        defer c.pool.Put(z)
         z.Reset(w)
         if _, err := z.Write(p); err != nil {
                 return err
@@ -75,6 +103,8 @@ func (c *gzipCompressor) Type() string {
 }
 
 // Decompressor defines the interface gRPC uses to decompress a message.
+//
+// Deprecated: use package encoding.
 type Decompressor interface {
         // Do reads the data from r and uncompress them.
         Do(r io.Reader) ([]byte, error)
@@ -87,6 +117,8 @@ type gzipDecompressor struct {
 }
 
 // NewGZIPDecompressor creates a Decompressor based on GZIP.
+//
+// Deprecated: use package encoding/gzip.
 func NewGZIPDecompressor() Decompressor {
         return &gzipDecompressor{}
 }
@@ -121,17 +153,23 @@ func (d *gzipDecompressor) Type() string {
 
 // callInfo contains all related configuration and information about an RPC.
 type callInfo struct {
+        compressorType        string
         failFast              bool
-        headerMD              metadata.MD
-        trailerMD             metadata.MD
-        peer                  *peer.Peer
-        traceInfo             traceInfo // in trace.go
+        stream                ClientStream
         maxReceiveMessageSize *int
         maxSendMessageSize    *int
         creds                 credentials.PerRPCCredentials
+        contentSubtype        string
+        codec                 baseCodec
+        maxRetryRPCBufferSize int
 }
 
-var defaultCallInfo = callInfo{failFast: true}
+func defaultCallInfo() *callInfo {
+        return &callInfo{
+                failFast:              true,
+                maxRetryRPCBufferSize: 256 * 1024, // 256KB
+        }
+}
 
 // CallOption configures a Call before it starts or extracts information from
 // a Call after it completes.
@@ -153,87 +191,267 @@ type EmptyCallOption struct{}
 func (EmptyCallOption) before(*callInfo) error { return nil }
 func (EmptyCallOption) after(*callInfo)        {}
 
-type beforeCall func(c *callInfo) error
-
-func (o beforeCall) before(c *callInfo) error { return o(c) }
-func (o beforeCall) after(c *callInfo)        {}
-
-type afterCall func(c *callInfo)
-
-func (o afterCall) before(c *callInfo) error { return nil }
-func (o afterCall) after(c *callInfo)        { o(c) }
-
 // Header returns a CallOptions that retrieves the header metadata
 // for a unary RPC.
 func Header(md *metadata.MD) CallOption {
-        return afterCall(func(c *callInfo) {
-                *md = c.headerMD
-        })
+        return HeaderCallOption{HeaderAddr: md}
+}
+
+// HeaderCallOption is a CallOption for collecting response header metadata.
+// The metadata field will be populated *after* the RPC completes.
+// This is an EXPERIMENTAL API.
+type HeaderCallOption struct {
+        HeaderAddr *metadata.MD
+}
+
+func (o HeaderCallOption) before(c *callInfo) error { return nil }
+func (o HeaderCallOption) after(c *callInfo) {
+        if c.stream != nil {
+                *o.HeaderAddr, _ = c.stream.Header()
+        }
 }
 
 // Trailer returns a CallOptions that retrieves the trailer metadata
 // for a unary RPC.
 func Trailer(md *metadata.MD) CallOption {
-        return afterCall(func(c *callInfo) {
-                *md = c.trailerMD
-        })
+        return TrailerCallOption{TrailerAddr: md}
+}
+
+// TrailerCallOption is a CallOption for collecting response trailer metadata.
+// The metadata field will be populated *after* the RPC completes.
+// This is an EXPERIMENTAL API.
+type TrailerCallOption struct {
+        TrailerAddr *metadata.MD
+}
+
+func (o TrailerCallOption) before(c *callInfo) error { return nil }
+func (o TrailerCallOption) after(c *callInfo) {
+        if c.stream != nil {
+                *o.TrailerAddr = c.stream.Trailer()
+        }
+}
+
+// Peer returns a CallOption that retrieves peer information for a unary RPC.
+// The peer field will be populated *after* the RPC completes.
+func Peer(p *peer.Peer) CallOption {
+        return PeerCallOption{PeerAddr: p}
 }
 
-// Peer returns a CallOption that retrieves peer information for a
-// unary RPC.
-func Peer(peer *peer.Peer) CallOption {
-        return afterCall(func(c *callInfo) {
-                if c.peer != nil {
-                        *peer = *c.peer
+// PeerCallOption is a CallOption for collecting the identity of the remote
+// peer. The peer field will be populated *after* the RPC completes.
+// This is an EXPERIMENTAL API.
+type PeerCallOption struct {
+        PeerAddr *peer.Peer
+}
+
+func (o PeerCallOption) before(c *callInfo) error { return nil }
+func (o PeerCallOption) after(c *callInfo) {
+        if c.stream != nil {
+                if x, ok := peer.FromContext(c.stream.Context()); ok {
+                        *o.PeerAddr = *x
                 }
-        })
+        }
 }
 
-// FailFast configures the action to take when an RPC is attempted on broken
-// connections or unreachable servers. If failfast is true, the RPC will fail
+// WaitForReady configures the action to take when an RPC is attempted on broken
+// connections or unreachable servers. If waitForReady is false, the RPC will fail
 // immediately. Otherwise, the RPC client will block the call until a
-// connection is available (or the call is canceled or times out) and will retry
-// the call if it fails due to a transient error. Please refer to
+// connection is available (or the call is canceled or times out) and will
+// retry the call if it fails due to a transient error.  gRPC will not retry if
+// data was written to the wire unless the server indicates it did not process
+// the data.  Please refer to
 // https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md.
-// Note: failFast is default to true.
+//
+// By default, RPCs don't "wait for ready".
+func WaitForReady(waitForReady bool) CallOption {
+        return FailFastCallOption{FailFast: !waitForReady}
+}
+
+// FailFast is the opposite of WaitForReady.
+//
+// Deprecated: use WaitForReady.
 func FailFast(failFast bool) CallOption {
-        return beforeCall(func(c *callInfo) error {
-                c.failFast = failFast
-                return nil
-        })
+        return FailFastCallOption{FailFast: failFast}
 }
 
+// FailFastCallOption is a CallOption for indicating whether an RPC should fail
+// fast or not.
+// This is an EXPERIMENTAL API.
+type FailFastCallOption struct {
+        FailFast bool
+}
+
+func (o FailFastCallOption) before(c *callInfo) error {
+        c.failFast = o.FailFast
+        return nil
+}
+func (o FailFastCallOption) after(c *callInfo) {}
+
 // MaxCallRecvMsgSize returns a CallOption which sets the maximum message size the client can receive.
 func MaxCallRecvMsgSize(s int) CallOption {
-        return beforeCall(func(o *callInfo) error {
-                o.maxReceiveMessageSize = &s
-                return nil
-        })
+        return MaxRecvMsgSizeCallOption{MaxRecvMsgSize: s}
+}
+
+// MaxRecvMsgSizeCallOption is a CallOption that indicates the maximum message
+// size the client can receive.
+// This is an EXPERIMENTAL API.
+type MaxRecvMsgSizeCallOption struct {
+        MaxRecvMsgSize int
 }
 
+func (o MaxRecvMsgSizeCallOption) before(c *callInfo) error {
+        c.maxReceiveMessageSize = &o.MaxRecvMsgSize
+        return nil
+}
+func (o MaxRecvMsgSizeCallOption) after(c *callInfo) {}
+
 // MaxCallSendMsgSize returns a CallOption which sets the maximum message size the client can send.
 func MaxCallSendMsgSize(s int) CallOption {
-        return beforeCall(func(o *callInfo) error {
-                o.maxSendMessageSize = &s
-                return nil
-        })
+        return MaxSendMsgSizeCallOption{MaxSendMsgSize: s}
+}
+
+// MaxSendMsgSizeCallOption is a CallOption that indicates the maximum message
+// size the client can send.
+// This is an EXPERIMENTAL API.
+type MaxSendMsgSizeCallOption struct {
+        MaxSendMsgSize int
 }
 
+func (o MaxSendMsgSizeCallOption) before(c *callInfo) error {
+        c.maxSendMessageSize = &o.MaxSendMsgSize
+        return nil
+}
+func (o MaxSendMsgSizeCallOption) after(c *callInfo) {}
+
 // PerRPCCredentials returns a CallOption that sets credentials.PerRPCCredentials
 // for a call.
 func PerRPCCredentials(creds credentials.PerRPCCredentials) CallOption {
-        return beforeCall(func(c *callInfo) error {
-                c.creds = creds
-                return nil
-        })
+        return PerRPCCredsCallOption{Creds: creds}
+}
+
+// PerRPCCredsCallOption is a CallOption that indicates the per-RPC
+// credentials to use for the call.
+// This is an EXPERIMENTAL API.
+type PerRPCCredsCallOption struct {
+        Creds credentials.PerRPCCredentials
+}
+
+func (o PerRPCCredsCallOption) before(c *callInfo) error {
+        c.creds = o.Creds
+        return nil
+}
+func (o PerRPCCredsCallOption) after(c *callInfo) {}
+
+// UseCompressor returns a CallOption which sets the compressor used when
+// sending the request.  If WithCompressor is also set, UseCompressor has
+// higher priority.
+//
+// This API is EXPERIMENTAL.
+func UseCompressor(name string) CallOption {
+        return CompressorCallOption{CompressorType: name}
+}
+
+// CompressorCallOption is a CallOption that indicates the compressor to use.
+// This is an EXPERIMENTAL API.
+type CompressorCallOption struct {
+        CompressorType string
+}
+
+func (o CompressorCallOption) before(c *callInfo) error {
+        c.compressorType = o.CompressorType
+        return nil
+}
+func (o CompressorCallOption) after(c *callInfo) {}
+
+// CallContentSubtype returns a CallOption that will set the content-subtype
+// for a call. For example, if content-subtype is "json", the Content-Type over
+// the wire will be "application/grpc+json". The content-subtype is converted
+// to lowercase before being included in Content-Type. See Content-Type on
+// https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#requests for
+// more details.
+//
+// If CallCustomCodec is not also used, the content-subtype will be used to
+// look up the Codec to use in the registry controlled by RegisterCodec. See
+// the documentation on RegisterCodec for details on registration. The lookup
+// of content-subtype is case-insensitive. If no such Codec is found, the call
+// will result in an error with code codes.Internal.
+//
+// If CallCustomCodec is also used, that Codec will be used for all request and
+// response messages, with the content-subtype set to the given contentSubtype
+// here for requests.
+func CallContentSubtype(contentSubtype string) CallOption {
+        return ContentSubtypeCallOption{ContentSubtype: strings.ToLower(contentSubtype)}
+}
+
+// ContentSubtypeCallOption is a CallOption that indicates the content-subtype
+// used for marshaling messages.
+// This is an EXPERIMENTAL API.
+type ContentSubtypeCallOption struct {
+        ContentSubtype string
+}
+
+func (o ContentSubtypeCallOption) before(c *callInfo) error {
+        c.contentSubtype = o.ContentSubtype
+        return nil
+}
+func (o ContentSubtypeCallOption) after(c *callInfo) {}
+
+// CallCustomCodec returns a CallOption that will set the given Codec to be
+// used for all request and response messages for a call. The result of calling
+// String() will be used as the content-subtype in a case-insensitive manner.
+//
+// See Content-Type on
+// https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#requests for
+// more details. Also see the documentation on RegisterCodec and
+// CallContentSubtype for more details on the interaction between Codec and
+// content-subtype.
+//
+// This function is provided for advanced users; prefer to use only
+// CallContentSubtype to select a registered codec instead.
+func CallCustomCodec(codec Codec) CallOption {
+        return CustomCodecCallOption{Codec: codec}
+}
+
+// CustomCodecCallOption is a CallOption that indicates the codec used for
+// marshaling messages.
+// This is an EXPERIMENTAL API.
+type CustomCodecCallOption struct {
+        Codec Codec
+}
+
+func (o CustomCodecCallOption) before(c *callInfo) error {
+        c.codec = o.Codec
+        return nil
+}
+func (o CustomCodecCallOption) after(c *callInfo) {}
+
+// MaxRetryRPCBufferSize returns a CallOption that limits the amount of memory
+// used for buffering this RPC's requests for retry purposes.
+//
+// This API is EXPERIMENTAL.
+func MaxRetryRPCBufferSize(bytes int) CallOption {
+        return MaxRetryRPCBufferSizeCallOption{bytes}
+}
+
+// MaxRetryRPCBufferSizeCallOption is a CallOption indicating the amount of
+// memory to be used for caching this RPC for retry purposes.
+// This is an EXPERIMENTAL API.
+type MaxRetryRPCBufferSizeCallOption struct {
+        MaxRetryRPCBufferSize int
+}
+
+func (o MaxRetryRPCBufferSizeCallOption) before(c *callInfo) error {
+        c.maxRetryRPCBufferSize = o.MaxRetryRPCBufferSize
+        return nil
 }
+func (o MaxRetryRPCBufferSizeCallOption) after(c *callInfo) {}
 
 // The format of the payload: compressed or not?
 type payloadFormat uint8
 
 const (
-        compressionNone payloadFormat = iota // no compression
-        compressionMade
+        compressionNone payloadFormat = 0 // no compression
+        compressionMade payloadFormat = 1 // compressed
 )
 
 // parser reads complete gRPC messages from the underlying reader.
@@ -243,8 +461,8 @@ type parser struct {
         // error types.
         r io.Reader
 
-        // The header of a gRPC message. Find more detail
-        // at https://grpc.io/docs/guides/wire.html.
+        // The header of a gRPC message. Find more detail at
+        // https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md
         header [5]byte
 }
 
@@ -257,7 +475,7 @@ type parser struct {
 //   * io.EOF, when no messages remain
 //   * io.ErrUnexpectedEOF
 //   * of type transport.ConnectionError
-//   * of type transport.StreamError
+//   * an error from the status package
 // No other error values or types must be returned, which also means
 // that the underlying io.Reader must not return an incompatible
 // error.
@@ -272,8 +490,11 @@ func (p *parser) recvMsg(maxReceiveMessageSize int) (pf payloadFormat, msg []byt
         if length == 0 {
                 return pf, nil, nil
         }
-        if length > uint32(maxReceiveMessageSize) {
-                return 0, nil, Errorf(codes.ResourceExhausted, "grpc: received message larger than max (%d vs. %d)", length, maxReceiveMessageSize)
+        if int64(length) > int64(maxInt) {
+                return 0, nil, status.Errorf(codes.ResourceExhausted, "grpc: received message larger than max length allowed on current machine (%d vs. %d)", length, maxInt)
+        }
+        if int(length) > maxReceiveMessageSize {
+                return 0, nil, status.Errorf(codes.ResourceExhausted, "grpc: received message larger than max (%d vs. %d)", length, maxReceiveMessageSize)
         }
         // TODO(bradfitz,zhaoq): garbage. reuse buffer after proto decoding instead
         // of making it for each message:
@@ -287,120 +508,173 @@ func (p *parser) recvMsg(maxReceiveMessageSize int) (pf payloadFormat, msg []byt
         return pf, msg, nil
 }
 
-// encode serializes msg and prepends the message header. If msg is nil, it
-// generates the message header of 0 message length.
-func encode(c Codec, msg interface{}, cp Compressor, cbuf *bytes.Buffer, outPayload *stats.OutPayload) ([]byte, error) {
-        var (
-                b      []byte
-                length uint
-        )
-        if msg != nil {
-                var err error
-                // TODO(zhaoq): optimize to reduce memory alloc and copying.
-                b, err = c.Marshal(msg)
+// encode serializes msg and returns a buffer containing the message, or an
+// error if it is too large to be transmitted by grpc.  If msg is nil, it
+// generates an empty message.
+func encode(c baseCodec, msg interface{}) ([]byte, error) {
+        if msg == nil { // NOTE: typed nils will not be caught by this check
+                return nil, nil
+        }
+        b, err := c.Marshal(msg)
+        if err != nil {
+                return nil, status.Errorf(codes.Internal, "grpc: error while marshaling: %v", err.Error())
+        }
+        if uint(len(b)) > math.MaxUint32 {
+                return nil, status.Errorf(codes.ResourceExhausted, "grpc: message too large (%d bytes)", len(b))
+        }
+        return b, nil
+}
+
+// compress returns the input bytes compressed by compressor or cp.  If both
+// compressors are nil, returns nil.
+//
+// TODO(dfawley): eliminate cp parameter by wrapping Compressor in an encoding.Compressor.
+func compress(in []byte, cp Compressor, compressor encoding.Compressor) ([]byte, error) {
+        if compressor == nil && cp == nil {
+                return nil, nil
+        }
+        wrapErr := func(err error) error {
+                return status.Errorf(codes.Internal, "grpc: error while compressing: %v", err.Error())
+        }
+        cbuf := &bytes.Buffer{}
+        if compressor != nil {
+                z, err := compressor.Compress(cbuf)
                 if err != nil {
-                        return nil, Errorf(codes.Internal, "grpc: error while marshaling: %v", err.Error())
+                        return nil, wrapErr(err)
                 }
-                if outPayload != nil {
-                        outPayload.Payload = msg
-                        // TODO truncate large payload.
-                        outPayload.Data = b
-                        outPayload.Length = len(b)
+                if _, err := z.Write(in); err != nil {
+                        return nil, wrapErr(err)
                 }
-                if cp != nil {
-                        if err := cp.Do(cbuf, b); err != nil {
-                                return nil, Errorf(codes.Internal, "grpc: error while compressing: %v", err.Error())
-                        }
-                        b = cbuf.Bytes()
+                if err := z.Close(); err != nil {
+                        return nil, wrapErr(err)
+                }
+        } else {
+                if err := cp.Do(cbuf, in); err != nil {
+                        return nil, wrapErr(err)
                 }
-                length = uint(len(b))
-        }
-        if length > math.MaxUint32 {
-                return nil, Errorf(codes.ResourceExhausted, "grpc: message too large (%d bytes)", length)
         }
+        return cbuf.Bytes(), nil
+}
 
-        const (
-                payloadLen = 1
-                sizeLen    = 4
-        )
-
-        var buf = make([]byte, payloadLen+sizeLen+len(b))
+const (
+        payloadLen = 1
+        sizeLen    = 4
+        headerLen  = payloadLen + sizeLen
+)
 
-        // Write payload format
-        if cp == nil {
-                buf[0] = byte(compressionNone)
+// msgHeader returns a 5-byte header for the message being transmitted and the
+// payload, which is compData if non-nil or data otherwise.
+func msgHeader(data, compData []byte) (hdr []byte, payload []byte) {
+        hdr = make([]byte, headerLen)
+        if compData != nil {
+                hdr[0] = byte(compressionMade)
+                data = compData
         } else {
-                buf[0] = byte(compressionMade)
+                hdr[0] = byte(compressionNone)
         }
-        // Write length of b into buf
-        binary.BigEndian.PutUint32(buf[1:], uint32(length))
-        // Copy encoded msg to buf
-        copy(buf[5:], b)
 
-        if outPayload != nil {
-                outPayload.WireLength = len(buf)
-        }
+        // Write length of payload into buf
+        binary.BigEndian.PutUint32(hdr[payloadLen:], uint32(len(data)))
+        return hdr, data
+}
 
-        return buf, nil
+func outPayload(client bool, msg interface{}, data, payload []byte, t time.Time) *stats.OutPayload {
+        return &stats.OutPayload{
+                Client:     client,
+                Payload:    msg,
+                Data:       data,
+                Length:     len(data),
+                WireLength: len(payload) + headerLen,
+                SentTime:   t,
+        }
 }
 
-func checkRecvPayload(pf payloadFormat, recvCompress string, dc Decompressor) error {
+func checkRecvPayload(pf payloadFormat, recvCompress string, haveCompressor bool) *status.Status {
         switch pf {
         case compressionNone:
         case compressionMade:
-                if dc == nil || recvCompress != dc.Type() {
-                        return Errorf(codes.Unimplemented, "grpc: Decompressor is not installed for grpc-encoding %q", recvCompress)
+                if recvCompress == "" || recvCompress == encoding.Identity {
+                        return status.New(codes.Internal, "grpc: compressed flag set with identity or empty encoding")
+                }
+                if !haveCompressor {
+                        return status.Newf(codes.Unimplemented, "grpc: Decompressor is not installed for grpc-encoding %q", recvCompress)
                 }
         default:
-                return Errorf(codes.Internal, "grpc: received unexpected payload format %d", pf)
+                return status.Newf(codes.Internal, "grpc: received unexpected payload format %d", pf)
         }
         return nil
 }
 
-func recv(p *parser, c Codec, s *transport.Stream, dc Decompressor, m interface{}, maxReceiveMessageSize int, inPayload *stats.InPayload) error {
+type payloadInfo struct {
+        wireLength        int // The compressed length got from wire.
+        uncompressedBytes []byte
+}
+
+func recvAndDecompress(p *parser, s *transport.Stream, dc Decompressor, maxReceiveMessageSize int, payInfo *payloadInfo, compressor encoding.Compressor) ([]byte, error) {
         pf, d, err := p.recvMsg(maxReceiveMessageSize)
         if err != nil {
-                return err
+                return nil, err
         }
-        if inPayload != nil {
-                inPayload.WireLength = len(d)
+        if payInfo != nil {
+                payInfo.wireLength = len(d)
         }
-        if err := checkRecvPayload(pf, s.RecvCompress(), dc); err != nil {
-                return err
+
+        if st := checkRecvPayload(pf, s.RecvCompress(), compressor != nil || dc != nil); st != nil {
+                return nil, st.Err()
         }
+
         if pf == compressionMade {
-                d, err = dc.Do(bytes.NewReader(d))
-                if err != nil {
-                        return Errorf(codes.Internal, "grpc: failed to decompress the received message %v", err)
+                // To match legacy behavior, if the decompressor is set by WithDecompressor or RPCDecompressor,
+                // use this decompressor as the default.
+                if dc != nil {
+                        d, err = dc.Do(bytes.NewReader(d))
+                        if err != nil {
+                                return nil, status.Errorf(codes.Internal, "grpc: failed to decompress the received message %v", err)
+                        }
+                } else {
+                        dcReader, err := compressor.Decompress(bytes.NewReader(d))
+                        if err != nil {
+                                return nil, status.Errorf(codes.Internal, "grpc: failed to decompress the received message %v", err)
+                        }
+                        d, err = ioutil.ReadAll(dcReader)
+                        if err != nil {
+                                return nil, status.Errorf(codes.Internal, "grpc: failed to decompress the received message %v", err)
+                        }
                 }
         }
         if len(d) > maxReceiveMessageSize {
                 // TODO: Revisit the error code. Currently keep it consistent with java
                 // implementation.
-                return Errorf(codes.ResourceExhausted, "grpc: received message larger than max (%d vs. %d)", len(d), maxReceiveMessageSize)
+                return nil, status.Errorf(codes.ResourceExhausted, "grpc: received message larger than max (%d vs. %d)", len(d), maxReceiveMessageSize)
+        }
+        return d, nil
+}
+
+// For the two compressor parameters, both should not be set, but if they are,
+// dc takes precedence over compressor.
+// TODO(dfawley): wrap the old compressor/decompressor using the new API?
+func recv(p *parser, c baseCodec, s *transport.Stream, dc Decompressor, m interface{}, maxReceiveMessageSize int, payInfo *payloadInfo, compressor encoding.Compressor) error {
+        d, err := recvAndDecompress(p, s, dc, maxReceiveMessageSize, payInfo, compressor)
+        if err != nil {
+                return err
         }
         if err := c.Unmarshal(d, m); err != nil {
-                return Errorf(codes.Internal, "grpc: failed to unmarshal the received message %v", err)
+                return status.Errorf(codes.Internal, "grpc: failed to unmarshal the received message %v", err)
         }
-        if inPayload != nil {
-                inPayload.RecvTime = time.Now()
-                inPayload.Payload = m
-                // TODO truncate large payload.
-                inPayload.Data = d
-                inPayload.Length = len(d)
+        if payInfo != nil {
+                payInfo.uncompressedBytes = d
         }
         return nil
 }
 
 type rpcInfo struct {
-        bytesSent     bool
-        bytesReceived bool
+        failfast bool
 }
 
 type rpcInfoContextKey struct{}
 
-func newContextWithRPCInfo(ctx context.Context) context.Context {
-        return context.WithValue(ctx, rpcInfoContextKey{}, &rpcInfo{})
+func newContextWithRPCInfo(ctx context.Context, failfast bool) context.Context {
+        return context.WithValue(ctx, rpcInfoContextKey{}, &rpcInfo{failfast: failfast})
 }
 
 func rpcInfoFromContext(ctx context.Context) (s *rpcInfo, ok bool) {
@@ -408,117 +682,135 @@ func rpcInfoFromContext(ctx context.Context) (s *rpcInfo, ok bool) {
         return
 }
 
-func updateRPCInfoInContext(ctx context.Context, s rpcInfo) {
-        if ss, ok := rpcInfoFromContext(ctx); ok {
-                *ss = s
-        }
-        return
-}
-
 // Code returns the error code for err if it was produced by the rpc system.
 // Otherwise, it returns codes.Unknown.
 //
-// Deprecated; use status.FromError and Code method instead.
+// Deprecated: use status.Code instead.
 func Code(err error) codes.Code {
-        if s, ok := status.FromError(err); ok {
-                return s.Code()
-        }
-        return codes.Unknown
+        return status.Code(err)
 }
 
 // ErrorDesc returns the error description of err if it was produced by the rpc system.
 // Otherwise, it returns err.Error() or empty string when err is nil.
 //
-// Deprecated; use status.FromError and Message method instead.
+// Deprecated: use status.Convert and Message method instead.
 func ErrorDesc(err error) string {
-        if s, ok := status.FromError(err); ok {
-                return s.Message()
-        }
-        return err.Error()
+        return status.Convert(err).Message()
 }
 
 // Errorf returns an error containing an error code and a description;
 // Errorf returns nil if c is OK.
 //
-// Deprecated; use status.Errorf instead.
+// Deprecated: use status.Errorf instead.
 func Errorf(c codes.Code, format string, a ...interface{}) error {
         return status.Errorf(c, format, a...)
 }
 
-// MethodConfig defines the configuration recommended by the service providers for a
-// particular method.
-// This is EXPERIMENTAL and subject to change.
-type MethodConfig struct {
-        // WaitForReady indicates whether RPCs sent to this method should wait until
-        // the connection is ready by default (!failfast). The value specified via the
-        // gRPC client API will override the value set here.
-        WaitForReady *bool
-        // Timeout is the default timeout for RPCs sent to this method. The actual
-        // deadline used will be the minimum of the value specified here and the value
-        // set by the application via the gRPC client API.  If either one is not set,
-        // then the other will be used.  If neither is set, then the RPC has no deadline.
-        Timeout *time.Duration
-        // MaxReqSize is the maximum allowed payload size for an individual request in a
-        // stream (client->server) in bytes. The size which is measured is the serialized
-        // payload after per-message compression (but before stream compression) in bytes.
-        // The actual value used is the minumum of the value specified here and the value set
-        // by the application via the gRPC client API. If either one is not set, then the other
-        // will be used.  If neither is set, then the built-in default is used.
-        MaxReqSize *int
-        // MaxRespSize is the maximum allowed payload size for an individual response in a
-        // stream (server->client) in bytes.
-        MaxRespSize *int
-}
-
-// ServiceConfig is provided by the service provider and contains parameters for how
-// clients that connect to the service should behave.
-// This is EXPERIMENTAL and subject to change.
-type ServiceConfig struct {
-        // LB is the load balancer the service providers recommends. The balancer specified
-        // via grpc.WithBalancer will override this.
-        LB Balancer
-        // Methods contains a map for the methods in this service.
-        // If there is an exact match for a method (i.e. /service/method) in the map, use the corresponding MethodConfig.
-        // If there's no exact match, look for the default config for the service (/service/) and use the corresponding MethodConfig if it exists.
-        // Otherwise, the method has no MethodConfig to use.
-        Methods map[string]MethodConfig
-}
-
-func min(a, b *int) *int {
-        if *a < *b {
-                return a
-        }
-        return b
-}
-
-func getMaxSize(mcMax, doptMax *int, defaultVal int) *int {
-        if mcMax == nil && doptMax == nil {
-                return &defaultVal
-        }
-        if mcMax != nil && doptMax != nil {
-                return min(mcMax, doptMax)
-        }
-        if mcMax != nil {
-                return mcMax
-        }
-        return doptMax
-}
-
-// SupportPackageIsVersion3 is referenced from generated protocol buffer files.
-// The latest support package version is 4.
-// SupportPackageIsVersion3 is kept for compability. It will be removed in the
-// next support package version update.
-const SupportPackageIsVersion3 = true
-
-// SupportPackageIsVersion4 is referenced from generated protocol buffer files
-// to assert that that code is compatible with this version of the grpc package.
-//
-// This constant may be renamed in the future if a change in the generated code
-// requires a synchronised update of grpc-go and protoc-gen-go. This constant
-// should not be referenced from any other code.
-const SupportPackageIsVersion4 = true
+// toRPCErr converts an error into an error from the status package.
+func toRPCErr(err error) error {
+        if err == nil || err == io.EOF {
+                return err
+        }
+        if err == io.ErrUnexpectedEOF {
+                return status.Error(codes.Internal, err.Error())
+        }
+        if _, ok := status.FromError(err); ok {
+                return err
+        }
+        switch e := err.(type) {
+        case transport.ConnectionError:
+                return status.Error(codes.Unavailable, e.Desc)
+        default:
+                switch err {
+                case context.DeadlineExceeded:
+                        return status.Error(codes.DeadlineExceeded, err.Error())
+                case context.Canceled:
+                        return status.Error(codes.Canceled, err.Error())
+                }
+        }
+        return status.Error(codes.Unknown, err.Error())
+}
 
-// Version is the current grpc version.
-const Version = "1.6.0-dev"
+// setCallInfoCodec should only be called after CallOptions have been applied.
+func setCallInfoCodec(c *callInfo) error {
+        if c.codec != nil {
+                // codec was already set by a CallOption; use it.
+                return nil
+        }
+
+        if c.contentSubtype == "" {
+                // No codec specified in CallOptions; use proto by default.
+                c.codec = encoding.GetCodec(proto.Name)
+                return nil
+        }
+
+        // c.contentSubtype is already lowercased in CallContentSubtype
+        c.codec = encoding.GetCodec(c.contentSubtype)
+        if c.codec == nil {
+                return status.Errorf(codes.Internal, "no codec registered for content-subtype %s", c.contentSubtype)
+        }
+        return nil
+}
+
+// parseDialTarget returns the network and address to pass to dialer
+func parseDialTarget(target string) (net string, addr string) {
+        net = "tcp"
+
+        m1 := strings.Index(target, ":")
+        m2 := strings.Index(target, ":/")
+
+        // handle unix:addr which will fail with url.Parse
+        if m1 >= 0 && m2 < 0 {
+                if n := target[0:m1]; n == "unix" {
+                        net = n
+                        addr = target[m1+1:]
+                        return net, addr
+                }
+        }
+        if m2 >= 0 {
+                t, err := url.Parse(target)
+                if err != nil {
+                        return net, target
+                }
+                scheme := t.Scheme
+                addr = t.Path
+                if scheme == "unix" {
+                        net = scheme
+                        if addr == "" {
+                                addr = t.Host
+                        }
+                        return net, addr
+                }
+        }
+
+        return net, target
+}
+
+// channelzData is used to store channelz related data for ClientConn, addrConn and Server.
+// These fields cannot be embedded in the original structs (e.g. ClientConn), since to do atomic
+// operation on int64 variable on 32-bit machine, user is responsible to enforce memory alignment.
+// Here, by grouping those int64 fields inside a struct, we are enforcing the alignment.
+type channelzData struct {
+        callsStarted   int64
+        callsFailed    int64
+        callsSucceeded int64
+        // lastCallStartedTime stores the timestamp that last call starts. It is of int64 type instead of
+        // time.Time since it's more costly to atomically update time.Time variable than int64 variable.
+        lastCallStartedTime int64
+}
+
+// The SupportPackageIsVersion variables are referenced from generated protocol
+// buffer files to ensure compatibility with the gRPC version used.  The latest
+// support package version is 5.
+//
+// Older versions are kept for compatibility. They may be removed if
+// compatibility cannot be maintained.
+//
+// These constants should not be referenced from any other code.
+const (
+        SupportPackageIsVersion3 = true
+        SupportPackageIsVersion4 = true
+        SupportPackageIsVersion5 = true
+)
 
 const grpcUA = "grpc-go/" + Version
diff --git a/vendor/google.golang.org/grpc/server.go b/vendor/google.golang.org/grpc/server.go
index 42733e2..d705d7a 100644
--- a/vendor/google.golang.org/grpc/server.go
+++ b/vendor/google.golang.org/grpc/server.go
@@ -19,36 +19,41 @@
 package grpc
 
 import (
-        "bytes"
+        "context"
         "errors"
         "fmt"
         "io"
+        "math"
         "net"
         "net/http"
         "reflect"
         "runtime"
         "strings"
         "sync"
+        "sync/atomic"
         "time"
 
-        "golang.org/x/net/context"
-        "golang.org/x/net/http2"
         "golang.org/x/net/trace"
+
         "google.golang.org/grpc/codes"
         "google.golang.org/grpc/credentials"
+        "google.golang.org/grpc/encoding"
+        "google.golang.org/grpc/encoding/proto"
         "google.golang.org/grpc/grpclog"
-        "google.golang.org/grpc/internal"
+        "google.golang.org/grpc/internal/binarylog"
+        "google.golang.org/grpc/internal/channelz"
+        "google.golang.org/grpc/internal/transport"
         "google.golang.org/grpc/keepalive"
         "google.golang.org/grpc/metadata"
+        "google.golang.org/grpc/peer"
         "google.golang.org/grpc/stats"
         "google.golang.org/grpc/status"
         "google.golang.org/grpc/tap"
-        "google.golang.org/grpc/transport"
 )
 
 const (
         defaultServerMaxReceiveMessageSize = 1024 * 1024 * 4
-        defaultServerMaxSendMessageSize    = 1024 * 1024 * 4
+        defaultServerMaxSendMessageSize    = math.MaxInt32
 )
 
 type methodHandler func(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor UnaryServerInterceptor) (interface{}, error)
@@ -88,18 +93,24 @@ type Server struct {
         conns  map[io.Closer]bool
         serve  bool
         drain  bool
-        ctx    context.Context
-        cancel context.CancelFunc
-        // A CondVar to let GracefulStop() blocks until all the pending RPCs are finished
-        // and all the transport goes away.
-        cv     *sync.Cond
+        cv     *sync.Cond          // signaled when connections close for GracefulStop
         m      map[string]*service // service name -> service info
         events trace.EventLog
+
+        quit               chan struct{}
+        done               chan struct{}
+        quitOnce           sync.Once
+        doneOnce           sync.Once
+        channelzRemoveOnce sync.Once
+        serveWG            sync.WaitGroup // counts active Serve goroutines for GracefulStop
+
+        channelzID int64 // channelz unique identification number
+        czData     *channelzData
 }
 
 type options struct {
         creds                 credentials.TransportCredentials
-        codec                 Codec
+        codec                 baseCodec
         cp                    Compressor
         dc                    Decompressor
         unaryInt              UnaryServerInterceptor
@@ -109,22 +120,50 @@ type options struct {
         maxConcurrentStreams  uint32
         maxReceiveMessageSize int
         maxSendMessageSize    int
-        useHandlerImpl        bool // use http.Handler-based server
         unknownStreamDesc     *StreamDesc
         keepaliveParams       keepalive.ServerParameters
         keepalivePolicy       keepalive.EnforcementPolicy
         initialWindowSize     int32
         initialConnWindowSize int32
+        writeBufferSize       int
+        readBufferSize        int
+        connectionTimeout     time.Duration
+        maxHeaderListSize     *uint32
 }
 
 var defaultServerOptions = options{
         maxReceiveMessageSize: defaultServerMaxReceiveMessageSize,
         maxSendMessageSize:    defaultServerMaxSendMessageSize,
+        connectionTimeout:     120 * time.Second,
+        writeBufferSize:       defaultWriteBufSize,
+        readBufferSize:        defaultReadBufSize,
 }
 
 // A ServerOption sets options such as credentials, codec and keepalive parameters, etc.
 type ServerOption func(*options)
 
+// WriteBufferSize determines how much data can be batched before doing a write on the wire.
+// The corresponding memory allocation for this buffer will be twice the size to keep syscalls low.
+// The default value for this buffer is 32KB.
+// Zero will disable the write buffer such that each write will be on underlying connection.
+// Note: A Send call may not directly translate to a write.
+func WriteBufferSize(s int) ServerOption {
+        return func(o *options) {
+                o.writeBufferSize = s
+        }
+}
+
+// ReadBufferSize lets you set the size of read buffer, this determines how much data can be read at most
+// for one read syscall.
+// The default value for this buffer is 32KB.
+// Zero will disable read buffer for a connection so data framer can access the underlying
+// conn directly.
+func ReadBufferSize(s int) ServerOption {
+        return func(o *options) {
+                o.readBufferSize = s
+        }
+}
+
 // InitialWindowSize returns a ServerOption that sets window size for stream.
 // The lower bound for window size is 64K and any value smaller than that will be ignored.
 func InitialWindowSize(s int32) ServerOption {
@@ -156,20 +195,32 @@ func KeepaliveEnforcementPolicy(kep keepalive.EnforcementPolicy) ServerOption {
 }
 
 // CustomCodec returns a ServerOption that sets a codec for message marshaling and unmarshaling.
+//
+// This will override any lookups by content-subtype for Codecs registered with RegisterCodec.
 func CustomCodec(codec Codec) ServerOption {
         return func(o *options) {
                 o.codec = codec
         }
 }
 
-// RPCCompressor returns a ServerOption that sets a compressor for outbound messages.
+// RPCCompressor returns a ServerOption that sets a compressor for outbound
+// messages.  For backward compatibility, all outbound messages will be sent
+// using this compressor, regardless of incoming message compression.  By
+// default, server messages will be sent using the same compressor with which
+// request messages were sent.
+//
+// Deprecated: use encoding.RegisterCompressor instead.
 func RPCCompressor(cp Compressor) ServerOption {
         return func(o *options) {
                 o.cp = cp
         }
 }
 
-// RPCDecompressor returns a ServerOption that sets a decompressor for inbound messages.
+// RPCDecompressor returns a ServerOption that sets a decompressor for inbound
+// messages.  It has higher priority than decompressors registered via
+// encoding.RegisterCompressor.
+//
+// Deprecated: use encoding.RegisterCompressor instead.
 func RPCDecompressor(dc Decompressor) ServerOption {
         return func(o *options) {
                 o.dc = dc
@@ -177,7 +228,9 @@ func RPCDecompressor(dc Decompressor) ServerOption {
 }
 
 // MaxMsgSize returns a ServerOption to set the max message size in bytes the server can receive.
-// If this is not set, gRPC uses the default limit. Deprecated: use MaxRecvMsgSize instead.
+// If this is not set, gRPC uses the default limit.
+//
+// Deprecated: use MaxRecvMsgSize instead.
 func MaxMsgSize(m int) ServerOption {
         return MaxRecvMsgSize(m)
 }
@@ -259,7 +312,7 @@ func StatsHandler(h stats.Handler) ServerOption {
 // handler that will be invoked instead of returning the "unimplemented" gRPC
 // error whenever a request is received for an unregistered service or method.
 // The handling function has full access to the Context of the request and the
-// stream, and the invocation passes through interceptors.
+// stream, and the invocation bypasses interceptors.
 func UnknownServiceHandler(streamHandler StreamHandler) ServerOption {
         return func(o *options) {
                 o.unknownStreamDesc = &StreamDesc{
@@ -272,6 +325,26 @@ func UnknownServiceHandler(streamHandler StreamHandler) ServerOption {
         }
 }
 
+// ConnectionTimeout returns a ServerOption that sets the timeout for
+// connection establishment (up to and including HTTP/2 handshaking) for all
+// new connections.  If this is not set, the default is 120 seconds.  A zero or
+// negative value will result in an immediate timeout.
+//
+// This API is EXPERIMENTAL.
+func ConnectionTimeout(d time.Duration) ServerOption {
+        return func(o *options) {
+                o.connectionTimeout = d
+        }
+}
+
+// MaxHeaderListSize returns a ServerOption that sets the max (uncompressed) size
+// of header list that the server is prepared to accept.
+func MaxHeaderListSize(s uint32) ServerOption {
+        return func(o *options) {
+                o.maxHeaderListSize = &s
+        }
+}
+
 // NewServer creates a gRPC server which has no service registered and has not
 // started to accept requests yet.
 func NewServer(opt ...ServerOption) *Server {
@@ -279,22 +352,24 @@ func NewServer(opt ...ServerOption) *Server {
         for _, o := range opt {
                 o(&opts)
         }
-        if opts.codec == nil {
-                // Set the default codec.
-                opts.codec = protoCodec{}
-        }
         s := &Server{
-                lis:   make(map[net.Listener]bool),
-                opts:  opts,
-                conns: make(map[io.Closer]bool),
-                m:     make(map[string]*service),
+                lis:    make(map[net.Listener]bool),
+                opts:   opts,
+                conns:  make(map[io.Closer]bool),
+                m:      make(map[string]*service),
+                quit:   make(chan struct{}),
+                done:   make(chan struct{}),
+                czData: new(channelzData),
         }
         s.cv = sync.NewCond(&s.mu)
-        s.ctx, s.cancel = context.WithCancel(context.Background())
         if EnableTracing {
                 _, file, line, _ := runtime.Caller(1)
                 s.events = trace.NewEventLog("grpc.Server", fmt.Sprintf("%s:%d", file, line))
         }
+
+        if channelz.IsOn() {
+                s.channelzID = channelz.RegisterServer(&channelzServer{s}, "")
+        }
         return s
 }
 
@@ -399,11 +474,9 @@ func (s *Server) GetServiceInfo() map[string]ServiceInfo {
         return ret
 }
 
-var (
-        // ErrServerStopped indicates that the operation is now illegal because of
-        // the server being stopped.
-        ErrServerStopped = errors.New("grpc: the server has been stopped")
-)
+// ErrServerStopped indicates that the operation is now illegal because of
+// the server being stopped.
+var ErrServerStopped = errors.New("grpc: the server has been stopped")
 
 func (s *Server) useTransportAuthenticator(rawConn net.Conn) (net.Conn, credentials.AuthInfo, error) {
         if s.opts.creds == nil {
@@ -412,28 +485,67 @@ func (s *Server) useTransportAuthenticator(rawConn net.Conn) (net.Conn, credenti
         return s.opts.creds.ServerHandshake(rawConn)
 }
 
+type listenSocket struct {
+        net.Listener
+        channelzID int64
+}
+
+func (l *listenSocket) ChannelzMetric() *channelz.SocketInternalMetric {
+        return &channelz.SocketInternalMetric{
+                SocketOptions: channelz.GetSocketOption(l.Listener),
+                LocalAddr:     l.Listener.Addr(),
+        }
+}
+
+func (l *listenSocket) Close() error {
+        err := l.Listener.Close()
+        if channelz.IsOn() {
+                channelz.RemoveEntry(l.channelzID)
+        }
+        return err
+}
+
 // Serve accepts incoming connections on the listener lis, creating a new
 // ServerTransport and service goroutine for each. The service goroutines
 // read gRPC requests and then call the registered handlers to reply to them.
 // Serve returns when lis.Accept fails with fatal errors.  lis will be closed when
 // this method returns.
-// Serve always returns non-nil error.
+// Serve will return a non-nil error unless Stop or GracefulStop is called.
 func (s *Server) Serve(lis net.Listener) error {
         s.mu.Lock()
         s.printf("serving")
         s.serve = true
         if s.lis == nil {
+                // Serve called after Stop or GracefulStop.
                 s.mu.Unlock()
                 lis.Close()
                 return ErrServerStopped
         }
-        s.lis[lis] = true
+
+        s.serveWG.Add(1)
+        defer func() {
+                s.serveWG.Done()
+                select {
+                // Stop or GracefulStop called; block until done and return nil.
+                case <-s.quit:
+                        <-s.done
+                default:
+                }
+        }()
+
+        ls := &listenSocket{Listener: lis}
+        s.lis[ls] = true
+
+        if channelz.IsOn() {
+                ls.channelzID = channelz.RegisterListenSocket(ls, s.channelzID, lis.Addr().String())
+        }
         s.mu.Unlock()
+
         defer func() {
                 s.mu.Lock()
-                if s.lis != nil && s.lis[lis] {
-                        lis.Close()
-                        delete(s.lis, lis)
+                if s.lis != nil && s.lis[ls] {
+                        ls.Close()
+                        delete(s.lis, ls)
                 }
                 s.mu.Unlock()
         }()
@@ -460,36 +572,52 @@ func (s *Server) Serve(lis net.Listener) error {
                                 timer := time.NewTimer(tempDelay)
                                 select {
                                 case <-timer.C:
-                                case <-s.ctx.Done():
+                                case <-s.quit:
+                                        timer.Stop()
+                                        return nil
                                 }
-                                timer.Stop()
                                 continue
                         }
                         s.mu.Lock()
                         s.printf("done serving; Accept = %v", err)
                         s.mu.Unlock()
+
+                        select {
+                        case <-s.quit:
+                                return nil
+                        default:
+                        }
                         return err
                 }
                 tempDelay = 0
-                // Start a new goroutine to deal with rawConn
-                // so we don't stall this Accept loop goroutine.
-                go s.handleRawConn(rawConn)
+                // Start a new goroutine to deal with rawConn so we don't stall this Accept
+                // loop goroutine.
+                //
+                // Make sure we account for the goroutine so GracefulStop doesn't nil out
+                // s.conns before this conn can be added.
+                s.serveWG.Add(1)
+                go func() {
+                        s.handleRawConn(rawConn)
+                        s.serveWG.Done()
+                }()
         }
 }
 
-// handleRawConn is run in its own goroutine and handles a just-accepted
-// connection that has not had any I/O performed on it yet.
+// handleRawConn forks a goroutine to handle a just-accepted connection that
+// has not had any I/O performed on it yet.
 func (s *Server) handleRawConn(rawConn net.Conn) {
+        rawConn.SetDeadline(time.Now().Add(s.opts.connectionTimeout))
         conn, authInfo, err := s.useTransportAuthenticator(rawConn)
         if err != nil {
                 s.mu.Lock()
                 s.errorf("ServerHandshake(%q) failed: %v", rawConn.RemoteAddr(), err)
                 s.mu.Unlock()
                 grpclog.Warningf("grpc: Server.Serve failed to complete security handshake from %q: %v", rawConn.RemoteAddr(), err)
-                // If serverHandShake returns ErrConnDispatched, keep rawConn open.
+                // If serverHandshake returns ErrConnDispatched, keep rawConn open.
                 if err != credentials.ErrConnDispatched {
                         rawConn.Close()
                 }
+                rawConn.SetDeadline(time.Time{})
                 return
         }
 
@@ -501,19 +629,25 @@ func (s *Server) handleRawConn(rawConn net.Conn) {
         }
         s.mu.Unlock()
 
-        if s.opts.useHandlerImpl {
-                s.serveUsingHandler(conn)
-        } else {
-                s.serveHTTP2Transport(conn, authInfo)
+        // Finish handshaking (HTTP2)
+        st := s.newHTTP2Transport(conn, authInfo)
+        if st == nil {
+                return
+        }
+
+        rawConn.SetDeadline(time.Time{})
+        if !s.addConn(st) {
+                return
         }
+        go func() {
+                s.serveStreams(st)
+                s.removeConn(st)
+        }()
 }
 
-// serveHTTP2Transport sets up a http/2 transport (using the
-// gRPC http2 server transport in transport/http2_server.go) and
-// serves streams on it.
-// This is run in its own goroutine (it does network I/O in
-// transport.NewServerTransport).
-func (s *Server) serveHTTP2Transport(c net.Conn, authInfo credentials.AuthInfo) {
+// newHTTP2Transport sets up a http/2 transport (using the
+// gRPC http2 server transport in transport/http2_server.go).
+func (s *Server) newHTTP2Transport(c net.Conn, authInfo credentials.AuthInfo) transport.ServerTransport {
         config := &transport.ServerConfig{
                 MaxStreams:            s.opts.maxConcurrentStreams,
                 AuthInfo:              authInfo,
@@ -523,6 +657,10 @@ func (s *Server) serveHTTP2Transport(c net.Conn, authInfo credentials.AuthInfo)
                 KeepalivePolicy:       s.opts.keepalivePolicy,
                 InitialWindowSize:     s.opts.initialWindowSize,
                 InitialConnWindowSize: s.opts.initialConnWindowSize,
+                WriteBufferSize:       s.opts.writeBufferSize,
+                ReadBufferSize:        s.opts.readBufferSize,
+                ChannelzParentID:      s.channelzID,
+                MaxHeaderListSize:     s.opts.maxHeaderListSize,
         }
         st, err := transport.NewServerTransport("http2", c, config)
         if err != nil {
@@ -531,17 +669,13 @@ func (s *Server) serveHTTP2Transport(c net.Conn, authInfo credentials.AuthInfo)
                 s.mu.Unlock()
                 c.Close()
                 grpclog.Warningln("grpc: Server.Serve failed to create ServerTransport: ", err)
-                return
-        }
-        if !s.addConn(st) {
-                st.Close()
-                return
+                return nil
         }
-        s.serveStreams(st)
+
+        return st
 }
 
 func (s *Server) serveStreams(st transport.ServerTransport) {
-        defer s.removeConn(st)
         defer st.Close()
         var wg sync.WaitGroup
         st.HandleStreams(func(stream *transport.Stream) {
@@ -562,32 +696,6 @@ func (s *Server) serveStreams(st transport.ServerTransport) {
 
 var _ http.Handler = (*Server)(nil)
 
-// serveUsingHandler is called from handleRawConn when s is configured
-// to handle requests via the http.Handler interface. It sets up a
-// net/http.Server to handle the just-accepted conn. The http.Server
-// is configured to route all incoming requests (all HTTP/2 streams)
-// to ServeHTTP, which creates a new ServerTransport for each stream.
-// serveUsingHandler blocks until conn closes.
-//
-// This codepath is only used when Server.TestingUseHandlerImpl has
-// been configured. This lets the end2end tests exercise the ServeHTTP
-// method as one of the environment types.
-//
-// conn is the *tls.Conn that's already been authenticated.
-func (s *Server) serveUsingHandler(conn net.Conn) {
-        if !s.addConn(conn) {
-                conn.Close()
-                return
-        }
-        defer s.removeConn(conn)
-        h2s := &http2.Server{
-                MaxConcurrentStreams: s.opts.maxConcurrentStreams,
-        }
-        h2s.ServeConn(conn, &http2.ServeConnOpts{
-                Handler: s,
-        })
-}
-
 // ServeHTTP implements the Go standard library's http.Handler
 // interface by responding to the gRPC request r, by looking up
 // the requested gRPC method in the gRPC server s.
@@ -613,13 +721,12 @@ func (s *Server) serveUsingHandler(conn net.Conn) {
 // available through grpc-go's HTTP/2 server, and it is currently EXPERIMENTAL
 // and subject to change.
 func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-        st, err := transport.NewServerHandlerTransport(w, r)
+        st, err := transport.NewServerHandlerTransport(w, r, s.opts.statsHandler)
         if err != nil {
                 http.Error(w, err.Error(), http.StatusInternalServerError)
                 return
         }
         if !s.addConn(st) {
-                st.Close()
                 return
         }
         defer s.removeConn(st)
@@ -649,9 +756,15 @@ func (s *Server) traceInfo(st transport.ServerTransport, stream *transport.Strea
 func (s *Server) addConn(c io.Closer) bool {
         s.mu.Lock()
         defer s.mu.Unlock()
-        if s.conns == nil || s.drain {
+        if s.conns == nil {
+                c.Close()
                 return false
         }
+        if s.drain {
+                // Transport added after we drained our existing conns: drain it
+                // immediately.
+                c.(transport.ServerTransport).Drain()
+        }
         s.conns[c] = true
         return true
 }
@@ -665,43 +778,73 @@ func (s *Server) removeConn(c io.Closer) {
         }
 }
 
-func (s *Server) sendResponse(t transport.ServerTransport, stream *transport.Stream, msg interface{}, cp Compressor, opts *transport.Options) error {
-        var (
-                cbuf       *bytes.Buffer
-                outPayload *stats.OutPayload
-        )
-        if cp != nil {
-                cbuf = new(bytes.Buffer)
+func (s *Server) channelzMetric() *channelz.ServerInternalMetric {
+        return &channelz.ServerInternalMetric{
+                CallsStarted:             atomic.LoadInt64(&s.czData.callsStarted),
+                CallsSucceeded:           atomic.LoadInt64(&s.czData.callsSucceeded),
+                CallsFailed:              atomic.LoadInt64(&s.czData.callsFailed),
+                LastCallStartedTimestamp: time.Unix(0, atomic.LoadInt64(&s.czData.lastCallStartedTime)),
         }
-        if s.opts.statsHandler != nil {
-                outPayload = &stats.OutPayload{}
-        }
-        p, err := encode(s.opts.codec, msg, cp, cbuf, outPayload)
+}
+
+func (s *Server) incrCallsStarted() {
+        atomic.AddInt64(&s.czData.callsStarted, 1)
+        atomic.StoreInt64(&s.czData.lastCallStartedTime, time.Now().UnixNano())
+}
+
+func (s *Server) incrCallsSucceeded() {
+        atomic.AddInt64(&s.czData.callsSucceeded, 1)
+}
+
+func (s *Server) incrCallsFailed() {
+        atomic.AddInt64(&s.czData.callsFailed, 1)
+}
+
+func (s *Server) sendResponse(t transport.ServerTransport, stream *transport.Stream, msg interface{}, cp Compressor, opts *transport.Options, comp encoding.Compressor) error {
+        data, err := encode(s.getCodec(stream.ContentSubtype()), msg)
         if err != nil {
                 grpclog.Errorln("grpc: server failed to encode response: ", err)
                 return err
         }
-        if len(p) > s.opts.maxSendMessageSize {
-                return status.Errorf(codes.ResourceExhausted, "grpc: trying to send message larger than max (%d vs. %d)", len(p), s.opts.maxSendMessageSize)
+        compData, err := compress(data, cp, comp)
+        if err != nil {
+                grpclog.Errorln("grpc: server failed to compress response: ", err)
+                return err
+        }
+        hdr, payload := msgHeader(data, compData)
+        // TODO(dfawley): should we be checking len(data) instead?
+        if len(payload) > s.opts.maxSendMessageSize {
+                return status.Errorf(codes.ResourceExhausted, "grpc: trying to send message larger than max (%d vs. %d)", len(payload), s.opts.maxSendMessageSize)
         }
-        err = t.Write(stream, p, opts)
-        if err == nil && outPayload != nil {
-                outPayload.SentTime = time.Now()
-                s.opts.statsHandler.HandleRPC(stream.Context(), outPayload)
+        err = t.Write(stream, hdr, payload, opts)
+        if err == nil && s.opts.statsHandler != nil {
+                s.opts.statsHandler.HandleRPC(stream.Context(), outPayload(false, msg, data, payload, time.Now()))
         }
         return err
 }
 
 func (s *Server) processUnaryRPC(t transport.ServerTransport, stream *transport.Stream, srv *service, md *MethodDesc, trInfo *traceInfo) (err error) {
+        if channelz.IsOn() {
+                s.incrCallsStarted()
+                defer func() {
+                        if err != nil && err != io.EOF {
+                                s.incrCallsFailed()
+                        } else {
+                                s.incrCallsSucceeded()
+                        }
+                }()
+        }
         sh := s.opts.statsHandler
         if sh != nil {
+                beginTime := time.Now()
                 begin := &stats.Begin{
-                        BeginTime: time.Now(),
+                        BeginTime: beginTime,
                 }
                 sh.HandleRPC(stream.Context(), begin)
                 defer func() {
                         end := &stats.End{
-                                EndTime: time.Now(),
+                                BeginTime: beginTime,
+                                EndTime:   time.Now(),
                         }
                         if err != nil && err != io.EOF {
                                 end.Error = toRPCErr(err)
@@ -720,94 +863,112 @@ func (s *Server) processUnaryRPC(t transport.ServerTransport, stream *transport.
                         }
                 }()
         }
-        if s.opts.cp != nil {
-                // NOTE: this needs to be ahead of all handling, https://github.com/grpc/grpc-go/issues/686.
-                stream.SetSendCompress(s.opts.cp.Type())
+
+        binlog := binarylog.GetMethodLogger(stream.Method())
+        if binlog != nil {
+                ctx := stream.Context()
+                md, _ := metadata.FromIncomingContext(ctx)
+                logEntry := &binarylog.ClientHeader{
+                        Header:     md,
+                        MethodName: stream.Method(),
+                        PeerAddr:   nil,
+                }
+                if deadline, ok := ctx.Deadline(); ok {
+                        logEntry.Timeout = deadline.Sub(time.Now())
+                        if logEntry.Timeout < 0 {
+                                logEntry.Timeout = 0
+                        }
+                }
+                if a := md[":authority"]; len(a) > 0 {
+                        logEntry.Authority = a[0]
+                }
+                if peer, ok := peer.FromContext(ctx); ok {
+                        logEntry.PeerAddr = peer.Addr
+                }
+                binlog.Log(logEntry)
+        }
+
+        // comp and cp are used for compression.  decomp and dc are used for
+        // decompression.  If comp and decomp are both set, they are the same;
+        // however they are kept separate to ensure that at most one of the
+        // compressor/decompressor variable pairs are set for use later.
+        var comp, decomp encoding.Compressor
+        var cp Compressor
+        var dc Decompressor
+
+        // If dc is set and matches the stream's compression, use it.  Otherwise, try
+        // to find a matching registered compressor for decomp.
+        if rc := stream.RecvCompress(); s.opts.dc != nil && s.opts.dc.Type() == rc {
+                dc = s.opts.dc
+        } else if rc != "" && rc != encoding.Identity {
+                decomp = encoding.GetCompressor(rc)
+                if decomp == nil {
+                        st := status.Newf(codes.Unimplemented, "grpc: Decompressor is not installed for grpc-encoding %q", rc)
+                        t.WriteStatus(stream, st)
+                        return st.Err()
+                }
         }
-        p := &parser{r: stream}
-        pf, req, err := p.recvMsg(s.opts.maxReceiveMessageSize)
-        if err == io.EOF {
-                // The entire stream is done (for unary RPC only).
-                return err
+
+        // If cp is set, use it.  Otherwise, attempt to compress the response using
+        // the incoming message compression method.
+        //
+        // NOTE: this needs to be ahead of all handling, https://github.com/grpc/grpc-go/issues/686.
+        if s.opts.cp != nil {
+                cp = s.opts.cp
+                stream.SetSendCompress(cp.Type())
+        } else if rc := stream.RecvCompress(); rc != "" && rc != encoding.Identity {
+                // Legacy compressor not specified; attempt to respond with same encoding.
+                comp = encoding.GetCompressor(rc)
+                if comp != nil {
+                        stream.SetSendCompress(rc)
+                }
         }
-        if err == io.ErrUnexpectedEOF {
-                err = Errorf(codes.Internal, io.ErrUnexpectedEOF.Error())
+
+        var payInfo *payloadInfo
+        if sh != nil || binlog != nil {
+                payInfo = &payloadInfo{}
         }
+        d, err := recvAndDecompress(&parser{r: stream}, stream, dc, s.opts.maxReceiveMessageSize, payInfo, decomp)
         if err != nil {
                 if st, ok := status.FromError(err); ok {
                         if e := t.WriteStatus(stream, st); e != nil {
                                 grpclog.Warningf("grpc: Server.processUnaryRPC failed to write status %v", e)
                         }
-                } else {
-                        switch st := err.(type) {
-                        case transport.ConnectionError:
-                                // Nothing to do here.
-                        case transport.StreamError:
-                                if e := t.WriteStatus(stream, status.New(st.Code, st.Desc)); e != nil {
-                                        grpclog.Warningf("grpc: Server.processUnaryRPC failed to write status %v", e)
-                                }
-                        default:
-                                panic(fmt.Sprintf("grpc: Unexpected error (%T) from recvMsg: %v", st, st))
-                        }
                 }
                 return err
         }
-
-        if err := checkRecvPayload(pf, stream.RecvCompress(), s.opts.dc); err != nil {
-                if st, ok := status.FromError(err); ok {
-                        if e := t.WriteStatus(stream, st); e != nil {
-                                grpclog.Warningf("grpc: Server.processUnaryRPC failed to write status %v", e)
-                        }
-                        return err
-                }
-                if e := t.WriteStatus(stream, status.New(codes.Internal, err.Error())); e != nil {
-                        grpclog.Warningf("grpc: Server.processUnaryRPC failed to write status %v", e)
-                }
-
-                // TODO checkRecvPayload always return RPC error. Add a return here if necessary.
-        }
-        var inPayload *stats.InPayload
-        if sh != nil {
-                inPayload = &stats.InPayload{
-                        RecvTime: time.Now(),
-                }
+        if channelz.IsOn() {
+                t.IncrMsgRecv()
         }
         df := func(v interface{}) error {
-                if inPayload != nil {
-                        inPayload.WireLength = len(req)
-                }
-                if pf == compressionMade {
-                        var err error
-                        req, err = s.opts.dc.Do(bytes.NewReader(req))
-                        if err != nil {
-                                return Errorf(codes.Internal, err.Error())
-                        }
-                }
-                if len(req) > s.opts.maxReceiveMessageSize {
-                        // TODO: Revisit the error code. Currently keep it consistent with
-                        // java implementation.
-                        return status.Errorf(codes.ResourceExhausted, "grpc: received message larger than max (%d vs. %d)", len(req), s.opts.maxReceiveMessageSize)
-                }
-                if err := s.opts.codec.Unmarshal(req, v); err != nil {
+                if err := s.getCodec(stream.ContentSubtype()).Unmarshal(d, v); err != nil {
                         return status.Errorf(codes.Internal, "grpc: error unmarshalling request: %v", err)
                 }
-                if inPayload != nil {
-                        inPayload.Payload = v
-                        inPayload.Data = req
-                        inPayload.Length = len(req)
-                        sh.HandleRPC(stream.Context(), inPayload)
+                if sh != nil {
+                        sh.HandleRPC(stream.Context(), &stats.InPayload{
+                                RecvTime: time.Now(),
+                                Payload:  v,
+                                Data:     d,
+                                Length:   len(d),
+                        })
+                }
+                if binlog != nil {
+                        binlog.Log(&binarylog.ClientMessage{
+                                Message: d,
+                        })
                 }
                 if trInfo != nil {
                         trInfo.tr.LazyLog(&payload{sent: false, msg: v}, true)
                 }
                 return nil
         }
-        reply, appErr := md.Handler(srv.server, stream.Context(), df, s.opts.unaryInt)
+        ctx := NewContextWithServerTransportStream(stream.Context(), stream)
+        reply, appErr := md.Handler(srv.server, ctx, df, s.opts.unaryInt)
         if appErr != nil {
                 appStatus, ok := status.FromError(appErr)
                 if !ok {
                         // Convert appErr if it is not a grpc status error.
-                        appErr = status.Error(convertCode(appErr), appErr.Error())
+                        appErr = status.Error(codes.Unknown, appErr.Error())
                         appStatus, _ = status.FromError(appErr)
                 }
                 if trInfo != nil {
@@ -817,16 +978,27 @@ func (s *Server) processUnaryRPC(t transport.ServerTransport, stream *transport.
                 if e := t.WriteStatus(stream, appStatus); e != nil {
                         grpclog.Warningf("grpc: Server.processUnaryRPC failed to write status: %v", e)
                 }
+                if binlog != nil {
+                        if h, _ := stream.Header(); h.Len() > 0 {
+                                // Only log serverHeader if there was header. Otherwise it can
+                                // be trailer only.
+                                binlog.Log(&binarylog.ServerHeader{
+                                        Header: h,
+                                })
+                        }
+                        binlog.Log(&binarylog.ServerTrailer{
+                                Trailer: stream.Trailer(),
+                                Err:     appErr,
+                        })
+                }
                 return appErr
         }
         if trInfo != nil {
                 trInfo.tr.LazyLog(stringer("OK"), false)
         }
-        opts := &transport.Options{
-                Last:  true,
-                Delay: false,
-        }
-        if err := s.sendResponse(t, stream, reply, s.opts.cp, opts); err != nil {
+        opts := &transport.Options{Last: true}
+
+        if err := s.sendResponse(t, stream, reply, cp, opts, comp); err != nil {
                 if err == io.EOF {
                         // The entire stream is done (for unary RPC only).
                         return err
@@ -839,35 +1011,72 @@ func (s *Server) processUnaryRPC(t transport.ServerTransport, stream *transport.
                         switch st := err.(type) {
                         case transport.ConnectionError:
                                 // Nothing to do here.
-                        case transport.StreamError:
-                                if e := t.WriteStatus(stream, status.New(st.Code, st.Desc)); e != nil {
-                                        grpclog.Warningf("grpc: Server.processUnaryRPC failed to write status %v", e)
-                                }
                         default:
                                 panic(fmt.Sprintf("grpc: Unexpected error (%T) from sendResponse: %v", st, st))
                         }
                 }
+                if binlog != nil {
+                        h, _ := stream.Header()
+                        binlog.Log(&binarylog.ServerHeader{
+                                Header: h,
+                        })
+                        binlog.Log(&binarylog.ServerTrailer{
+                                Trailer: stream.Trailer(),
+                                Err:     appErr,
+                        })
+                }
                 return err
         }
+        if binlog != nil {
+                h, _ := stream.Header()
+                binlog.Log(&binarylog.ServerHeader{
+                        Header: h,
+                })
+                binlog.Log(&binarylog.ServerMessage{
+                        Message: reply,
+                })
+        }
+        if channelz.IsOn() {
+                t.IncrMsgSent()
+        }
         if trInfo != nil {
                 trInfo.tr.LazyLog(&payload{sent: true, msg: reply}, true)
         }
         // TODO: Should we be logging if writing status failed here, like above?
         // Should the logging be in WriteStatus?  Should we ignore the WriteStatus
         // error or allow the stats handler to see it?
-        return t.WriteStatus(stream, status.New(codes.OK, ""))
+        err = t.WriteStatus(stream, status.New(codes.OK, ""))
+        if binlog != nil {
+                binlog.Log(&binarylog.ServerTrailer{
+                        Trailer: stream.Trailer(),
+                        Err:     appErr,
+                })
+        }
+        return err
 }
 
 func (s *Server) processStreamingRPC(t transport.ServerTransport, stream *transport.Stream, srv *service, sd *StreamDesc, trInfo *traceInfo) (err error) {
+        if channelz.IsOn() {
+                s.incrCallsStarted()
+                defer func() {
+                        if err != nil && err != io.EOF {
+                                s.incrCallsFailed()
+                        } else {
+                                s.incrCallsSucceeded()
+                        }
+                }()
+        }
         sh := s.opts.statsHandler
         if sh != nil {
+                beginTime := time.Now()
                 begin := &stats.Begin{
-                        BeginTime: time.Now(),
+                        BeginTime: beginTime,
                 }
                 sh.HandleRPC(stream.Context(), begin)
                 defer func() {
                         end := &stats.End{
-                                EndTime: time.Now(),
+                                BeginTime: beginTime,
+                                EndTime:   time.Now(),
                         }
                         if err != nil && err != io.EOF {
                                 end.Error = toRPCErr(err)
@@ -875,24 +1084,70 @@ func (s *Server) processStreamingRPC(t transport.ServerTransport, stream *transp
                         sh.HandleRPC(stream.Context(), end)
                 }()
         }
-        if s.opts.cp != nil {
-                stream.SetSendCompress(s.opts.cp.Type())
-        }
+        ctx := NewContextWithServerTransportStream(stream.Context(), stream)
         ss := &serverStream{
-                t:     t,
-                s:     stream,
-                p:     &parser{r: stream},
-                codec: s.opts.codec,
-                cp:    s.opts.cp,
-                dc:    s.opts.dc,
+                ctx:                   ctx,
+                t:                     t,
+                s:                     stream,
+                p:                     &parser{r: stream},
+                codec:                 s.getCodec(stream.ContentSubtype()),
                 maxReceiveMessageSize: s.opts.maxReceiveMessageSize,
                 maxSendMessageSize:    s.opts.maxSendMessageSize,
                 trInfo:                trInfo,
                 statsHandler:          sh,
         }
-        if ss.cp != nil {
-                ss.cbuf = new(bytes.Buffer)
+
+        ss.binlog = binarylog.GetMethodLogger(stream.Method())
+        if ss.binlog != nil {
+                md, _ := metadata.FromIncomingContext(ctx)
+                logEntry := &binarylog.ClientHeader{
+                        Header:     md,
+                        MethodName: stream.Method(),
+                        PeerAddr:   nil,
+                }
+                if deadline, ok := ctx.Deadline(); ok {
+                        logEntry.Timeout = deadline.Sub(time.Now())
+                        if logEntry.Timeout < 0 {
+                                logEntry.Timeout = 0
+                        }
+                }
+                if a := md[":authority"]; len(a) > 0 {
+                        logEntry.Authority = a[0]
+                }
+                if peer, ok := peer.FromContext(ss.Context()); ok {
+                        logEntry.PeerAddr = peer.Addr
+                }
+                ss.binlog.Log(logEntry)
+        }
+
+        // If dc is set and matches the stream's compression, use it.  Otherwise, try
+        // to find a matching registered compressor for decomp.
+        if rc := stream.RecvCompress(); s.opts.dc != nil && s.opts.dc.Type() == rc {
+                ss.dc = s.opts.dc
+        } else if rc != "" && rc != encoding.Identity {
+                ss.decomp = encoding.GetCompressor(rc)
+                if ss.decomp == nil {
+                        st := status.Newf(codes.Unimplemented, "grpc: Decompressor is not installed for grpc-encoding %q", rc)
+                        t.WriteStatus(ss.s, st)
+                        return st.Err()
+                }
+        }
+
+        // If cp is set, use it.  Otherwise, attempt to compress the response using
+        // the incoming message compression method.
+        //
+        // NOTE: this needs to be ahead of all handling, https://github.com/grpc/grpc-go/issues/686.
+        if s.opts.cp != nil {
+                ss.cp = s.opts.cp
+                stream.SetSendCompress(s.opts.cp.Type())
+        } else if rc := stream.RecvCompress(); rc != "" && rc != encoding.Identity {
+                // Legacy compressor not specified; attempt to respond with same encoding.
+                ss.comp = encoding.GetCompressor(rc)
+                if ss.comp != nil {
+                        stream.SetSendCompress(rc)
+                }
         }
+
         if trInfo != nil {
                 trInfo.tr.LazyLog(&trInfo.firstLine, false)
                 defer func() {
@@ -924,12 +1179,7 @@ func (s *Server) processStreamingRPC(t transport.ServerTransport, stream *transp
         if appErr != nil {
                 appStatus, ok := status.FromError(appErr)
                 if !ok {
-                        switch err := appErr.(type) {
-                        case transport.StreamError:
-                                appStatus = status.New(err.Code, err.Desc)
-                        default:
-                                appStatus = status.New(convertCode(appErr), appErr.Error())
-                        }
+                        appStatus = status.New(codes.Unknown, appErr.Error())
                         appErr = appStatus.Err()
                 }
                 if trInfo != nil {
@@ -939,6 +1189,12 @@ func (s *Server) processStreamingRPC(t transport.ServerTransport, stream *transp
                         ss.mu.Unlock()
                 }
                 t.WriteStatus(ss.s, appStatus)
+                if ss.binlog != nil {
+                        ss.binlog.Log(&binarylog.ServerTrailer{
+                                Trailer: ss.s.Trailer(),
+                                Err:     appErr,
+                        })
+                }
                 // TODO: Should we log an error from WriteStatus here and below?
                 return appErr
         }
@@ -947,8 +1203,14 @@ func (s *Server) processStreamingRPC(t transport.ServerTransport, stream *transp
                 ss.trInfo.tr.LazyLog(stringer("OK"), false)
                 ss.mu.Unlock()
         }
-        return t.WriteStatus(ss.s, status.New(codes.OK, ""))
-
+        err = t.WriteStatus(ss.s, status.New(codes.OK, ""))
+        if ss.binlog != nil {
+                ss.binlog.Log(&binarylog.ServerTrailer{
+                        Trailer: ss.s.Trailer(),
+                        Err:     appErr,
+                })
+        }
+        return err
 }
 
 func (s *Server) handleStream(t transport.ServerTransport, stream *transport.Stream, trInfo *traceInfo) {
@@ -977,47 +1239,27 @@ func (s *Server) handleStream(t transport.ServerTransport, stream *transport.Str
         }
         service := sm[:pos]
         method := sm[pos+1:]
-        srv, ok := s.m[service]
-        if !ok {
-                if unknownDesc := s.opts.unknownStreamDesc; unknownDesc != nil {
-                        s.processStreamingRPC(t, stream, nil, unknownDesc, trInfo)
+
+        if srv, ok := s.m[service]; ok {
+                if md, ok := srv.md[method]; ok {
+                        s.processUnaryRPC(t, stream, srv, md, trInfo)
                         return
                 }
-                if trInfo != nil {
-                        trInfo.tr.LazyLog(&fmtStringer{"Unknown service %v", []interface{}{service}}, true)
-                        trInfo.tr.SetError()
-                }
-                errDesc := fmt.Sprintf("unknown service %v", service)
-                if err := t.WriteStatus(stream, status.New(codes.Unimplemented, errDesc)); err != nil {
-                        if trInfo != nil {
-                                trInfo.tr.LazyLog(&fmtStringer{"%v", []interface{}{err}}, true)
-                                trInfo.tr.SetError()
-                        }
-                        grpclog.Warningf("grpc: Server.handleStream failed to write status: %v", err)
-                }
-                if trInfo != nil {
-                        trInfo.tr.Finish()
+                if sd, ok := srv.sd[method]; ok {
+                        s.processStreamingRPC(t, stream, srv, sd, trInfo)
+                        return
                 }
-                return
-        }
-        // Unary RPC or Streaming RPC?
-        if md, ok := srv.md[method]; ok {
-                s.processUnaryRPC(t, stream, srv, md, trInfo)
-                return
         }
-        if sd, ok := srv.sd[method]; ok {
-                s.processStreamingRPC(t, stream, srv, sd, trInfo)
+        // Unknown service, or known server unknown method.
+        if unknownDesc := s.opts.unknownStreamDesc; unknownDesc != nil {
+                s.processStreamingRPC(t, stream, nil, unknownDesc, trInfo)
                 return
         }
         if trInfo != nil {
-                trInfo.tr.LazyLog(&fmtStringer{"Unknown method %v", []interface{}{method}}, true)
+                trInfo.tr.LazyLog(&fmtStringer{"Unknown service %v", []interface{}{service}}, true)
                 trInfo.tr.SetError()
         }
-        if unknownDesc := s.opts.unknownStreamDesc; unknownDesc != nil {
-                s.processStreamingRPC(t, stream, nil, unknownDesc, trInfo)
-                return
-        }
-        errDesc := fmt.Sprintf("unknown method %v", method)
+        errDesc := fmt.Sprintf("unknown service %v", service)
         if err := t.WriteStatus(stream, status.New(codes.Unimplemented, errDesc)); err != nil {
                 if trInfo != nil {
                         trInfo.tr.LazyLog(&fmtStringer{"%v", []interface{}{err}}, true)
@@ -1030,12 +1272,65 @@ func (s *Server) handleStream(t transport.ServerTransport, stream *transport.Str
         }
 }
 
+// The key to save ServerTransportStream in the context.
+type streamKey struct{}
+
+// NewContextWithServerTransportStream creates a new context from ctx and
+// attaches stream to it.
+//
+// This API is EXPERIMENTAL.
+func NewContextWithServerTransportStream(ctx context.Context, stream ServerTransportStream) context.Context {
+        return context.WithValue(ctx, streamKey{}, stream)
+}
+
+// ServerTransportStream is a minimal interface that a transport stream must
+// implement. This can be used to mock an actual transport stream for tests of
+// handler code that use, for example, grpc.SetHeader (which requires some
+// stream to be in context).
+//
+// See also NewContextWithServerTransportStream.
+//
+// This API is EXPERIMENTAL.
+type ServerTransportStream interface {
+        Method() string
+        SetHeader(md metadata.MD) error
+        SendHeader(md metadata.MD) error
+        SetTrailer(md metadata.MD) error
+}
+
+// ServerTransportStreamFromContext returns the ServerTransportStream saved in
+// ctx. Returns nil if the given context has no stream associated with it
+// (which implies it is not an RPC invocation context).
+//
+// This API is EXPERIMENTAL.
+func ServerTransportStreamFromContext(ctx context.Context) ServerTransportStream {
+        s, _ := ctx.Value(streamKey{}).(ServerTransportStream)
+        return s
+}
+
 // Stop stops the gRPC server. It immediately closes all open
 // connections and listeners.
 // It cancels all active RPCs on the server side and the corresponding
 // pending RPCs on the client side will get notified by connection
 // errors.
 func (s *Server) Stop() {
+        s.quitOnce.Do(func() {
+                close(s.quit)
+        })
+
+        defer func() {
+                s.serveWG.Wait()
+                s.doneOnce.Do(func() {
+                        close(s.done)
+                })
+        }()
+
+        s.channelzRemoveOnce.Do(func() {
+                if channelz.IsOn() {
+                        channelz.RemoveEntry(s.channelzID)
+                }
+        })
+
         s.mu.Lock()
         listeners := s.lis
         s.lis = nil
@@ -1053,7 +1348,6 @@ func (s *Server) Stop() {
         }
 
         s.mu.Lock()
-        s.cancel()
         if s.events != nil {
                 s.events.Finish()
                 s.events = nil
@@ -1065,22 +1359,44 @@ func (s *Server) Stop() {
 // accepting new connections and RPCs and blocks until all the pending RPCs are
 // finished.
 func (s *Server) GracefulStop() {
+        s.quitOnce.Do(func() {
+                close(s.quit)
+        })
+
+        defer func() {
+                s.doneOnce.Do(func() {
+                        close(s.done)
+                })
+        }()
+
+        s.channelzRemoveOnce.Do(func() {
+                if channelz.IsOn() {
+                        channelz.RemoveEntry(s.channelzID)
+                }
+        })
         s.mu.Lock()
-        defer s.mu.Unlock()
         if s.conns == nil {
+                s.mu.Unlock()
                 return
         }
+
         for lis := range s.lis {
                 lis.Close()
         }
         s.lis = nil
-        s.cancel()
         if !s.drain {
                 for c := range s.conns {
                         c.(transport.ServerTransport).Drain()
                 }
                 s.drain = true
         }
+
+        // Wait for serving threads to be ready to exit.  Only then can we be sure no
+        // new conns will be created.
+        s.mu.Unlock()
+        s.serveWG.Wait()
+        s.mu.Lock()
+
         for len(s.conns) != 0 {
                 s.cv.Wait()
         }
@@ -1089,26 +1405,23 @@ func (s *Server) GracefulStop() {
                 s.events.Finish()
                 s.events = nil
         }
+        s.mu.Unlock()
 }
 
-func init() {
-        internal.TestingCloseConns = func(arg interface{}) {
-                arg.(*Server).testingCloseConns()
+// contentSubtype must be lowercase
+// cannot return nil
+func (s *Server) getCodec(contentSubtype string) baseCodec {
+        if s.opts.codec != nil {
+                return s.opts.codec
         }
-        internal.TestingUseHandlerImpl = func(arg interface{}) {
-                arg.(*Server).opts.useHandlerImpl = true
+        if contentSubtype == "" {
+                return encoding.GetCodec(proto.Name)
         }
-}
-
-// testingCloseConns closes all existing transports but keeps s.lis
-// accepting new connections.
-func (s *Server) testingCloseConns() {
-        s.mu.Lock()
-        for c := range s.conns {
-                c.Close()
-                delete(s.conns, c)
+        codec := encoding.GetCodec(contentSubtype)
+        if codec == nil {
+                return encoding.GetCodec(proto.Name)
         }
-        s.mu.Unlock()
+        return codec
 }
 
 // SetHeader sets the header metadata.
@@ -1121,9 +1434,9 @@ func SetHeader(ctx context.Context, md metadata.MD) error {
         if md.Len() == 0 {
                 return nil
         }
-        stream, ok := transport.StreamFromContext(ctx)
-        if !ok {
-                return Errorf(codes.Internal, "grpc: failed to fetch the stream from the context %v", ctx)
+        stream := ServerTransportStreamFromContext(ctx)
+        if stream == nil {
+                return status.Errorf(codes.Internal, "grpc: failed to fetch the stream from the context %v", ctx)
         }
         return stream.SetHeader(md)
 }
@@ -1131,15 +1444,11 @@ func SetHeader(ctx context.Context, md metadata.MD) error {
 // SendHeader sends header metadata. It may be called at most once.
 // The provided md and headers set by SetHeader() will be sent.
 func SendHeader(ctx context.Context, md metadata.MD) error {
-        stream, ok := transport.StreamFromContext(ctx)
-        if !ok {
-                return Errorf(codes.Internal, "grpc: failed to fetch the stream from the context %v", ctx)
+        stream := ServerTransportStreamFromContext(ctx)
+        if stream == nil {
+                return status.Errorf(codes.Internal, "grpc: failed to fetch the stream from the context %v", ctx)
         }
-        t := stream.ServerTransport()
-        if t == nil {
-                grpclog.Fatalf("grpc: SendHeader: %v has no ServerTransport to send header metadata.", stream)
-        }
-        if err := t.WriteHeader(stream, md); err != nil {
+        if err := stream.SendHeader(md); err != nil {
                 return toRPCErr(err)
         }
         return nil
@@ -1151,9 +1460,27 @@ func SetTrailer(ctx context.Context, md metadata.MD) error {
         if md.Len() == 0 {
                 return nil
         }
-        stream, ok := transport.StreamFromContext(ctx)
-        if !ok {
-                return Errorf(codes.Internal, "grpc: failed to fetch the stream from the context %v", ctx)
+        stream := ServerTransportStreamFromContext(ctx)
+        if stream == nil {
+                return status.Errorf(codes.Internal, "grpc: failed to fetch the stream from the context %v", ctx)
         }
         return stream.SetTrailer(md)
 }
+
+// Method returns the method string for the server context.  The returned
+// string is in the format of "/service/method".
+func Method(ctx context.Context) (string, bool) {
+        s := ServerTransportStreamFromContext(ctx)
+        if s == nil {
+                return "", false
+        }
+        return s.Method(), true
+}
+
+type channelzServer struct {
+        s *Server
+}
+
+func (c *channelzServer) ChannelzMetric() *channelz.ServerInternalMetric {
+        return c.s.channelzMetric()
+}
diff --git a/vendor/google.golang.org/grpc/service_config.go b/vendor/google.golang.org/grpc/service_config.go
new file mode 100644
index 0000000..162857e
--- /dev/null
+++ b/vendor/google.golang.org/grpc/service_config.go
@@ -0,0 +1,372 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package grpc
+
+import (
+        "encoding/json"
+        "fmt"
+        "strconv"
+        "strings"
+        "time"
+
+        "google.golang.org/grpc/codes"
+        "google.golang.org/grpc/grpclog"
+)
+
+const maxInt = int(^uint(0) >> 1)
+
+// MethodConfig defines the configuration recommended by the service providers for a
+// particular method.
+//
+// Deprecated: Users should not use this struct. Service config should be received
+// through name resolver, as specified here
+// https://github.com/grpc/grpc/blob/master/doc/service_config.md
+type MethodConfig struct {
+        // WaitForReady indicates whether RPCs sent to this method should wait until
+        // the connection is ready by default (!failfast). The value specified via the
+        // gRPC client API will override the value set here.
+        WaitForReady *bool
+        // Timeout is the default timeout for RPCs sent to this method. The actual
+        // deadline used will be the minimum of the value specified here and the value
+        // set by the application via the gRPC client API.  If either one is not set,
+        // then the other will be used.  If neither is set, then the RPC has no deadline.
+        Timeout *time.Duration
+        // MaxReqSize is the maximum allowed payload size for an individual request in a
+        // stream (client->server) in bytes. The size which is measured is the serialized
+        // payload after per-message compression (but before stream compression) in bytes.
+        // The actual value used is the minimum of the value specified here and the value set
+        // by the application via the gRPC client API. If either one is not set, then the other
+        // will be used.  If neither is set, then the built-in default is used.
+        MaxReqSize *int
+        // MaxRespSize is the maximum allowed payload size for an individual response in a
+        // stream (server->client) in bytes.
+        MaxRespSize *int
+        // RetryPolicy configures retry options for the method.
+        retryPolicy *retryPolicy
+}
+
+// ServiceConfig is provided by the service provider and contains parameters for how
+// clients that connect to the service should behave.
+//
+// Deprecated: Users should not use this struct. Service config should be received
+// through name resolver, as specified here
+// https://github.com/grpc/grpc/blob/master/doc/service_config.md
+type ServiceConfig struct {
+        // LB is the load balancer the service providers recommends. The balancer specified
+        // via grpc.WithBalancer will override this.
+        LB *string
+
+        // Methods contains a map for the methods in this service.  If there is an
+        // exact match for a method (i.e. /service/method) in the map, use the
+        // corresponding MethodConfig.  If there's no exact match, look for the
+        // default config for the service (/service/) and use the corresponding
+        // MethodConfig if it exists.  Otherwise, the method has no MethodConfig to
+        // use.
+        Methods map[string]MethodConfig
+
+        // If a retryThrottlingPolicy is provided, gRPC will automatically throttle
+        // retry attempts and hedged RPCs when the client’s ratio of failures to
+        // successes exceeds a threshold.
+        //
+        // For each server name, the gRPC client will maintain a token_count which is
+        // initially set to maxTokens, and can take values between 0 and maxTokens.
+        //
+        // Every outgoing RPC (regardless of service or method invoked) will change
+        // token_count as follows:
+        //
+        //   - Every failed RPC will decrement the token_count by 1.
+        //   - Every successful RPC will increment the token_count by tokenRatio.
+        //
+        // If token_count is less than or equal to maxTokens / 2, then RPCs will not
+        // be retried and hedged RPCs will not be sent.
+        retryThrottling *retryThrottlingPolicy
+        // healthCheckConfig must be set as one of the requirement to enable LB channel
+        // health check.
+        healthCheckConfig *healthCheckConfig
+}
+
+// healthCheckConfig defines the go-native version of the LB channel health check config.
+type healthCheckConfig struct {
+        // serviceName is the service name to use in the health-checking request.
+        ServiceName string
+}
+
+// retryPolicy defines the go-native version of the retry policy defined by the
+// service config here:
+// https://github.com/grpc/proposal/blob/master/A6-client-retries.md#integration-with-service-config
+type retryPolicy struct {
+        // MaxAttempts is the maximum number of attempts, including the original RPC.
+        //
+        // This field is required and must be two or greater.
+        maxAttempts int
+
+        // Exponential backoff parameters. The initial retry attempt will occur at
+        // random(0, initialBackoffMS). In general, the nth attempt will occur at
+        // random(0,
+        //   min(initialBackoffMS*backoffMultiplier**(n-1), maxBackoffMS)).
+        //
+        // These fields are required and must be greater than zero.
+        initialBackoff    time.Duration
+        maxBackoff        time.Duration
+        backoffMultiplier float64
+
+        // The set of status codes which may be retried.
+        //
+        // Status codes are specified as strings, e.g., "UNAVAILABLE".
+        //
+        // This field is required and must be non-empty.
+        // Note: a set is used to store this for easy lookup.
+        retryableStatusCodes map[codes.Code]bool
+}
+
+type jsonRetryPolicy struct {
+        MaxAttempts          int
+        InitialBackoff       string
+        MaxBackoff           string
+        BackoffMultiplier    float64
+        RetryableStatusCodes []codes.Code
+}
+
+// retryThrottlingPolicy defines the go-native version of the retry throttling
+// policy defined by the service config here:
+// https://github.com/grpc/proposal/blob/master/A6-client-retries.md#integration-with-service-config
+type retryThrottlingPolicy struct {
+        // The number of tokens starts at maxTokens. The token_count will always be
+        // between 0 and maxTokens.
+        //
+        // This field is required and must be greater than zero.
+        MaxTokens float64
+        // The amount of tokens to add on each successful RPC. Typically this will
+        // be some number between 0 and 1, e.g., 0.1.
+        //
+        // This field is required and must be greater than zero. Up to 3 decimal
+        // places are supported.
+        TokenRatio float64
+}
+
+func parseDuration(s *string) (*time.Duration, error) {
+        if s == nil {
+                return nil, nil
+        }
+        if !strings.HasSuffix(*s, "s") {
+                return nil, fmt.Errorf("malformed duration %q", *s)
+        }
+        ss := strings.SplitN((*s)[:len(*s)-1], ".", 3)
+        if len(ss) > 2 {
+                return nil, fmt.Errorf("malformed duration %q", *s)
+        }
+        // hasDigits is set if either the whole or fractional part of the number is
+        // present, since both are optional but one is required.
+        hasDigits := false
+        var d time.Duration
+        if len(ss[0]) > 0 {
+                i, err := strconv.ParseInt(ss[0], 10, 32)
+                if err != nil {
+                        return nil, fmt.Errorf("malformed duration %q: %v", *s, err)
+                }
+                d = time.Duration(i) * time.Second
+                hasDigits = true
+        }
+        if len(ss) == 2 && len(ss[1]) > 0 {
+                if len(ss[1]) > 9 {
+                        return nil, fmt.Errorf("malformed duration %q", *s)
+                }
+                f, err := strconv.ParseInt(ss[1], 10, 64)
+                if err != nil {
+                        return nil, fmt.Errorf("malformed duration %q: %v", *s, err)
+                }
+                for i := 9; i > len(ss[1]); i-- {
+                        f *= 10
+                }
+                d += time.Duration(f)
+                hasDigits = true
+        }
+        if !hasDigits {
+                return nil, fmt.Errorf("malformed duration %q", *s)
+        }
+
+        return &d, nil
+}
+
+type jsonName struct {
+        Service *string
+        Method  *string
+}
+
+func (j jsonName) generatePath() (string, bool) {
+        if j.Service == nil {
+                return "", false
+        }
+        res := "/" + *j.Service + "/"
+        if j.Method != nil {
+                res += *j.Method
+        }
+        return res, true
+}
+
+// TODO(lyuxuan): delete this struct after cleaning up old service config implementation.
+type jsonMC struct {
+        Name                    *[]jsonName
+        WaitForReady            *bool
+        Timeout                 *string
+        MaxRequestMessageBytes  *int64
+        MaxResponseMessageBytes *int64
+        RetryPolicy             *jsonRetryPolicy
+}
+
+// TODO(lyuxuan): delete this struct after cleaning up old service config implementation.
+type jsonSC struct {
+        LoadBalancingPolicy *string
+        MethodConfig        *[]jsonMC
+        RetryThrottling     *retryThrottlingPolicy
+        HealthCheckConfig   *healthCheckConfig
+}
+
+func parseServiceConfig(js string) (ServiceConfig, error) {
+        if len(js) == 0 {
+                return ServiceConfig{}, fmt.Errorf("no JSON service config provided")
+        }
+        var rsc jsonSC
+        err := json.Unmarshal([]byte(js), &rsc)
+        if err != nil {
+                grpclog.Warningf("grpc: parseServiceConfig error unmarshaling %s due to %v", js, err)
+                return ServiceConfig{}, err
+        }
+        sc := ServiceConfig{
+                LB:                rsc.LoadBalancingPolicy,
+                Methods:           make(map[string]MethodConfig),
+                retryThrottling:   rsc.RetryThrottling,
+                healthCheckConfig: rsc.HealthCheckConfig,
+        }
+        if rsc.MethodConfig == nil {
+                return sc, nil
+        }
+
+        for _, m := range *rsc.MethodConfig {
+                if m.Name == nil {
+                        continue
+                }
+                d, err := parseDuration(m.Timeout)
+                if err != nil {
+                        grpclog.Warningf("grpc: parseServiceConfig error unmarshaling %s due to %v", js, err)
+                        return ServiceConfig{}, err
+                }
+
+                mc := MethodConfig{
+                        WaitForReady: m.WaitForReady,
+                        Timeout:      d,
+                }
+                if mc.retryPolicy, err = convertRetryPolicy(m.RetryPolicy); err != nil {
+                        grpclog.Warningf("grpc: parseServiceConfig error unmarshaling %s due to %v", js, err)
+                        return ServiceConfig{}, err
+                }
+                if m.MaxRequestMessageBytes != nil {
+                        if *m.MaxRequestMessageBytes > int64(maxInt) {
+                                mc.MaxReqSize = newInt(maxInt)
+                        } else {
+                                mc.MaxReqSize = newInt(int(*m.MaxRequestMessageBytes))
+                        }
+                }
+                if m.MaxResponseMessageBytes != nil {
+                        if *m.MaxResponseMessageBytes > int64(maxInt) {
+                                mc.MaxRespSize = newInt(maxInt)
+                        } else {
+                                mc.MaxRespSize = newInt(int(*m.MaxResponseMessageBytes))
+                        }
+                }
+                for _, n := range *m.Name {
+                        if path, valid := n.generatePath(); valid {
+                                sc.Methods[path] = mc
+                        }
+                }
+        }
+
+        if sc.retryThrottling != nil {
+                if sc.retryThrottling.MaxTokens <= 0 ||
+                        sc.retryThrottling.MaxTokens >= 1000 ||
+                        sc.retryThrottling.TokenRatio <= 0 {
+                        // Illegal throttling config; disable throttling.
+                        sc.retryThrottling = nil
+                }
+        }
+        return sc, nil
+}
+
+func convertRetryPolicy(jrp *jsonRetryPolicy) (p *retryPolicy, err error) {
+        if jrp == nil {
+                return nil, nil
+        }
+        ib, err := parseDuration(&jrp.InitialBackoff)
+        if err != nil {
+                return nil, err
+        }
+        mb, err := parseDuration(&jrp.MaxBackoff)
+        if err != nil {
+                return nil, err
+        }
+
+        if jrp.MaxAttempts <= 1 ||
+                *ib <= 0 ||
+                *mb <= 0 ||
+                jrp.BackoffMultiplier <= 0 ||
+                len(jrp.RetryableStatusCodes) == 0 {
+                grpclog.Warningf("grpc: ignoring retry policy %v due to illegal configuration", jrp)
+                return nil, nil
+        }
+
+        rp := &retryPolicy{
+                maxAttempts:          jrp.MaxAttempts,
+                initialBackoff:       *ib,
+                maxBackoff:           *mb,
+                backoffMultiplier:    jrp.BackoffMultiplier,
+                retryableStatusCodes: make(map[codes.Code]bool),
+        }
+        if rp.maxAttempts > 5 {
+                // TODO(retry): Make the max maxAttempts configurable.
+                rp.maxAttempts = 5
+        }
+        for _, code := range jrp.RetryableStatusCodes {
+                rp.retryableStatusCodes[code] = true
+        }
+        return rp, nil
+}
+
+func min(a, b *int) *int {
+        if *a < *b {
+                return a
+        }
+        return b
+}
+
+func getMaxSize(mcMax, doptMax *int, defaultVal int) *int {
+        if mcMax == nil && doptMax == nil {
+                return &defaultVal
+        }
+        if mcMax != nil && doptMax != nil {
+                return min(mcMax, doptMax)
+        }
+        if mcMax != nil {
+                return mcMax
+        }
+        return doptMax
+}
+
+func newInt(b int) *int {
+        return &b
+}
diff --git a/vendor/google.golang.org/grpc/stats/handlers.go b/vendor/google.golang.org/grpc/stats/handlers.go
index 05b384c..dc03731 100644
--- a/vendor/google.golang.org/grpc/stats/handlers.go
+++ b/vendor/google.golang.org/grpc/stats/handlers.go
@@ -19,9 +19,8 @@
 package stats
 
 import (
+        "context"
         "net"
-
-        "golang.org/x/net/context"
 )
 
 // ConnTagInfo defines the relevant information needed by connection context tagger.
diff --git a/vendor/google.golang.org/grpc/stats/stats.go b/vendor/google.golang.org/grpc/stats/stats.go
index 338a3a7..84f77da 100644
--- a/vendor/google.golang.org/grpc/stats/stats.go
+++ b/vendor/google.golang.org/grpc/stats/stats.go
@@ -16,12 +16,15 @@
  *
  */
 
+//go:generate protoc --go_out=plugins=grpc:. grpc_testing/test.proto
+
 // Package stats is for collecting and reporting various network and RPC stats.
 // This package is for monitoring purpose only. All fields are read-only.
 // All APIs are experimental.
 package stats // import "google.golang.org/grpc/stats"
 
 import (
+        "context"
         "net"
         "time"
 )
@@ -131,8 +134,6 @@ func (s *OutPayload) isRPCStats() {}
 type OutHeader struct {
         // Client is true if this OutHeader is from client side.
         Client bool
-        // WireLength is the wire length of header.
-        WireLength int
 
         // The following fields are valid only if Client is true.
         // FullMethod is the full RPC method string, i.e., /package.service/method.
@@ -167,6 +168,8 @@ func (s *OutTrailer) isRPCStats() {}
 type End struct {
         // Client is true if this End is from client side.
         Client bool
+        // BeginTime is the time when the RPC began.
+        BeginTime time.Time
         // EndTime is the time when the RPC ends.
         EndTime time.Time
         // Error is the error the RPC ended with. It is an error generated from
@@ -208,3 +211,85 @@ type ConnEnd struct {
 func (s *ConnEnd) IsClient() bool { return s.Client }
 
 func (s *ConnEnd) isConnStats() {}
+
+type incomingTagsKey struct{}
+type outgoingTagsKey struct{}
+
+// SetTags attaches stats tagging data to the context, which will be sent in
+// the outgoing RPC with the header grpc-tags-bin.  Subsequent calls to
+// SetTags will overwrite the values from earlier calls.
+//
+// NOTE: this is provided only for backward compatibility with existing clients
+// and will likely be removed in an upcoming release.  New uses should transmit
+// this type of data using metadata with a different, non-reserved (i.e. does
+// not begin with "grpc-") header name.
+func SetTags(ctx context.Context, b []byte) context.Context {
+        return context.WithValue(ctx, outgoingTagsKey{}, b)
+}
+
+// Tags returns the tags from the context for the inbound RPC.
+//
+// NOTE: this is provided only for backward compatibility with existing clients
+// and will likely be removed in an upcoming release.  New uses should transmit
+// this type of data using metadata with a different, non-reserved (i.e. does
+// not begin with "grpc-") header name.
+func Tags(ctx context.Context) []byte {
+        b, _ := ctx.Value(incomingTagsKey{}).([]byte)
+        return b
+}
+
+// SetIncomingTags attaches stats tagging data to the context, to be read by
+// the application (not sent in outgoing RPCs).
+//
+// This is intended for gRPC-internal use ONLY.
+func SetIncomingTags(ctx context.Context, b []byte) context.Context {
+        return context.WithValue(ctx, incomingTagsKey{}, b)
+}
+
+// OutgoingTags returns the tags from the context for the outbound RPC.
+//
+// This is intended for gRPC-internal use ONLY.
+func OutgoingTags(ctx context.Context) []byte {
+        b, _ := ctx.Value(outgoingTagsKey{}).([]byte)
+        return b
+}
+
+type incomingTraceKey struct{}
+type outgoingTraceKey struct{}
+
+// SetTrace attaches stats tagging data to the context, which will be sent in
+// the outgoing RPC with the header grpc-trace-bin.  Subsequent calls to
+// SetTrace will overwrite the values from earlier calls.
+//
+// NOTE: this is provided only for backward compatibility with existing clients
+// and will likely be removed in an upcoming release.  New uses should transmit
+// this type of data using metadata with a different, non-reserved (i.e. does
+// not begin with "grpc-") header name.
+func SetTrace(ctx context.Context, b []byte) context.Context {
+        return context.WithValue(ctx, outgoingTraceKey{}, b)
+}
+
+// Trace returns the trace from the context for the inbound RPC.
+//
+// NOTE: this is provided only for backward compatibility with existing clients
+// and will likely be removed in an upcoming release.  New uses should transmit
+// this type of data using metadata with a different, non-reserved (i.e. does
+// not begin with "grpc-") header name.
+func Trace(ctx context.Context) []byte {
+        b, _ := ctx.Value(incomingTraceKey{}).([]byte)
+        return b
+}
+
+// SetIncomingTrace attaches stats tagging data to the context, to be read by
+// the application (not sent in outgoing RPCs).  It is intended for
+// gRPC-internal use.
+func SetIncomingTrace(ctx context.Context, b []byte) context.Context {
+        return context.WithValue(ctx, incomingTraceKey{}, b)
+}
+
+// OutgoingTrace returns the trace from the context for the outbound RPC.  It is
+// intended for gRPC-internal use.
+func OutgoingTrace(ctx context.Context) []byte {
+        b, _ := ctx.Value(outgoingTraceKey{}).([]byte)
+        return b
+}
diff --git a/vendor/google.golang.org/grpc/status/status.go b/vendor/google.golang.org/grpc/status/status.go
index 871dc4b..ed36681 100644
--- a/vendor/google.golang.org/grpc/status/status.go
+++ b/vendor/google.golang.org/grpc/status/status.go
@@ -28,6 +28,7 @@
 package status
 
 import (
+        "context"
         "errors"
         "fmt"
 
@@ -46,7 +47,7 @@ func (se *statusError) Error() string {
         return fmt.Sprintf("rpc error: code = %s desc = %s", codes.Code(p.GetCode()), p.GetMessage())
 }
 
-func (se *statusError) status() *Status {
+func (se *statusError) GRPCStatus() *Status {
         return &Status{s: (*spb.Status)(se)}
 }
 
@@ -120,15 +121,25 @@ func FromProto(s *spb.Status) *Status {
 }
 
 // FromError returns a Status representing err if it was produced from this
-// package, otherwise it returns nil, false.
+// package or has a method `GRPCStatus() *Status`. Otherwise, ok is false and a
+// Status is returned with codes.Unknown and the original error message.
 func FromError(err error) (s *Status, ok bool) {
         if err == nil {
                 return &Status{s: &spb.Status{Code: int32(codes.OK)}}, true
         }
-        if s, ok := err.(*statusError); ok {
-                return s.status(), true
+        if se, ok := err.(interface {
+                GRPCStatus() *Status
+        }); ok {
+                return se.GRPCStatus(), true
         }
-        return nil, false
+        return New(codes.Unknown, err.Error()), false
+}
+
+// Convert is a convenience function which removes the need to handle the
+// boolean return value from FromError.
+func Convert(err error) *Status {
+        s, _ := FromError(err)
+        return s
 }
 
 // WithDetails returns a new status with the provided details messages appended to the status.
@@ -166,3 +177,34 @@ func (s *Status) Details() []interface{} {
         }
         return details
 }
+
+// Code returns the Code of the error if it is a Status error, codes.OK if err
+// is nil, or codes.Unknown otherwise.
+func Code(err error) codes.Code {
+        // Don't use FromError to avoid allocation of OK status.
+        if err == nil {
+                return codes.OK
+        }
+        if se, ok := err.(interface {
+                GRPCStatus() *Status
+        }); ok {
+                return se.GRPCStatus().Code()
+        }
+        return codes.Unknown
+}
+
+// FromContextError converts a context error into a Status.  It returns a
+// Status with codes.OK if err is nil, or a Status with codes.Unknown if err is
+// non-nil and not a context error.
+func FromContextError(err error) *Status {
+        switch err {
+        case nil:
+                return New(codes.OK, "")
+        case context.DeadlineExceeded:
+                return New(codes.DeadlineExceeded, err.Error())
+        case context.Canceled:
+                return New(codes.Canceled, err.Error())
+        default:
+                return New(codes.Unknown, err.Error())
+        }
+}
diff --git a/vendor/google.golang.org/grpc/stream.go b/vendor/google.golang.org/grpc/stream.go
index 1c621ba..d06279a 100644
--- a/vendor/google.golang.org/grpc/stream.go
+++ b/vendor/google.golang.org/grpc/stream.go
@@ -19,24 +19,35 @@
 package grpc
 
 import (
-        "bytes"
+        "context"
         "errors"
         "io"
+        "math"
+        "strconv"
         "sync"
         "time"
 
-        "golang.org/x/net/context"
         "golang.org/x/net/trace"
+        "google.golang.org/grpc/balancer"
         "google.golang.org/grpc/codes"
+        "google.golang.org/grpc/connectivity"
+        "google.golang.org/grpc/encoding"
+        "google.golang.org/grpc/grpclog"
+        "google.golang.org/grpc/internal/binarylog"
+        "google.golang.org/grpc/internal/channelz"
+        "google.golang.org/grpc/internal/grpcrand"
+        "google.golang.org/grpc/internal/transport"
         "google.golang.org/grpc/metadata"
         "google.golang.org/grpc/peer"
         "google.golang.org/grpc/stats"
         "google.golang.org/grpc/status"
-        "google.golang.org/grpc/transport"
 )
 
 // StreamHandler defines the handler called by gRPC server to complete the
-// execution of a streaming RPC.
+// execution of a streaming RPC. If a StreamHandler returns an error, it
+// should be produced by the status package, or else gRPC will use
+// codes.Unknown as the status code and err.Error() as the status message
+// of the RPC.
 type StreamHandler func(srv interface{}, stream ServerStream) error
 
 // StreamDesc represents a streaming RPC service's method specification.
@@ -50,30 +61,21 @@ type StreamDesc struct {
 }
 
 // Stream defines the common interface a client or server stream has to satisfy.
+//
+// Deprecated: See ClientStream and ServerStream documentation instead.
 type Stream interface {
-        // Context returns the context for this stream.
+        // Deprecated: See ClientStream and ServerStream documentation instead.
         Context() context.Context
-        // SendMsg blocks until it sends m, the stream is done or the stream
-        // breaks.
-        // On error, it aborts the stream and returns an RPC status on client
-        // side. On server side, it simply returns the error to the caller.
-        // SendMsg is called by generated code. Also Users can call SendMsg
-        // directly when it is really needed in their use cases.
-        // It's safe to have a goroutine calling SendMsg and another goroutine calling
-        // recvMsg on the same stream at the same time.
-        // But it is not safe to call SendMsg on the same stream in different goroutines.
+        // Deprecated: See ClientStream and ServerStream documentation instead.
         SendMsg(m interface{}) error
-        // RecvMsg blocks until it receives a message or the stream is
-        // done. On client side, it returns io.EOF when the stream is done. On
-        // any other error, it aborts the stream and returns an RPC status. On
-        // server side, it simply returns the error to the caller.
-        // It's safe to have a goroutine calling SendMsg and another goroutine calling
-        // recvMsg on the same stream at the same time.
-        // But it is not safe to call RecvMsg on the same stream in different goroutines.
+        // Deprecated: See ClientStream and ServerStream documentation instead.
         RecvMsg(m interface{}) error
 }
 
-// ClientStream defines the interface a client stream has to satisfy.
+// ClientStream defines the client-side behavior of a streaming RPC.
+//
+// All errors returned from ClientStream methods are compatible with the
+// status package.
 type ClientStream interface {
         // Header returns the header metadata received from the server if there
         // is any. It blocks if the metadata is not ready to read.
@@ -83,62 +85,147 @@ type ClientStream interface {
         // stream.Recv has returned a non-nil error (including io.EOF).
         Trailer() metadata.MD
         // CloseSend closes the send direction of the stream. It closes the stream
-        // when non-nil error is met.
+        // when non-nil error is met. It is also not safe to call CloseSend
+        // concurrently with SendMsg.
         CloseSend() error
-        // Stream.SendMsg() may return a non-nil error when something wrong happens sending
-        // the request. The returned error indicates the status of this sending, not the final
-        // status of the RPC.
-        // Always call Stream.RecvMsg() to get the final status if you care about the status of
-        // the RPC.
-        Stream
+        // Context returns the context for this stream.
+        //
+        // It should not be called until after Header or RecvMsg has returned. Once
+        // called, subsequent client-side retries are disabled.
+        Context() context.Context
+        // SendMsg is generally called by generated code. On error, SendMsg aborts
+        // the stream. If the error was generated by the client, the status is
+        // returned directly; otherwise, io.EOF is returned and the status of
+        // the stream may be discovered using RecvMsg.
+        //
+        // SendMsg blocks until:
+        //   - There is sufficient flow control to schedule m with the transport, or
+        //   - The stream is done, or
+        //   - The stream breaks.
+        //
+        // SendMsg does not wait until the message is received by the server. An
+        // untimely stream closure may result in lost messages. To ensure delivery,
+        // users should ensure the RPC completed successfully using RecvMsg.
+        //
+        // It is safe to have a goroutine calling SendMsg and another goroutine
+        // calling RecvMsg on the same stream at the same time, but it is not safe
+        // to call SendMsg on the same stream in different goroutines. It is also
+        // not safe to call CloseSend concurrently with SendMsg.
+        SendMsg(m interface{}) error
+        // RecvMsg blocks until it receives a message into m or the stream is
+        // done. It returns io.EOF when the stream completes successfully. On
+        // any other error, the stream is aborted and the error contains the RPC
+        // status.
+        //
+        // It is safe to have a goroutine calling SendMsg and another goroutine
+        // calling RecvMsg on the same stream at the same time, but it is not
+        // safe to call RecvMsg on the same stream in different goroutines.
+        RecvMsg(m interface{}) error
 }
 
-// NewClientStream creates a new Stream for the client side. This is called
-// by generated code.
-func NewClientStream(ctx context.Context, desc *StreamDesc, cc *ClientConn, method string, opts ...CallOption) (_ ClientStream, err error) {
+// NewStream creates a new Stream for the client side. This is typically
+// called by generated code. ctx is used for the lifetime of the stream.
+//
+// To ensure resources are not leaked due to the stream returned, one of the following
+// actions must be performed:
+//
+//      1. Call Close on the ClientConn.
+//      2. Cancel the context provided.
+//      3. Call RecvMsg until a non-nil error is returned. A protobuf-generated
+//         client-streaming RPC, for instance, might use the helper function
+//         CloseAndRecv (note that CloseSend does not Recv, therefore is not
+//         guaranteed to release all resources).
+//      4. Receive a non-nil, non-io.EOF error from Header or SendMsg.
+//
+// If none of the above happen, a goroutine and a context will be leaked, and grpc
+// will not call the optionally-configured stats handler with a stats.End message.
+func (cc *ClientConn) NewStream(ctx context.Context, desc *StreamDesc, method string, opts ...CallOption) (ClientStream, error) {
+        // allow interceptor to see all applicable call options, which means those
+        // configured as defaults from dial option as well as per-call options
+        opts = combine(cc.dopts.callOptions, opts)
+
         if cc.dopts.streamInt != nil {
                 return cc.dopts.streamInt(ctx, desc, cc, method, newClientStream, opts...)
         }
         return newClientStream(ctx, desc, cc, method, opts...)
 }
 
+// NewClientStream is a wrapper for ClientConn.NewStream.
+func NewClientStream(ctx context.Context, desc *StreamDesc, cc *ClientConn, method string, opts ...CallOption) (ClientStream, error) {
+        return cc.NewStream(ctx, desc, method, opts...)
+}
+
 func newClientStream(ctx context.Context, desc *StreamDesc, cc *ClientConn, method string, opts ...CallOption) (_ ClientStream, err error) {
-        var (
-                t      transport.ClientTransport
-                s      *transport.Stream
-                put    func()
-                cancel context.CancelFunc
-        )
-        c := defaultCallInfo
+        if channelz.IsOn() {
+                cc.incrCallsStarted()
+                defer func() {
+                        if err != nil {
+                                cc.incrCallsFailed()
+                        }
+                }()
+        }
+        c := defaultCallInfo()
+        // Provide an opportunity for the first RPC to see the first service config
+        // provided by the resolver.
+        if err := cc.waitForResolvedAddrs(ctx); err != nil {
+                return nil, err
+        }
         mc := cc.GetMethodConfig(method)
         if mc.WaitForReady != nil {
                 c.failFast = !*mc.WaitForReady
         }
 
-        if mc.Timeout != nil {
+        // Possible context leak:
+        // The cancel function for the child context we create will only be called
+        // when RecvMsg returns a non-nil error, if the ClientConn is closed, or if
+        // an error is generated by SendMsg.
+        // https://github.com/grpc/grpc-go/issues/1818.
+        var cancel context.CancelFunc
+        if mc.Timeout != nil && *mc.Timeout >= 0 {
                 ctx, cancel = context.WithTimeout(ctx, *mc.Timeout)
+        } else {
+                ctx, cancel = context.WithCancel(ctx)
         }
+        defer func() {
+                if err != nil {
+                        cancel()
+                }
+        }()
 
-        opts = append(cc.dopts.callOptions, opts...)
         for _, o := range opts {
-                if err := o.before(&c); err != nil {
+                if err := o.before(c); err != nil {
                         return nil, toRPCErr(err)
                 }
         }
         c.maxSendMessageSize = getMaxSize(mc.MaxReqSize, c.maxSendMessageSize, defaultClientMaxSendMessageSize)
         c.maxReceiveMessageSize = getMaxSize(mc.MaxRespSize, c.maxReceiveMessageSize, defaultClientMaxReceiveMessageSize)
+        if err := setCallInfoCodec(c); err != nil {
+                return nil, err
+        }
 
         callHdr := &transport.CallHdr{
-                Host:   cc.authority,
-                Method: method,
-                // If it's not client streaming, we should already have the request to be sent,
-                // so we don't flush the header.
-                // If it's client streaming, the user may never send a request or send it any
-                // time soon, so we ask the transport to flush the header.
-                Flush: desc.ClientStreams,
-        }
-        if cc.dopts.cp != nil {
+                Host:           cc.authority,
+                Method:         method,
+                ContentSubtype: c.contentSubtype,
+        }
+
+        // Set our outgoing compression according to the UseCompressor CallOption, if
+        // set.  In that case, also find the compressor from the encoding package.
+        // Otherwise, use the compressor configured by the WithCompressor DialOption,
+        // if set.
+        var cp Compressor
+        var comp encoding.Compressor
+        if ct := c.compressorType; ct != "" {
+                callHdr.SendCompress = ct
+                if ct != encoding.Identity {
+                        comp = encoding.GetCompressor(ct)
+                        if comp == nil {
+                                return nil, status.Errorf(codes.Internal, "grpc: Compressor is not installed for requested grpc-encoding %q", ct)
+                        }
+                }
+        } else if cc.dopts.cp != nil {
                 callHdr.SendCompress = cc.dopts.cp.Type()
+                cp = cc.dopts.cp
         }
         if c.creds != nil {
                 callHdr.Creds = c.creds
@@ -152,380 +239,1019 @@ func newClientStream(ctx context.Context, desc *StreamDesc, cc *ClientConn, meth
                 }
                 trInfo.tr.LazyLog(&trInfo.firstLine, false)
                 ctx = trace.NewContext(ctx, trInfo.tr)
-                defer func() {
-                        if err != nil {
-                                // Need to call tr.finish() if error is returned.
-                                // Because tr will not be returned to caller.
-                                trInfo.tr.LazyPrintf("RPC: [%v]", err)
-                                trInfo.tr.SetError()
-                                trInfo.tr.Finish()
-                        }
-                }()
         }
-        ctx = newContextWithRPCInfo(ctx)
+        ctx = newContextWithRPCInfo(ctx, c.failFast)
         sh := cc.dopts.copts.StatsHandler
+        var beginTime time.Time
         if sh != nil {
                 ctx = sh.TagRPC(ctx, &stats.RPCTagInfo{FullMethodName: method, FailFast: c.failFast})
+                beginTime = time.Now()
                 begin := &stats.Begin{
                         Client:    true,
-                        BeginTime: time.Now(),
+                        BeginTime: beginTime,
                         FailFast:  c.failFast,
                 }
                 sh.HandleRPC(ctx, begin)
-                defer func() {
-                        if err != nil {
-                                // Only handle end stats if err != nil.
-                                end := &stats.End{
-                                        Client: true,
-                                        Error:  err,
-                                }
-                                sh.HandleRPC(ctx, end)
-                        }
-                }()
         }
-        gopts := BalancerGetOptions{
-                BlockingWait: !c.failFast,
+
+        cs := &clientStream{
+                callHdr:      callHdr,
+                ctx:          ctx,
+                methodConfig: &mc,
+                opts:         opts,
+                callInfo:     c,
+                cc:           cc,
+                desc:         desc,
+                codec:        c.codec,
+                cp:           cp,
+                comp:         comp,
+                cancel:       cancel,
+                beginTime:    beginTime,
+                firstAttempt: true,
+        }
+        if !cc.dopts.disableRetry {
+                cs.retryThrottler = cc.retryThrottler.Load().(*retryThrottler)
         }
-        for {
-                t, put, err = cc.getTransport(ctx, gopts)
-                if err != nil {
-                        // TODO(zhaoq): Probably revisit the error handling.
-                        if _, ok := status.FromError(err); ok {
-                                return nil, err
-                        }
-                        if err == errConnClosing || err == errConnUnavailable {
-                                if c.failFast {
-                                        return nil, Errorf(codes.Unavailable, "%v", err)
-                                }
-                                continue
-                        }
-                        // All the other errors are treated as Internal errors.
-                        return nil, Errorf(codes.Internal, "%v", err)
-                }
+        cs.binlog = binarylog.GetMethodLogger(method)
 
-                s, err = t.NewStream(ctx, callHdr)
-                if err != nil {
-                        if _, ok := err.(transport.ConnectionError); ok && put != nil {
-                                // If error is connection error, transport was sending data on wire,
-                                // and we are not sure if anything has been sent on wire.
-                                // If error is not connection error, we are sure nothing has been sent.
-                                updateRPCInfoInContext(ctx, rpcInfo{bytesSent: true, bytesReceived: false})
-                        }
-                        if put != nil {
-                                put()
-                                put = nil
-                        }
-                        if _, ok := err.(transport.ConnectionError); (ok || err == transport.ErrStreamDrain) && !c.failFast {
-                                continue
+        cs.callInfo.stream = cs
+        // Only this initial attempt has stats/tracing.
+        // TODO(dfawley): move to newAttempt when per-attempt stats are implemented.
+        if err := cs.newAttemptLocked(sh, trInfo); err != nil {
+                cs.finish(err)
+                return nil, err
+        }
+
+        op := func(a *csAttempt) error { return a.newStream() }
+        if err := cs.withRetry(op, func() { cs.bufferForRetryLocked(0, op) }); err != nil {
+                cs.finish(err)
+                return nil, err
+        }
+
+        if cs.binlog != nil {
+                md, _ := metadata.FromOutgoingContext(ctx)
+                logEntry := &binarylog.ClientHeader{
+                        OnClientSide: true,
+                        Header:       md,
+                        MethodName:   method,
+                        Authority:    cs.cc.authority,
+                }
+                if deadline, ok := ctx.Deadline(); ok {
+                        logEntry.Timeout = deadline.Sub(time.Now())
+                        if logEntry.Timeout < 0 {
+                                logEntry.Timeout = 0
                         }
-                        return nil, toRPCErr(err)
                 }
-                break
+                cs.binlog.Log(logEntry)
         }
-        // Set callInfo.peer object from stream's context.
-        if peer, ok := peer.FromContext(s.Context()); ok {
-                c.peer = peer
+
+        if desc != unaryStreamDesc {
+                // Listen on cc and stream contexts to cleanup when the user closes the
+                // ClientConn or cancels the stream context.  In all other cases, an error
+                // should already be injected into the recv buffer by the transport, which
+                // the client will eventually receive, and then we will cancel the stream's
+                // context in clientStream.finish.
+                go func() {
+                        select {
+                        case <-cc.ctx.Done():
+                                cs.finish(ErrClientConnClosing)
+                        case <-ctx.Done():
+                                cs.finish(toRPCErr(ctx.Err()))
+                        }
+                }()
         }
-        cs := &clientStream{
-                opts:   opts,
-                c:      c,
-                desc:   desc,
-                codec:  cc.dopts.codec,
-                cp:     cc.dopts.cp,
-                dc:     cc.dopts.dc,
-                cancel: cancel,
-
-                put: put,
-                t:   t,
-                s:   s,
-                p:   &parser{r: s},
-
-                tracing: EnableTracing,
-                trInfo:  trInfo,
-
-                statsCtx:     ctx,
-                statsHandler: cc.dopts.copts.StatsHandler,
-        }
-        if cc.dopts.cp != nil {
-                cs.cbuf = new(bytes.Buffer)
-        }
-        // Listen on ctx.Done() to detect cancellation and s.Done() to detect normal termination
-        // when there is no pending I/O operations on this stream.
-        go func() {
-                select {
-                case <-t.Error():
-                        // Incur transport error, simply exit.
-                case <-cc.ctx.Done():
-                        cs.finish(ErrClientConnClosing)
-                        cs.closeTransportStream(ErrClientConnClosing)
-                case <-s.Done():
-                        // TODO: The trace of the RPC is terminated here when there is no pending
-                        // I/O, which is probably not the optimal solution.
-                        cs.finish(s.Status().Err())
-                        cs.closeTransportStream(nil)
-                case <-s.GoAway():
-                        cs.finish(errConnDrain)
-                        cs.closeTransportStream(errConnDrain)
-                case <-s.Context().Done():
-                        err := s.Context().Err()
-                        cs.finish(err)
-                        cs.closeTransportStream(transport.ContextErr(err))
-                }
-        }()
         return cs, nil
 }
 
+func (cs *clientStream) newAttemptLocked(sh stats.Handler, trInfo traceInfo) error {
+        cs.attempt = &csAttempt{
+                cs:           cs,
+                dc:           cs.cc.dopts.dc,
+                statsHandler: sh,
+                trInfo:       trInfo,
+        }
+
+        if err := cs.ctx.Err(); err != nil {
+                return toRPCErr(err)
+        }
+        t, done, err := cs.cc.getTransport(cs.ctx, cs.callInfo.failFast, cs.callHdr.Method)
+        if err != nil {
+                return err
+        }
+        cs.attempt.t = t
+        cs.attempt.done = done
+        return nil
+}
+
+func (a *csAttempt) newStream() error {
+        cs := a.cs
+        cs.callHdr.PreviousAttempts = cs.numRetries
+        s, err := a.t.NewStream(cs.ctx, cs.callHdr)
+        if err != nil {
+                return toRPCErr(err)
+        }
+        cs.attempt.s = s
+        cs.attempt.p = &parser{r: s}
+        return nil
+}
+
 // clientStream implements a client side Stream.
 type clientStream struct {
-        opts   []CallOption
-        c      callInfo
-        t      transport.ClientTransport
-        s      *transport.Stream
-        p      *parser
-        desc   *StreamDesc
-        codec  Codec
-        cp     Compressor
-        cbuf   *bytes.Buffer
-        dc     Decompressor
-        cancel context.CancelFunc
+        callHdr  *transport.CallHdr
+        opts     []CallOption
+        callInfo *callInfo
+        cc       *ClientConn
+        desc     *StreamDesc
+
+        codec baseCodec
+        cp    Compressor
+        comp  encoding.Compressor
+
+        cancel context.CancelFunc // cancels all attempts
+
+        sentLast  bool // sent an end stream
+        beginTime time.Time
+
+        methodConfig *MethodConfig
+
+        ctx context.Context // the application's context, wrapped by stats/tracing
 
-        tracing bool // set to EnableTracing when the clientStream is created.
+        retryThrottler *retryThrottler // The throttler active when the RPC began.
 
-        mu       sync.Mutex
-        put      func()
-        closed   bool
-        finished bool
-        // trInfo.tr is set when the clientStream is created (if EnableTracing is true),
-        // and is set to nil when the clientStream's finish method is called.
+        binlog *binarylog.MethodLogger // Binary logger, can be nil.
+        // serverHeaderBinlogged is a boolean for whether server header has been
+        // logged. Server header will be logged when the first time one of those
+        // happens: stream.Header(), stream.Recv().
+        //
+        // It's only read and used by Recv() and Header(), so it doesn't need to be
+        // synchronized.
+        serverHeaderBinlogged bool
+
+        mu                      sync.Mutex
+        firstAttempt            bool       // if true, transparent retry is valid
+        numRetries              int        // exclusive of transparent retry attempt(s)
+        numRetriesSincePushback int        // retries since pushback; to reset backoff
+        finished                bool       // TODO: replace with atomic cmpxchg or sync.Once?
+        attempt                 *csAttempt // the active client stream attempt
+        // TODO(hedging): hedging will have multiple attempts simultaneously.
+        committed  bool                       // active attempt committed for retry?
+        buffer     []func(a *csAttempt) error // operations to replay on retry
+        bufferSize int                        // current size of buffer
+}
+
+// csAttempt implements a single transport stream attempt within a
+// clientStream.
+type csAttempt struct {
+        cs   *clientStream
+        t    transport.ClientTransport
+        s    *transport.Stream
+        p    *parser
+        done func(balancer.DoneInfo)
+
+        finished  bool
+        dc        Decompressor
+        decomp    encoding.Compressor
+        decompSet bool
+
+        mu sync.Mutex // guards trInfo.tr
+        // trInfo.tr is set when created (if EnableTracing is true),
+        // and cleared when the finish method is called.
         trInfo traceInfo
 
-        // statsCtx keeps the user context for stats handling.
-        // All stats collection should use the statsCtx (instead of the stream context)
-        // so that all the generated stats for a particular RPC can be associated in the processing phase.
-        statsCtx     context.Context
         statsHandler stats.Handler
 }
 
+func (cs *clientStream) commitAttemptLocked() {
+        cs.committed = true
+        cs.buffer = nil
+}
+
+func (cs *clientStream) commitAttempt() {
+        cs.mu.Lock()
+        cs.commitAttemptLocked()
+        cs.mu.Unlock()
+}
+
+// shouldRetry returns nil if the RPC should be retried; otherwise it returns
+// the error that should be returned by the operation.
+func (cs *clientStream) shouldRetry(err error) error {
+        if cs.attempt.s == nil && !cs.callInfo.failFast {
+                // In the event of any error from NewStream (attempt.s == nil), we
+                // never attempted to write anything to the wire, so we can retry
+                // indefinitely for non-fail-fast RPCs.
+                return nil
+        }
+        if cs.finished || cs.committed {
+                // RPC is finished or committed; cannot retry.
+                return err
+        }
+        // Wait for the trailers.
+        if cs.attempt.s != nil {
+                <-cs.attempt.s.Done()
+        }
+        if cs.firstAttempt && !cs.callInfo.failFast && (cs.attempt.s == nil || cs.attempt.s.Unprocessed()) {
+                // First attempt, wait-for-ready, stream unprocessed: transparently retry.
+                cs.firstAttempt = false
+                return nil
+        }
+        cs.firstAttempt = false
+        if cs.cc.dopts.disableRetry {
+                return err
+        }
+
+        pushback := 0
+        hasPushback := false
+        if cs.attempt.s != nil {
+                if to, toErr := cs.attempt.s.TrailersOnly(); toErr != nil || !to {
+                        return err
+                }
+
+                // TODO(retry): Move down if the spec changes to not check server pushback
+                // before considering this a failure for throttling.
+                sps := cs.attempt.s.Trailer()["grpc-retry-pushback-ms"]
+                if len(sps) == 1 {
+                        var e error
+                        if pushback, e = strconv.Atoi(sps[0]); e != nil || pushback < 0 {
+                                grpclog.Infof("Server retry pushback specified to abort (%q).", sps[0])
+                                cs.retryThrottler.throttle() // This counts as a failure for throttling.
+                                return err
+                        }
+                        hasPushback = true
+                } else if len(sps) > 1 {
+                        grpclog.Warningf("Server retry pushback specified multiple values (%q); not retrying.", sps)
+                        cs.retryThrottler.throttle() // This counts as a failure for throttling.
+                        return err
+                }
+        }
+
+        var code codes.Code
+        if cs.attempt.s != nil {
+                code = cs.attempt.s.Status().Code()
+        } else {
+                code = status.Convert(err).Code()
+        }
+
+        rp := cs.methodConfig.retryPolicy
+        if rp == nil || !rp.retryableStatusCodes[code] {
+                return err
+        }
+
+        // Note: the ordering here is important; we count this as a failure
+        // only if the code matched a retryable code.
+        if cs.retryThrottler.throttle() {
+                return err
+        }
+        if cs.numRetries+1 >= rp.maxAttempts {
+                return err
+        }
+
+        var dur time.Duration
+        if hasPushback {
+                dur = time.Millisecond * time.Duration(pushback)
+                cs.numRetriesSincePushback = 0
+        } else {
+                fact := math.Pow(rp.backoffMultiplier, float64(cs.numRetriesSincePushback))
+                cur := float64(rp.initialBackoff) * fact
+                if max := float64(rp.maxBackoff); cur > max {
+                        cur = max
+                }
+                dur = time.Duration(grpcrand.Int63n(int64(cur)))
+                cs.numRetriesSincePushback++
+        }
+
+        // TODO(dfawley): we could eagerly fail here if dur puts us past the
+        // deadline, but unsure if it is worth doing.
+        t := time.NewTimer(dur)
+        select {
+        case <-t.C:
+                cs.numRetries++
+                return nil
+        case <-cs.ctx.Done():
+                t.Stop()
+                return status.FromContextError(cs.ctx.Err()).Err()
+        }
+}
+
+// Returns nil if a retry was performed and succeeded; error otherwise.
+func (cs *clientStream) retryLocked(lastErr error) error {
+        for {
+                cs.attempt.finish(lastErr)
+                if err := cs.shouldRetry(lastErr); err != nil {
+                        cs.commitAttemptLocked()
+                        return err
+                }
+                if err := cs.newAttemptLocked(nil, traceInfo{}); err != nil {
+                        return err
+                }
+                if lastErr = cs.replayBufferLocked(); lastErr == nil {
+                        return nil
+                }
+        }
+}
+
 func (cs *clientStream) Context() context.Context {
-        return cs.s.Context()
+        cs.commitAttempt()
+        // No need to lock before using attempt, since we know it is committed and
+        // cannot change.
+        return cs.attempt.s.Context()
+}
+
+func (cs *clientStream) withRetry(op func(a *csAttempt) error, onSuccess func()) error {
+        cs.mu.Lock()
+        for {
+                if cs.committed {
+                        cs.mu.Unlock()
+                        return op(cs.attempt)
+                }
+                a := cs.attempt
+                cs.mu.Unlock()
+                err := op(a)
+                cs.mu.Lock()
+                if a != cs.attempt {
+                        // We started another attempt already.
+                        continue
+                }
+                if err == io.EOF {
+                        <-a.s.Done()
+                }
+                if err == nil || (err == io.EOF && a.s.Status().Code() == codes.OK) {
+                        onSuccess()
+                        cs.mu.Unlock()
+                        return err
+                }
+                if err := cs.retryLocked(err); err != nil {
+                        cs.mu.Unlock()
+                        return err
+                }
+        }
 }
 
 func (cs *clientStream) Header() (metadata.MD, error) {
-        m, err := cs.s.Header()
+        var m metadata.MD
+        err := cs.withRetry(func(a *csAttempt) error {
+                var err error
+                m, err = a.s.Header()
+                return toRPCErr(err)
+        }, cs.commitAttemptLocked)
         if err != nil {
-                if _, ok := err.(transport.ConnectionError); !ok {
-                        cs.closeTransportStream(err)
+                cs.finish(err)
+                return nil, err
+        }
+        if cs.binlog != nil && !cs.serverHeaderBinlogged {
+                // Only log if binary log is on and header has not been logged.
+                logEntry := &binarylog.ServerHeader{
+                        OnClientSide: true,
+                        Header:       m,
+                        PeerAddr:     nil,
                 }
+                if peer, ok := peer.FromContext(cs.Context()); ok {
+                        logEntry.PeerAddr = peer.Addr
+                }
+                cs.binlog.Log(logEntry)
+                cs.serverHeaderBinlogged = true
         }
         return m, err
 }
 
 func (cs *clientStream) Trailer() metadata.MD {
-        return cs.s.Trailer()
+        // On RPC failure, we never need to retry, because usage requires that
+        // RecvMsg() returned a non-nil error before calling this function is valid.
+        // We would have retried earlier if necessary.
+        //
+        // Commit the attempt anyway, just in case users are not following those
+        // directions -- it will prevent races and should not meaningfully impact
+        // performance.
+        cs.commitAttempt()
+        if cs.attempt.s == nil {
+                return nil
+        }
+        return cs.attempt.s.Trailer()
 }
 
-func (cs *clientStream) SendMsg(m interface{}) (err error) {
-        if cs.tracing {
-                cs.mu.Lock()
-                if cs.trInfo.tr != nil {
-                        cs.trInfo.tr.LazyLog(&payload{sent: true, msg: m}, true)
+func (cs *clientStream) replayBufferLocked() error {
+        a := cs.attempt
+        for _, f := range cs.buffer {
+                if err := f(a); err != nil {
+                        return err
                 }
-                cs.mu.Unlock()
         }
-        // TODO Investigate how to signal the stats handling party.
-        // generate error stats if err != nil && err != io.EOF?
+        return nil
+}
+
+func (cs *clientStream) bufferForRetryLocked(sz int, op func(a *csAttempt) error) {
+        // Note: we still will buffer if retry is disabled (for transparent retries).
+        if cs.committed {
+                return
+        }
+        cs.bufferSize += sz
+        if cs.bufferSize > cs.callInfo.maxRetryRPCBufferSize {
+                cs.commitAttemptLocked()
+                return
+        }
+        cs.buffer = append(cs.buffer, op)
+}
+
+func (cs *clientStream) SendMsg(m interface{}) (err error) {
         defer func() {
-                if err != nil {
+                if err != nil && err != io.EOF {
+                        // Call finish on the client stream for errors generated by this SendMsg
+                        // call, as these indicate problems created by this client.  (Transport
+                        // errors are converted to an io.EOF error in csAttempt.sendMsg; the real
+                        // error will be returned from RecvMsg eventually in that case, or be
+                        // retried.)
                         cs.finish(err)
                 }
-                if err == nil {
-                        return
-                }
-                if err == io.EOF {
-                        // Specialize the process for server streaming. SendMesg is only called
-                        // once when creating the stream object. io.EOF needs to be skipped when
-                        // the rpc is early finished (before the stream object is created.).
-                        // TODO: It is probably better to move this into the generated code.
-                        if !cs.desc.ClientStreams && cs.desc.ServerStreams {
-                                err = nil
-                        }
-                        return
-                }
-                if _, ok := err.(transport.ConnectionError); !ok {
-                        cs.closeTransportStream(err)
-                }
-                err = toRPCErr(err)
         }()
-        var outPayload *stats.OutPayload
-        if cs.statsHandler != nil {
-                outPayload = &stats.OutPayload{
-                        Client: true,
-                }
+        if cs.sentLast {
+                return status.Errorf(codes.Internal, "SendMsg called after CloseSend")
         }
-        out, err := encode(cs.codec, m, cs.cp, cs.cbuf, outPayload)
-        defer func() {
-                if cs.cbuf != nil {
-                        cs.cbuf.Reset()
-                }
-        }()
+        if !cs.desc.ClientStreams {
+                cs.sentLast = true
+        }
+        data, err := encode(cs.codec, m)
         if err != nil {
                 return err
         }
-        if cs.c.maxSendMessageSize == nil {
-                return Errorf(codes.Internal, "callInfo maxSendMessageSize field uninitialized(nil)")
+        compData, err := compress(data, cs.cp, cs.comp)
+        if err != nil {
+                return err
         }
-        if len(out) > *cs.c.maxSendMessageSize {
-                return Errorf(codes.ResourceExhausted, "trying to send message larger than max (%d vs. %d)", len(out), *cs.c.maxSendMessageSize)
+        hdr, payload := msgHeader(data, compData)
+        // TODO(dfawley): should we be checking len(data) instead?
+        if len(payload) > *cs.callInfo.maxSendMessageSize {
+                return status.Errorf(codes.ResourceExhausted, "trying to send message larger than max (%d vs. %d)", len(payload), *cs.callInfo.maxSendMessageSize)
         }
-        err = cs.t.Write(cs.s, out, &transport.Options{Last: false})
-        if err == nil && outPayload != nil {
-                outPayload.SentTime = time.Now()
-                cs.statsHandler.HandleRPC(cs.statsCtx, outPayload)
+        msgBytes := data // Store the pointer before setting to nil. For binary logging.
+        op := func(a *csAttempt) error {
+                err := a.sendMsg(m, hdr, payload, data)
+                // nil out the message and uncomp when replaying; they are only needed for
+                // stats which is disabled for subsequent attempts.
+                m, data = nil, nil
+                return err
         }
-        return err
+        err = cs.withRetry(op, func() { cs.bufferForRetryLocked(len(hdr)+len(payload), op) })
+        if cs.binlog != nil && err == nil {
+                cs.binlog.Log(&binarylog.ClientMessage{
+                        OnClientSide: true,
+                        Message:      msgBytes,
+                })
+        }
+        return
 }
 
-func (cs *clientStream) RecvMsg(m interface{}) (err error) {
-        var inPayload *stats.InPayload
-        if cs.statsHandler != nil {
-                inPayload = &stats.InPayload{
-                        Client: true,
-                }
+func (cs *clientStream) RecvMsg(m interface{}) error {
+        if cs.binlog != nil && !cs.serverHeaderBinlogged {
+                // Call Header() to binary log header if it's not already logged.
+                cs.Header()
         }
-        if cs.c.maxReceiveMessageSize == nil {
-                return Errorf(codes.Internal, "callInfo maxReceiveMessageSize field uninitialized(nil)")
+        var recvInfo *payloadInfo
+        if cs.binlog != nil {
+                recvInfo = &payloadInfo{}
         }
-        err = recv(cs.p, cs.codec, cs.s, cs.dc, m, *cs.c.maxReceiveMessageSize, inPayload)
-        defer func() {
-                // err != nil indicates the termination of the stream.
-                if err != nil {
-                        cs.finish(err)
+        err := cs.withRetry(func(a *csAttempt) error {
+                return a.recvMsg(m, recvInfo)
+        }, cs.commitAttemptLocked)
+        if cs.binlog != nil && err == nil {
+                cs.binlog.Log(&binarylog.ServerMessage{
+                        OnClientSide: true,
+                        Message:      recvInfo.uncompressedBytes,
+                })
+        }
+        if err != nil || !cs.desc.ServerStreams {
+                // err != nil or non-server-streaming indicates end of stream.
+                cs.finish(err)
+
+                if cs.binlog != nil {
+                        // finish will not log Trailer. Log Trailer here.
+                        logEntry := &binarylog.ServerTrailer{
+                                OnClientSide: true,
+                                Trailer:      cs.Trailer(),
+                                Err:          err,
+                        }
+                        if logEntry.Err == io.EOF {
+                                logEntry.Err = nil
+                        }
+                        if peer, ok := peer.FromContext(cs.Context()); ok {
+                                logEntry.PeerAddr = peer.Addr
+                        }
+                        cs.binlog.Log(logEntry)
                 }
-        }()
+        }
+        return err
+}
+
+func (cs *clientStream) CloseSend() error {
+        if cs.sentLast {
+                // TODO: return an error and finish the stream instead, due to API misuse?
+                return nil
+        }
+        cs.sentLast = true
+        op := func(a *csAttempt) error {
+                a.t.Write(a.s, nil, nil, &transport.Options{Last: true})
+                // Always return nil; io.EOF is the only error that might make sense
+                // instead, but there is no need to signal the client to call RecvMsg
+                // as the only use left for the stream after CloseSend is to call
+                // RecvMsg.  This also matches historical behavior.
+                return nil
+        }
+        cs.withRetry(op, func() { cs.bufferForRetryLocked(0, op) })
+        if cs.binlog != nil {
+                cs.binlog.Log(&binarylog.ClientHalfClose{
+                        OnClientSide: true,
+                })
+        }
+        // We never returned an error here for reasons.
+        return nil
+}
+
+func (cs *clientStream) finish(err error) {
+        if err == io.EOF {
+                // Ending a stream with EOF indicates a success.
+                err = nil
+        }
+        cs.mu.Lock()
+        if cs.finished {
+                cs.mu.Unlock()
+                return
+        }
+        cs.finished = true
+        cs.commitAttemptLocked()
+        cs.mu.Unlock()
+        // For binary logging. only log cancel in finish (could be caused by RPC ctx
+        // canceled or ClientConn closed). Trailer will be logged in RecvMsg.
+        //
+        // Only one of cancel or trailer needs to be logged. In the cases where
+        // users don't call RecvMsg, users must have already canceled the RPC.
+        if cs.binlog != nil && status.Code(err) == codes.Canceled {
+                cs.binlog.Log(&binarylog.Cancel{
+                        OnClientSide: true,
+                })
+        }
         if err == nil {
-                if cs.tracing {
-                        cs.mu.Lock()
-                        if cs.trInfo.tr != nil {
-                                cs.trInfo.tr.LazyLog(&payload{sent: false, msg: m}, true)
-                        }
-                        cs.mu.Unlock()
+                cs.retryThrottler.successfulRPC()
+        }
+        if channelz.IsOn() {
+                if err != nil {
+                        cs.cc.incrCallsFailed()
+                } else {
+                        cs.cc.incrCallsSucceeded()
                 }
-                if inPayload != nil {
-                        cs.statsHandler.HandleRPC(cs.statsCtx, inPayload)
+        }
+        if cs.attempt != nil {
+                cs.attempt.finish(err)
+        }
+        // after functions all rely upon having a stream.
+        if cs.attempt.s != nil {
+                for _, o := range cs.opts {
+                        o.after(cs.callInfo)
                 }
-                if !cs.desc.ClientStreams || cs.desc.ServerStreams {
-                        return
+        }
+        cs.cancel()
+}
+
+func (a *csAttempt) sendMsg(m interface{}, hdr, payld, data []byte) error {
+        cs := a.cs
+        if EnableTracing {
+                a.mu.Lock()
+                if a.trInfo.tr != nil {
+                        a.trInfo.tr.LazyLog(&payload{sent: true, msg: m}, true)
                 }
-                // Special handling for client streaming rpc.
-                // This recv expects EOF or errors, so we don't collect inPayload.
-                if cs.c.maxReceiveMessageSize == nil {
-                        return Errorf(codes.Internal, "callInfo maxReceiveMessageSize field uninitialized(nil)")
+                a.mu.Unlock()
+        }
+        if err := a.t.Write(a.s, hdr, payld, &transport.Options{Last: !cs.desc.ClientStreams}); err != nil {
+                if !cs.desc.ClientStreams {
+                        // For non-client-streaming RPCs, we return nil instead of EOF on error
+                        // because the generated code requires it.  finish is not called; RecvMsg()
+                        // will call it with the stream's status independently.
+                        return nil
                 }
-                err = recv(cs.p, cs.codec, cs.s, cs.dc, m, *cs.c.maxReceiveMessageSize, nil)
-                cs.closeTransportStream(err)
-                if err == nil {
-                        return toRPCErr(errors.New("grpc: client streaming protocol violation: get <nil>, want <EOF>"))
+                return io.EOF
+        }
+        if a.statsHandler != nil {
+                a.statsHandler.HandleRPC(cs.ctx, outPayload(true, m, data, payld, time.Now()))
+        }
+        if channelz.IsOn() {
+                a.t.IncrMsgSent()
+        }
+        return nil
+}
+
+func (a *csAttempt) recvMsg(m interface{}, payInfo *payloadInfo) (err error) {
+        cs := a.cs
+        if a.statsHandler != nil && payInfo == nil {
+                payInfo = &payloadInfo{}
+        }
+
+        if !a.decompSet {
+                // Block until we receive headers containing received message encoding.
+                if ct := a.s.RecvCompress(); ct != "" && ct != encoding.Identity {
+                        if a.dc == nil || a.dc.Type() != ct {
+                                // No configured decompressor, or it does not match the incoming
+                                // message encoding; attempt to find a registered compressor that does.
+                                a.dc = nil
+                                a.decomp = encoding.GetCompressor(ct)
+                        }
+                } else {
+                        // No compression is used; disable our decompressor.
+                        a.dc = nil
                 }
+                // Only initialize this state once per stream.
+                a.decompSet = true
+        }
+        err = recv(a.p, cs.codec, a.s, a.dc, m, *cs.callInfo.maxReceiveMessageSize, payInfo, a.decomp)
+        if err != nil {
                 if err == io.EOF {
-                        if se := cs.s.Status().Err(); se != nil {
-                                return se
+                        if statusErr := a.s.Status().Err(); statusErr != nil {
+                                return statusErr
                         }
-                        cs.finish(err)
-                        return nil
+                        return io.EOF // indicates successful end of stream.
                 }
                 return toRPCErr(err)
         }
-        if _, ok := err.(transport.ConnectionError); !ok {
-                cs.closeTransportStream(err)
+        if EnableTracing {
+                a.mu.Lock()
+                if a.trInfo.tr != nil {
+                        a.trInfo.tr.LazyLog(&payload{sent: false, msg: m}, true)
+                }
+                a.mu.Unlock()
+        }
+        if a.statsHandler != nil {
+                a.statsHandler.HandleRPC(cs.ctx, &stats.InPayload{
+                        Client:   true,
+                        RecvTime: time.Now(),
+                        Payload:  m,
+                        // TODO truncate large payload.
+                        Data:   payInfo.uncompressedBytes,
+                        Length: len(payInfo.uncompressedBytes),
+                })
+        }
+        if channelz.IsOn() {
+                a.t.IncrMsgRecv()
+        }
+        if cs.desc.ServerStreams {
+                // Subsequent messages should be received by subsequent RecvMsg calls.
+                return nil
+        }
+        // Special handling for non-server-stream rpcs.
+        // This recv expects EOF or errors, so we don't collect inPayload.
+        err = recv(a.p, cs.codec, a.s, a.dc, m, *cs.callInfo.maxReceiveMessageSize, nil, a.decomp)
+        if err == nil {
+                return toRPCErr(errors.New("grpc: client streaming protocol violation: get <nil>, want <EOF>"))
         }
         if err == io.EOF {
-                if statusErr := cs.s.Status().Err(); statusErr != nil {
-                        return statusErr
-                }
-                // Returns io.EOF to indicate the end of the stream.
-                return
+                return a.s.Status().Err() // non-server streaming Recv returns nil on success
         }
         return toRPCErr(err)
 }
 
-func (cs *clientStream) CloseSend() (err error) {
-        err = cs.t.Write(cs.s, nil, &transport.Options{Last: true})
+func (a *csAttempt) finish(err error) {
+        a.mu.Lock()
+        if a.finished {
+                a.mu.Unlock()
+                return
+        }
+        a.finished = true
+        if err == io.EOF {
+                // Ending a stream with EOF indicates a success.
+                err = nil
+        }
+        if a.s != nil {
+                a.t.CloseStream(a.s, err)
+        }
+
+        if a.done != nil {
+                br := false
+                var tr metadata.MD
+                if a.s != nil {
+                        br = a.s.BytesReceived()
+                        tr = a.s.Trailer()
+                }
+                a.done(balancer.DoneInfo{
+                        Err:           err,
+                        Trailer:       tr,
+                        BytesSent:     a.s != nil,
+                        BytesReceived: br,
+                })
+        }
+        if a.statsHandler != nil {
+                end := &stats.End{
+                        Client:    true,
+                        BeginTime: a.cs.beginTime,
+                        EndTime:   time.Now(),
+                        Error:     err,
+                }
+                a.statsHandler.HandleRPC(a.cs.ctx, end)
+        }
+        if a.trInfo.tr != nil {
+                if err == nil {
+                        a.trInfo.tr.LazyPrintf("RPC: [OK]")
+                } else {
+                        a.trInfo.tr.LazyPrintf("RPC: [%v]", err)
+                        a.trInfo.tr.SetError()
+                }
+                a.trInfo.tr.Finish()
+                a.trInfo.tr = nil
+        }
+        a.mu.Unlock()
+}
+
+func (ac *addrConn) newClientStream(ctx context.Context, desc *StreamDesc, method string, t transport.ClientTransport, opts ...CallOption) (_ ClientStream, err error) {
+        ac.mu.Lock()
+        if ac.transport != t {
+                ac.mu.Unlock()
+                return nil, status.Error(codes.Canceled, "the provided transport is no longer valid to use")
+        }
+        // transition to CONNECTING state when an attempt starts
+        if ac.state != connectivity.Connecting {
+                ac.updateConnectivityState(connectivity.Connecting)
+                ac.cc.handleSubConnStateChange(ac.acbw, ac.state)
+        }
+        ac.mu.Unlock()
+
+        if t == nil {
+                // TODO: return RPC error here?
+                return nil, errors.New("transport provided is nil")
+        }
+        // defaultCallInfo contains unnecessary info(i.e. failfast, maxRetryRPCBufferSize), so we just initialize an empty struct.
+        c := &callInfo{}
+
+        for _, o := range opts {
+                if err := o.before(c); err != nil {
+                        return nil, toRPCErr(err)
+                }
+        }
+        c.maxReceiveMessageSize = getMaxSize(nil, c.maxReceiveMessageSize, defaultClientMaxReceiveMessageSize)
+        c.maxSendMessageSize = getMaxSize(nil, c.maxSendMessageSize, defaultServerMaxSendMessageSize)
+
+        // Possible context leak:
+        // The cancel function for the child context we create will only be called
+        // when RecvMsg returns a non-nil error, if the ClientConn is closed, or if
+        // an error is generated by SendMsg.
+        // https://github.com/grpc/grpc-go/issues/1818.
+        ctx, cancel := context.WithCancel(ctx)
         defer func() {
                 if err != nil {
-                        cs.finish(err)
+                        cancel()
                 }
         }()
-        if err == nil || err == io.EOF {
-                return nil
+
+        if err := setCallInfoCodec(c); err != nil {
+                return nil, err
         }
-        if _, ok := err.(transport.ConnectionError); !ok {
-                cs.closeTransportStream(err)
+
+        callHdr := &transport.CallHdr{
+                Host:           ac.cc.authority,
+                Method:         method,
+                ContentSubtype: c.contentSubtype,
         }
-        err = toRPCErr(err)
-        return
+
+        // Set our outgoing compression according to the UseCompressor CallOption, if
+        // set.  In that case, also find the compressor from the encoding package.
+        // Otherwise, use the compressor configured by the WithCompressor DialOption,
+        // if set.
+        var cp Compressor
+        var comp encoding.Compressor
+        if ct := c.compressorType; ct != "" {
+                callHdr.SendCompress = ct
+                if ct != encoding.Identity {
+                        comp = encoding.GetCompressor(ct)
+                        if comp == nil {
+                                return nil, status.Errorf(codes.Internal, "grpc: Compressor is not installed for requested grpc-encoding %q", ct)
+                        }
+                }
+        } else if ac.cc.dopts.cp != nil {
+                callHdr.SendCompress = ac.cc.dopts.cp.Type()
+                cp = ac.cc.dopts.cp
+        }
+        if c.creds != nil {
+                callHdr.Creds = c.creds
+        }
+
+        as := &addrConnStream{
+                callHdr:  callHdr,
+                ac:       ac,
+                ctx:      ctx,
+                cancel:   cancel,
+                opts:     opts,
+                callInfo: c,
+                desc:     desc,
+                codec:    c.codec,
+                cp:       cp,
+                comp:     comp,
+                t:        t,
+        }
+
+        as.callInfo.stream = as
+        s, err := as.t.NewStream(as.ctx, as.callHdr)
+        if err != nil {
+                err = toRPCErr(err)
+                return nil, err
+        }
+        as.s = s
+        as.p = &parser{r: s}
+        ac.incrCallsStarted()
+        if desc != unaryStreamDesc {
+                // Listen on cc and stream contexts to cleanup when the user closes the
+                // ClientConn or cancels the stream context.  In all other cases, an error
+                // should already be injected into the recv buffer by the transport, which
+                // the client will eventually receive, and then we will cancel the stream's
+                // context in clientStream.finish.
+                go func() {
+                        select {
+                        case <-ac.ctx.Done():
+                                as.finish(status.Error(codes.Canceled, "grpc: the SubConn is closing"))
+                        case <-ctx.Done():
+                                as.finish(toRPCErr(ctx.Err()))
+                        }
+                }()
+        }
+        return as, nil
 }
 
-func (cs *clientStream) closeTransportStream(err error) {
-        cs.mu.Lock()
-        if cs.closed {
-                cs.mu.Unlock()
-                return
+type addrConnStream struct {
+        s         *transport.Stream
+        ac        *addrConn
+        callHdr   *transport.CallHdr
+        cancel    context.CancelFunc
+        opts      []CallOption
+        callInfo  *callInfo
+        t         transport.ClientTransport
+        ctx       context.Context
+        sentLast  bool
+        desc      *StreamDesc
+        codec     baseCodec
+        cp        Compressor
+        comp      encoding.Compressor
+        decompSet bool
+        dc        Decompressor
+        decomp    encoding.Compressor
+        p         *parser
+        done      func(balancer.DoneInfo)
+        mu        sync.Mutex
+        finished  bool
+}
+
+func (as *addrConnStream) Header() (metadata.MD, error) {
+        m, err := as.s.Header()
+        if err != nil {
+                as.finish(toRPCErr(err))
         }
-        cs.closed = true
-        cs.mu.Unlock()
-        cs.t.CloseStream(cs.s, err)
+        return m, err
 }
 
-func (cs *clientStream) finish(err error) {
-        cs.mu.Lock()
-        defer cs.mu.Unlock()
-        if cs.finished {
-                return
+func (as *addrConnStream) Trailer() metadata.MD {
+        return as.s.Trailer()
+}
+
+func (as *addrConnStream) CloseSend() error {
+        if as.sentLast {
+                // TODO: return an error and finish the stream instead, due to API misuse?
+                return nil
         }
-        cs.finished = true
+        as.sentLast = true
+
+        as.t.Write(as.s, nil, nil, &transport.Options{Last: true})
+        // Always return nil; io.EOF is the only error that might make sense
+        // instead, but there is no need to signal the client to call RecvMsg
+        // as the only use left for the stream after CloseSend is to call
+        // RecvMsg.  This also matches historical behavior.
+        return nil
+}
+
+func (as *addrConnStream) Context() context.Context {
+        return as.s.Context()
+}
+
+func (as *addrConnStream) SendMsg(m interface{}) (err error) {
         defer func() {
-                if cs.cancel != nil {
-                        cs.cancel()
+                if err != nil && err != io.EOF {
+                        // Call finish on the client stream for errors generated by this SendMsg
+                        // call, as these indicate problems created by this client.  (Transport
+                        // errors are converted to an io.EOF error in csAttempt.sendMsg; the real
+                        // error will be returned from RecvMsg eventually in that case, or be
+                        // retried.)
+                        as.finish(err)
                 }
         }()
-        for _, o := range cs.opts {
-                o.after(&cs.c)
+        if as.sentLast {
+                return status.Errorf(codes.Internal, "SendMsg called after CloseSend")
         }
-        if cs.put != nil {
-                updateRPCInfoInContext(cs.s.Context(), rpcInfo{
-                        bytesSent:     cs.s.BytesSent(),
-                        bytesReceived: cs.s.BytesReceived(),
-                })
-                cs.put()
-                cs.put = nil
+        if !as.desc.ClientStreams {
+                as.sentLast = true
         }
-        if cs.statsHandler != nil {
-                end := &stats.End{
-                        Client:  true,
-                        EndTime: time.Now(),
-                }
-                if err != io.EOF {
-                        // end.Error is nil if the RPC finished successfully.
-                        end.Error = toRPCErr(err)
+        data, err := encode(as.codec, m)
+        if err != nil {
+                return err
+        }
+        compData, err := compress(data, as.cp, as.comp)
+        if err != nil {
+                return err
+        }
+        hdr, payld := msgHeader(data, compData)
+        // TODO(dfawley): should we be checking len(data) instead?
+        if len(payld) > *as.callInfo.maxSendMessageSize {
+                return status.Errorf(codes.ResourceExhausted, "trying to send message larger than max (%d vs. %d)", len(payld), *as.callInfo.maxSendMessageSize)
+        }
+
+        if err := as.t.Write(as.s, hdr, payld, &transport.Options{Last: !as.desc.ClientStreams}); err != nil {
+                if !as.desc.ClientStreams {
+                        // For non-client-streaming RPCs, we return nil instead of EOF on error
+                        // because the generated code requires it.  finish is not called; RecvMsg()
+                        // will call it with the stream's status independently.
+                        return nil
                 }
-                cs.statsHandler.HandleRPC(cs.statsCtx, end)
+                return io.EOF
         }
-        if !cs.tracing {
-                return
+
+        if channelz.IsOn() {
+                as.t.IncrMsgSent()
         }
-        if cs.trInfo.tr != nil {
-                if err == nil || err == io.EOF {
-                        cs.trInfo.tr.LazyPrintf("RPC: [OK]")
+        return nil
+}
+
+func (as *addrConnStream) RecvMsg(m interface{}) (err error) {
+        defer func() {
+                if err != nil || !as.desc.ServerStreams {
+                        // err != nil or non-server-streaming indicates end of stream.
+                        as.finish(err)
+                }
+        }()
+
+        if !as.decompSet {
+                // Block until we receive headers containing received message encoding.
+                if ct := as.s.RecvCompress(); ct != "" && ct != encoding.Identity {
+                        if as.dc == nil || as.dc.Type() != ct {
+                                // No configured decompressor, or it does not match the incoming
+                                // message encoding; attempt to find a registered compressor that does.
+                                as.dc = nil
+                                as.decomp = encoding.GetCompressor(ct)
+                        }
                 } else {
-                        cs.trInfo.tr.LazyPrintf("RPC: [%v]", err)
-                        cs.trInfo.tr.SetError()
+                        // No compression is used; disable our decompressor.
+                        as.dc = nil
                 }
-                cs.trInfo.tr.Finish()
-                cs.trInfo.tr = nil
+                // Only initialize this state once per stream.
+                as.decompSet = true
+        }
+        err = recv(as.p, as.codec, as.s, as.dc, m, *as.callInfo.maxReceiveMessageSize, nil, as.decomp)
+        if err != nil {
+                if err == io.EOF {
+                        if statusErr := as.s.Status().Err(); statusErr != nil {
+                                return statusErr
+                        }
+                        return io.EOF // indicates successful end of stream.
+                }
+                return toRPCErr(err)
+        }
+
+        if channelz.IsOn() {
+                as.t.IncrMsgRecv()
         }
+        if as.desc.ServerStreams {
+                // Subsequent messages should be received by subsequent RecvMsg calls.
+                return nil
+        }
+
+        // Special handling for non-server-stream rpcs.
+        // This recv expects EOF or errors, so we don't collect inPayload.
+        err = recv(as.p, as.codec, as.s, as.dc, m, *as.callInfo.maxReceiveMessageSize, nil, as.decomp)
+        if err == nil {
+                return toRPCErr(errors.New("grpc: client streaming protocol violation: get <nil>, want <EOF>"))
+        }
+        if err == io.EOF {
+                return as.s.Status().Err() // non-server streaming Recv returns nil on success
+        }
+        return toRPCErr(err)
 }
 
-// ServerStream defines the interface a server stream has to satisfy.
+func (as *addrConnStream) finish(err error) {
+        as.mu.Lock()
+        if as.finished {
+                as.mu.Unlock()
+                return
+        }
+        as.finished = true
+        if err == io.EOF {
+                // Ending a stream with EOF indicates a success.
+                err = nil
+        }
+        if as.s != nil {
+                as.t.CloseStream(as.s, err)
+        }
+
+        if err != nil {
+                as.ac.incrCallsFailed()
+        } else {
+                as.ac.incrCallsSucceeded()
+        }
+        as.cancel()
+        as.mu.Unlock()
+}
+
+// ServerStream defines the server-side behavior of a streaming RPC.
+//
+// All errors returned from ServerStream methods are compatible with the
+// status package.
 type ServerStream interface {
         // SetHeader sets the header metadata. It may be called multiple times.
         // When call multiple times, all the provided metadata will be merged.
@@ -541,29 +1267,67 @@ type ServerStream interface {
         // SetTrailer sets the trailer metadata which will be sent with the RPC status.
         // When called more than once, all the provided metadata will be merged.
         SetTrailer(metadata.MD)
-        Stream
+        // Context returns the context for this stream.
+        Context() context.Context
+        // SendMsg sends a message. On error, SendMsg aborts the stream and the
+        // error is returned directly.
+        //
+        // SendMsg blocks until:
+        //   - There is sufficient flow control to schedule m with the transport, or
+        //   - The stream is done, or
+        //   - The stream breaks.
+        //
+        // SendMsg does not wait until the message is received by the client. An
+        // untimely stream closure may result in lost messages.
+        //
+        // It is safe to have a goroutine calling SendMsg and another goroutine
+        // calling RecvMsg on the same stream at the same time, but it is not safe
+        // to call SendMsg on the same stream in different goroutines.
+        SendMsg(m interface{}) error
+        // RecvMsg blocks until it receives a message into m or the stream is
+        // done. It returns io.EOF when the client has performed a CloseSend. On
+        // any non-EOF error, the stream is aborted and the error contains the
+        // RPC status.
+        //
+        // It is safe to have a goroutine calling SendMsg and another goroutine
+        // calling RecvMsg on the same stream at the same time, but it is not
+        // safe to call RecvMsg on the same stream in different goroutines.
+        RecvMsg(m interface{}) error
 }
 
 // serverStream implements a server side Stream.
 type serverStream struct {
-        t                     transport.ServerTransport
-        s                     *transport.Stream
-        p                     *parser
-        codec                 Codec
-        cp                    Compressor
-        dc                    Decompressor
-        cbuf                  *bytes.Buffer
+        ctx   context.Context
+        t     transport.ServerTransport
+        s     *transport.Stream
+        p     *parser
+        codec baseCodec
+
+        cp     Compressor
+        dc     Decompressor
+        comp   encoding.Compressor
+        decomp encoding.Compressor
+
         maxReceiveMessageSize int
         maxSendMessageSize    int
         trInfo                *traceInfo
 
         statsHandler stats.Handler
 
+        binlog *binarylog.MethodLogger
+        // serverHeaderBinlogged indicates whether server header has been logged. It
+        // will happen when one of the following two happens: stream.SendHeader(),
+        // stream.Send().
+        //
+        // It's only checked in send and sendHeader, doesn't need to be
+        // synchronized.
+        serverHeaderBinlogged bool
+
         mu sync.Mutex // protects trInfo.tr after the service handler runs.
 }
 
 func (ss *serverStream) Context() context.Context {
-        return ss.s.Context()
+        return ss.ctx
 }
 
 func (ss *serverStream) SetHeader(md metadata.MD) error {
@@ -574,7 +1338,15 @@ func (ss *serverStream) SetHeader(md metadata.MD) error {
 }
 
 func (ss *serverStream) SendHeader(md metadata.MD) error {
-        return ss.t.WriteHeader(ss.s, md)
+        err := ss.t.WriteHeader(ss.s, md)
+        if ss.binlog != nil && !ss.serverHeaderBinlogged {
+                h, _ := ss.s.Header()
+                ss.binlog.Log(&binarylog.ServerHeader{
+                        Header: h,
+                })
+                ss.serverHeaderBinlogged = true
+        }
+        return err
 }
 
 func (ss *serverStream) SetTrailer(md metadata.MD) {
@@ -582,7 +1354,6 @@ func (ss *serverStream) SetTrailer(md metadata.MD) {
                 return
         }
         ss.s.SetTrailer(md)
-        return
 }
 
 func (ss *serverStream) SendMsg(m interface{}) (err error) {
@@ -599,29 +1370,50 @@ func (ss *serverStream) SendMsg(m interface{}) (err error) {
                         }
                         ss.mu.Unlock()
                 }
-        }()
-        var outPayload *stats.OutPayload
-        if ss.statsHandler != nil {
-                outPayload = &stats.OutPayload{}
-        }
-        out, err := encode(ss.codec, m, ss.cp, ss.cbuf, outPayload)
-        defer func() {
-                if ss.cbuf != nil {
-                        ss.cbuf.Reset()
+                if err != nil && err != io.EOF {
+                        st, _ := status.FromError(toRPCErr(err))
+                        ss.t.WriteStatus(ss.s, st)
+                        // Non-user specified status was sent out. This should be an error
+                        // case (as a server side Cancel maybe).
+                        //
+                        // This is not handled specifically now. User will return a final
+                        // status from the service handler, we will log that error instead.
+                        // This behavior is similar to an interceptor.
+                }
+                if channelz.IsOn() && err == nil {
+                        ss.t.IncrMsgSent()
                 }
         }()
+        data, err := encode(ss.codec, m)
+        if err != nil {
+                return err
+        }
+        compData, err := compress(data, ss.cp, ss.comp)
         if err != nil {
                 return err
         }
-        if len(out) > ss.maxSendMessageSize {
-                return Errorf(codes.ResourceExhausted, "trying to send message larger than max (%d vs. %d)", len(out), ss.maxSendMessageSize)
+        hdr, payload := msgHeader(data, compData)
+        // TODO(dfawley): should we be checking len(data) instead?
+        if len(payload) > ss.maxSendMessageSize {
+                return status.Errorf(codes.ResourceExhausted, "trying to send message larger than max (%d vs. %d)", len(payload), ss.maxSendMessageSize)
         }
-        if err := ss.t.Write(ss.s, out, &transport.Options{Last: false}); err != nil {
+        if err := ss.t.Write(ss.s, hdr, payload, &transport.Options{Last: false}); err != nil {
                 return toRPCErr(err)
         }
-        if outPayload != nil {
-                outPayload.SentTime = time.Now()
-                ss.statsHandler.HandleRPC(ss.s.Context(), outPayload)
+        if ss.binlog != nil {
+                if !ss.serverHeaderBinlogged {
+                        h, _ := ss.s.Header()
+                        ss.binlog.Log(&binarylog.ServerHeader{
+                                Header: h,
+                        })
+                        ss.serverHeaderBinlogged = true
+                }
+                ss.binlog.Log(&binarylog.ServerMessage{
+                        Message: data,
+                })
+        }
+        if ss.statsHandler != nil {
+                ss.statsHandler.HandleRPC(ss.s.Context(), outPayload(false, m, data, payload, time.Now()))
         }
         return nil
 }
@@ -640,22 +1432,55 @@ func (ss *serverStream) RecvMsg(m interface{}) (err error) {
                         }
                         ss.mu.Unlock()
                 }
+                if err != nil && err != io.EOF {
+                        st, _ := status.FromError(toRPCErr(err))
+                        ss.t.WriteStatus(ss.s, st)
+                        // Non-user specified status was sent out. This should be an error
+                        // case (as a server side Cancel maybe).
+                        //
+                        // This is not handled specifically now. User will return a final
+                        // status from the service handler, we will log that error instead.
+                        // This behavior is similar to an interceptor.
+                }
+                if channelz.IsOn() && err == nil {
+                        ss.t.IncrMsgRecv()
+                }
         }()
-        var inPayload *stats.InPayload
-        if ss.statsHandler != nil {
-                inPayload = &stats.InPayload{}
+        var payInfo *payloadInfo
+        if ss.statsHandler != nil || ss.binlog != nil {
+                payInfo = &payloadInfo{}
         }
-        if err := recv(ss.p, ss.codec, ss.s, ss.dc, m, ss.maxReceiveMessageSize, inPayload); err != nil {
+        if err := recv(ss.p, ss.codec, ss.s, ss.dc, m, ss.maxReceiveMessageSize, payInfo, ss.decomp); err != nil {
                 if err == io.EOF {
+                        if ss.binlog != nil {
+                                ss.binlog.Log(&binarylog.ClientHalfClose{})
+                        }
                         return err
                 }
                 if err == io.ErrUnexpectedEOF {
-                        err = Errorf(codes.Internal, io.ErrUnexpectedEOF.Error())
+                        err = status.Errorf(codes.Internal, io.ErrUnexpectedEOF.Error())
                 }
                 return toRPCErr(err)
         }
-        if inPayload != nil {
-                ss.statsHandler.HandleRPC(ss.s.Context(), inPayload)
+        if ss.statsHandler != nil {
+                ss.statsHandler.HandleRPC(ss.s.Context(), &stats.InPayload{
+                        RecvTime: time.Now(),
+                        Payload:  m,
+                        // TODO truncate large payload.
+                        Data:   payInfo.uncompressedBytes,
+                        Length: len(payInfo.uncompressedBytes),
+                })
+        }
+        if ss.binlog != nil {
+                ss.binlog.Log(&binarylog.ClientMessage{
+                        Message: payInfo.uncompressedBytes,
+                })
         }
         return nil
 }
+
+// MethodFromServerStream returns the method string for the input stream.
+// The returned string is in the format of "/service/method".
+func MethodFromServerStream(stream ServerStream) (string, bool) {
+        return Method(stream.Context())
+}
diff --git a/vendor/google.golang.org/grpc/tap/tap.go b/vendor/google.golang.org/grpc/tap/tap.go
index decb678..584360f 100644
--- a/vendor/google.golang.org/grpc/tap/tap.go
+++ b/vendor/google.golang.org/grpc/tap/tap.go
@@ -21,7 +21,7 @@
 package tap
 
 import (
-        "golang.org/x/net/context"
+        "context"
 )
 
 // Info defines the relevant information needed by the handles.
@@ -32,8 +32,20 @@ type Info struct {
         // TODO: More to be added.
 }
 
-// ServerInHandle defines the function which runs when a new stream is created
-// on the server side. Note that it is executed in the per-connection I/O goroutine(s) instead
-// of per-RPC goroutine. Therefore, users should NOT have any blocking/time-consuming
-// work in this handle. Otherwise all the RPCs would slow down.
+// ServerInHandle defines the function which runs before a new stream is created
+// on the server side. If it returns a non-nil error, the stream will not be
+// created and a RST_STREAM will be sent back to the client with REFUSED_STREAM.
+// The client will receive an RPC error "code = Unavailable, desc = stream
+// terminated by RST_STREAM with error code: REFUSED_STREAM".
+//
+// It's intended to be used in situations where you don't want to waste the
+// resources to accept the new stream (e.g. rate-limiting). And the content of
+// the error will be ignored and won't be sent back to the client. For other
+// general usages, please use interceptors.
+//
+// Note that it is executed in the per-connection I/O goroutine(s) instead of
+// per-RPC goroutine. Therefore, users should NOT have any
+// blocking/time-consuming work in this handle. Otherwise all the RPCs would
+// slow down. Also, for the same reason, this handle won't be called
+// concurrently by gRPC.
 type ServerInHandle func(ctx context.Context, info *Info) (context.Context, error)
diff --git a/vendor/google.golang.org/grpc/test/bufconn/bufconn.go b/vendor/google.golang.org/grpc/test/bufconn/bufconn.go
new file mode 100644
index 0000000..bdb5d81
--- /dev/null
+++ b/vendor/google.golang.org/grpc/test/bufconn/bufconn.go
@@ -0,0 +1,244 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package bufconn provides a net.Conn implemented by a buffer and related
+// dialing and listening functionality.
+package bufconn
+
+import (
+        "fmt"
+        "io"
+        "net"
+        "sync"
+        "time"
+)
+
+// Listener implements a net.Listener that creates local, buffered net.Conns
+// via its Accept and Dial method.
+type Listener struct {
+        mu   sync.Mutex
+        sz   int
+        ch   chan net.Conn
+        done chan struct{}
+}
+
+var errClosed = fmt.Errorf("Closed")
+
+// Listen returns a Listener that can only be contacted by its own Dialers and
+// creates buffered connections between the two.
+func Listen(sz int) *Listener {
+        return &Listener{sz: sz, ch: make(chan net.Conn), done: make(chan struct{})}
+}
+
+// Accept blocks until Dial is called, then returns a net.Conn for the server
+// half of the connection.
+func (l *Listener) Accept() (net.Conn, error) {
+        select {
+        case <-l.done:
+                return nil, errClosed
+        case c := <-l.ch:
+                return c, nil
+        }
+}
+
+// Close stops the listener.
+func (l *Listener) Close() error {
+        l.mu.Lock()
+        defer l.mu.Unlock()
+        select {
+        case <-l.done:
+                // Already closed.
+                break
+        default:
+                close(l.done)
+        }
+        return nil
+}
+
+// Addr reports the address of the listener.
+func (l *Listener) Addr() net.Addr { return addr{} }
+
+// Dial creates an in-memory full-duplex network connection, unblocks Accept by
+// providing it the server half of the connection, and returns the client half
+// of the connection.
+func (l *Listener) Dial() (net.Conn, error) {
+        p1, p2 := newPipe(l.sz), newPipe(l.sz)
+        select {
+        case <-l.done:
+                return nil, errClosed
+        case l.ch <- &conn{p1, p2}:
+                return &conn{p2, p1}, nil
+        }
+}
+
+type pipe struct {
+        mu sync.Mutex
+
+        // buf contains the data in the pipe.  It is a ring buffer of fixed capacity,
+        // with r and w pointing to the offset to read and write, respsectively.
+        //
+        // Data is read between [r, w) and written to [w, r), wrapping around the end
+        // of the slice if necessary.
+        //
+        // The buffer is empty if r == len(buf), otherwise if r == w, it is full.
+        //
+        // w and r are always in the range [0, cap(buf)) and [0, len(buf)].
+        buf  []byte
+        w, r int
+
+        wwait sync.Cond
+        rwait sync.Cond
+
+        closed      bool
+        writeClosed bool
+}
+
+func newPipe(sz int) *pipe {
+        p := &pipe{buf: make([]byte, 0, sz)}
+        p.wwait.L = &p.mu
+        p.rwait.L = &p.mu
+        return p
+}
+
+func (p *pipe) empty() bool {
+        return p.r == len(p.buf)
+}
+
+func (p *pipe) full() bool {
+        return p.r < len(p.buf) && p.r == p.w
+}
+
+func (p *pipe) Read(b []byte) (n int, err error) {
+        p.mu.Lock()
+        defer p.mu.Unlock()
+        // Block until p has data.
+        for {
+                if p.closed {
+                        return 0, io.ErrClosedPipe
+                }
+                if !p.empty() {
+                        break
+                }
+                if p.writeClosed {
+                        return 0, io.EOF
+                }
+                p.rwait.Wait()
+        }
+        wasFull := p.full()
+
+        n = copy(b, p.buf[p.r:len(p.buf)])
+        p.r += n
+        if p.r == cap(p.buf) {
+                p.r = 0
+                p.buf = p.buf[:p.w]
+        }
+
+        // Signal a blocked writer, if any
+        if wasFull {
+                p.wwait.Signal()
+        }
+
+        return n, nil
+}
+
+func (p *pipe) Write(b []byte) (n int, err error) {
+        p.mu.Lock()
+        defer p.mu.Unlock()
+        if p.closed {
+                return 0, io.ErrClosedPipe
+        }
+        for len(b) > 0 {
+                // Block until p is not full.
+                for {
+                        if p.closed || p.writeClosed {
+                                return 0, io.ErrClosedPipe
+                        }
+                        if !p.full() {
+                                break
+                        }
+                        p.wwait.Wait()
+                }
+                wasEmpty := p.empty()
+
+                end := cap(p.buf)
+                if p.w < p.r {
+                        end = p.r
+                }
+                x := copy(p.buf[p.w:end], b)
+                b = b[x:]
+                n += x
+                p.w += x
+                if p.w > len(p.buf) {
+                        p.buf = p.buf[:p.w]
+                }
+                if p.w == cap(p.buf) {
+                        p.w = 0
+                }
+
+                // Signal a blocked reader, if any.
+                if wasEmpty {
+                        p.rwait.Signal()
+                }
+        }
+        return n, nil
+}
+
+func (p *pipe) Close() error {
+        p.mu.Lock()
+        defer p.mu.Unlock()
+        p.closed = true
+        // Signal all blocked readers and writers to return an error.
+        p.rwait.Broadcast()
+        p.wwait.Broadcast()
+        return nil
+}
+
+func (p *pipe) closeWrite() error {
+        p.mu.Lock()
+        defer p.mu.Unlock()
+        p.writeClosed = true
+        // Signal all blocked readers and writers to return an error.
+        p.rwait.Broadcast()
+        p.wwait.Broadcast()
+        return nil
+}
+
+type conn struct {
+        io.Reader
+        io.Writer
+}
+
+func (c *conn) Close() error {
+        err1 := c.Reader.(*pipe).Close()
+        err2 := c.Writer.(*pipe).closeWrite()
+        if err1 != nil {
+                return err1
+        }
+        return err2
+}
+
+func (*conn) LocalAddr() net.Addr                  { return addr{} }
+func (*conn) RemoteAddr() net.Addr                 { return addr{} }
+func (c *conn) SetDeadline(t time.Time) error      { return fmt.Errorf("unsupported") }
+func (c *conn) SetReadDeadline(t time.Time) error  { return fmt.Errorf("unsupported") }
+func (c *conn) SetWriteDeadline(t time.Time) error { return fmt.Errorf("unsupported") }
+
+type addr struct{}
+
+func (addr) Network() string { return "bufconn" }
+func (addr) String() string  { return "bufconn" }
diff --git a/vendor/google.golang.org/grpc/trace.go b/vendor/google.golang.org/grpc/trace.go
index b419c9e..c1c96de 100644
--- a/vendor/google.golang.org/grpc/trace.go
+++ b/vendor/google.golang.org/grpc/trace.go
@@ -31,7 +31,7 @@ import (
 
 // EnableTracing controls whether to trace RPCs using the golang.org/x/net/trace package.
 // This should only be set before any RPCs are sent or received by this program.
-var EnableTracing = true
+var EnableTracing bool
 
 // methodFamily returns the trace family for the given method.
 // It turns "/pkg.Service/GetFoo" into "pkg.Service".
@@ -76,6 +76,15 @@ func (f *firstLine) String() string {
         return line.String()
 }
 
+const truncateSize = 100
+
+func truncate(x string, l int) string {
+        if l > len(x) {
+                return x
+        }
+        return x[:l]
+}
+
 // payload represents an RPC request or response payload.
 type payload struct {
         sent bool        // whether this is an outgoing payload
@@ -85,9 +94,9 @@ type payload struct {
 
 func (p payload) String() string {
         if p.sent {
-                return fmt.Sprintf("sent: %v", p.msg)
+                return truncate(fmt.Sprintf("sent: %v", p.msg), truncateSize)
         }
-        return fmt.Sprintf("recv: %v", p.msg)
+        return truncate(fmt.Sprintf("recv: %v", p.msg), truncateSize)
 }
 
 type fmtStringer struct {
diff --git a/vendor/google.golang.org/grpc/transport/go16.go b/vendor/google.golang.org/grpc/transport/go16.go
deleted file mode 100644
index 7cffee1..0000000
--- a/vendor/google.golang.org/grpc/transport/go16.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// +build go1.6,!go1.7
-
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package transport
-
-import (
-        "net"
-
-        "google.golang.org/grpc/codes"
-
-        "golang.org/x/net/context"
-)
-
-// dialContext connects to the address on the named network.
-func dialContext(ctx context.Context, network, address string) (net.Conn, error) {
-        return (&net.Dialer{Cancel: ctx.Done()}).Dial(network, address)
-}
-
-// ContextErr converts the error from context package into a StreamError.
-func ContextErr(err error) StreamError {
-        switch err {
-        case context.DeadlineExceeded:
-                return streamErrorf(codes.DeadlineExceeded, "%v", err)
-        case context.Canceled:
-                return streamErrorf(codes.Canceled, "%v", err)
-        }
-        return streamErrorf(codes.Internal, "Unexpected error from context packet: %v", err)
-}
diff --git a/vendor/google.golang.org/grpc/transport/go17.go b/vendor/google.golang.org/grpc/transport/go17.go
deleted file mode 100644
index 2464e69..0000000
--- a/vendor/google.golang.org/grpc/transport/go17.go
+++ /dev/null
@@ -1,46 +0,0 @@
-// +build go1.7
-
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package transport
-
-import (
-        "context"
-        "net"
-
-        "google.golang.org/grpc/codes"
-
-        netctx "golang.org/x/net/context"
-)
-
-// dialContext connects to the address on the named network.
-func dialContext(ctx context.Context, network, address string) (net.Conn, error) {
-        return (&net.Dialer{}).DialContext(ctx, network, address)
-}
-
-// ContextErr converts the error from context package into a StreamError.
-func ContextErr(err error) StreamError {
-        switch err {
-        case context.DeadlineExceeded, netctx.DeadlineExceeded:
-                return streamErrorf(codes.DeadlineExceeded, "%v", err)
-        case context.Canceled, netctx.Canceled:
-                return streamErrorf(codes.Canceled, "%v", err)
-        }
-        return streamErrorf(codes.Internal, "Unexpected error from context packet: %v", err)
-}
diff --git a/vendor/google.golang.org/grpc/transport/http2_client.go b/vendor/google.golang.org/grpc/transport/http2_client.go
deleted file mode 100644
index 516ea06..0000000
--- a/vendor/google.golang.org/grpc/transport/http2_client.go
+++ /dev/null
@@ -1,1369 +0,0 @@
-/*
- *
- * Copyright 2014 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package transport
-
-import (
-        "bytes"
-        "io"
-        "math"
-        "net"
-        "strings"
-        "sync"
-        "sync/atomic"
-        "time"
-
-        "golang.org/x/net/context"
-        "golang.org/x/net/http2"
-        "golang.org/x/net/http2/hpack"
-        "google.golang.org/grpc/codes"
-        "google.golang.org/grpc/credentials"
-        "google.golang.org/grpc/keepalive"
-        "google.golang.org/grpc/metadata"
-        "google.golang.org/grpc/peer"
-        "google.golang.org/grpc/stats"
-        "google.golang.org/grpc/status"
-)
-
-// http2Client implements the ClientTransport interface with HTTP2.
-type http2Client struct {
-        ctx        context.Context
-        target     string // server name/addr
-        userAgent  string
-        md         interface{}
-        conn       net.Conn // underlying communication channel
-        remoteAddr net.Addr
-        localAddr  net.Addr
-        authInfo   credentials.AuthInfo // auth info about the connection
-        nextID     uint32               // the next stream ID to be used
-
-        // writableChan synchronizes write access to the transport.
-        // A writer acquires the write lock by sending a value on writableChan
-        // and releases it by receiving from writableChan.
-        writableChan chan int
-        // shutdownChan is closed when Close is called.
-        // Blocking operations should select on shutdownChan to avoid
-        // blocking forever after Close.
-        // TODO(zhaoq): Maybe have a channel context?
-        shutdownChan chan struct{}
-        // errorChan is closed to notify the I/O error to the caller.
-        errorChan chan struct{}
-        // goAway is closed to notify the upper layer (i.e., addrConn.transportMonitor)
-        // that the server sent GoAway on this transport.
-        goAway chan struct{}
-        // awakenKeepalive is used to wake up keepalive when after it has gone dormant.
-        awakenKeepalive chan struct{}
-
-        framer *framer
-        hBuf   *bytes.Buffer  // the buffer for HPACK encoding
-        hEnc   *hpack.Encoder // HPACK encoder
-
-        // controlBuf delivers all the control related tasks (e.g., window
-        // updates, reset streams, and various settings) to the controller.
-        controlBuf *controlBuffer
-        fc         *inFlow
-        // sendQuotaPool provides flow control to outbound message.
-        sendQuotaPool *quotaPool
-        // streamsQuota limits the max number of concurrent streams.
-        streamsQuota *quotaPool
-
-        // The scheme used: https if TLS is on, http otherwise.
-        scheme string
-
-        isSecure bool
-
-        creds []credentials.PerRPCCredentials
-
-        // Boolean to keep track of reading activity on transport.
-        // 1 is true and 0 is false.
-        activity uint32 // Accessed atomically.
-        kp       keepalive.ClientParameters
-
-        statsHandler stats.Handler
-
-        initialWindowSize int32
-
-        bdpEst          *bdpEstimator
-        outQuotaVersion uint32
-
-        mu            sync.Mutex     // guard the following variables
-        state         transportState // the state of underlying connection
-        activeStreams map[uint32]*Stream
-        // The max number of concurrent streams
-        maxStreams int
-        // the per-stream outbound flow control window size set by the peer.
-        streamSendQuota uint32
-        // prevGoAway ID records the Last-Stream-ID in the previous GOAway frame.
-        prevGoAwayID uint32
-        // goAwayReason records the http2.ErrCode and debug data received with the
-        // GoAway frame.
-        goAwayReason GoAwayReason
-}
-
-func dial(ctx context.Context, fn func(context.Context, string) (net.Conn, error), addr string) (net.Conn, error) {
-        if fn != nil {
-                return fn(ctx, addr)
-        }
-        return dialContext(ctx, "tcp", addr)
-}
-
-func isTemporary(err error) bool {
-        switch err {
-        case io.EOF:
-                // Connection closures may be resolved upon retry, and are thus
-                // treated as temporary.
-                return true
-        case context.DeadlineExceeded:
-                // In Go 1.7, context.DeadlineExceeded implements Timeout(), and this
-                // special case is not needed. Until then, we need to keep this
-                // clause.
-                return true
-        }
-
-        switch err := err.(type) {
-        case interface {
-                Temporary() bool
-        }:
-                return err.Temporary()
-        case interface {
-                Timeout() bool
-        }:
-                // Timeouts may be resolved upon retry, and are thus treated as
-                // temporary.
-                return err.Timeout()
-        }
-        return false
-}
-
-// newHTTP2Client constructs a connected ClientTransport to addr based on HTTP2
-// and starts to receive messages on it. Non-nil error returns if construction
-// fails.
-func newHTTP2Client(ctx context.Context, addr TargetInfo, opts ConnectOptions) (_ ClientTransport, err error) {
-        scheme := "http"
-        conn, err := dial(ctx, opts.Dialer, addr.Addr)
-        if err != nil {
-                if opts.FailOnNonTempDialError {
-                        return nil, connectionErrorf(isTemporary(err), err, "transport: error while dialing: %v", err)
-                }
-                return nil, connectionErrorf(true, err, "transport: Error while dialing %v", err)
-        }
-        // Any further errors will close the underlying connection
-        defer func(conn net.Conn) {
-                if err != nil {
-                        conn.Close()
-                }
-        }(conn)
-        var (
-                isSecure bool
-                authInfo credentials.AuthInfo
-        )
-        if creds := opts.TransportCredentials; creds != nil {
-                scheme = "https"
-                conn, authInfo, err = creds.ClientHandshake(ctx, addr.Addr, conn)
-                if err != nil {
-                        // Credentials handshake errors are typically considered permanent
-                        // to avoid retrying on e.g. bad certificates.
-                        temp := isTemporary(err)
-                        return nil, connectionErrorf(temp, err, "transport: authentication handshake failed: %v", err)
-                }
-                isSecure = true
-        }
-        kp := opts.KeepaliveParams
-        // Validate keepalive parameters.
-        if kp.Time == 0 {
-                kp.Time = defaultClientKeepaliveTime
-        }
-        if kp.Timeout == 0 {
-                kp.Timeout = defaultClientKeepaliveTimeout
-        }
-        dynamicWindow := true
-        icwz := int32(initialWindowSize)
-        if opts.InitialConnWindowSize >= defaultWindowSize {
-                icwz = opts.InitialConnWindowSize
-                dynamicWindow = false
-        }
-        var buf bytes.Buffer
-        t := &http2Client{
-                ctx:        ctx,
-                target:     addr.Addr,
-                userAgent:  opts.UserAgent,
-                md:         addr.Metadata,
-                conn:       conn,
-                remoteAddr: conn.RemoteAddr(),
-                localAddr:  conn.LocalAddr(),
-                authInfo:   authInfo,
-                // The client initiated stream id is odd starting from 1.
-                nextID:            1,
-                writableChan:      make(chan int, 1),
-                shutdownChan:      make(chan struct{}),
-                errorChan:         make(chan struct{}),
-                goAway:            make(chan struct{}),
-                awakenKeepalive:   make(chan struct{}, 1),
-                framer:            newFramer(conn),
-                hBuf:              &buf,
-                hEnc:              hpack.NewEncoder(&buf),
-                controlBuf:        newControlBuffer(),
-                fc:                &inFlow{limit: uint32(icwz)},
-                sendQuotaPool:     newQuotaPool(defaultWindowSize),
-                scheme:            scheme,
-                state:             reachable,
-                activeStreams:     make(map[uint32]*Stream),
-                isSecure:          isSecure,
-                creds:             opts.PerRPCCredentials,
-                maxStreams:        defaultMaxStreamsClient,
-                streamsQuota:      newQuotaPool(defaultMaxStreamsClient),
-                streamSendQuota:   defaultWindowSize,
-                kp:                kp,
-                statsHandler:      opts.StatsHandler,
-                initialWindowSize: initialWindowSize,
-        }
-        if opts.InitialWindowSize >= defaultWindowSize {
-                t.initialWindowSize = opts.InitialWindowSize
-                dynamicWindow = false
-        }
-        if dynamicWindow {
-                t.bdpEst = &bdpEstimator{
-                        bdp:               initialWindowSize,
-                        updateFlowControl: t.updateFlowControl,
-                }
-        }
-        // Make sure awakenKeepalive can't be written upon.
-        // keepalive routine will make it writable, if need be.
-        t.awakenKeepalive <- struct{}{}
-        if t.statsHandler != nil {
-                t.ctx = t.statsHandler.TagConn(t.ctx, &stats.ConnTagInfo{
-                        RemoteAddr: t.remoteAddr,
-                        LocalAddr:  t.localAddr,
-                })
-                connBegin := &stats.ConnBegin{
-                        Client: true,
-                }
-                t.statsHandler.HandleConn(t.ctx, connBegin)
-        }
-        // Start the reader goroutine for incoming message. Each transport has
-        // a dedicated goroutine which reads HTTP2 frame from network. Then it
-        // dispatches the frame to the corresponding stream entity.
-        go t.reader()
-        // Send connection preface to server.
-        n, err := t.conn.Write(clientPreface)
-        if err != nil {
-                t.Close()
-                return nil, connectionErrorf(true, err, "transport: failed to write client preface: %v", err)
-        }
-        if n != len(clientPreface) {
-                t.Close()
-                return nil, connectionErrorf(true, err, "transport: preface mismatch, wrote %d bytes; want %d", n, len(clientPreface))
-        }
-        if t.initialWindowSize != defaultWindowSize {
-                err = t.framer.writeSettings(true, http2.Setting{
-                        ID:  http2.SettingInitialWindowSize,
-                        Val: uint32(t.initialWindowSize),
-                })
-        } else {
-                err = t.framer.writeSettings(true)
-        }
-        if err != nil {
-                t.Close()
-                return nil, connectionErrorf(true, err, "transport: failed to write initial settings frame: %v", err)
-        }
-        // Adjust the connection flow control window if needed.
-        if delta := uint32(icwz - defaultWindowSize); delta > 0 {
-                if err := t.framer.writeWindowUpdate(true, 0, delta); err != nil {
-                        t.Close()
-                        return nil, connectionErrorf(true, err, "transport: failed to write window update: %v", err)
-                }
-        }
-        go t.controller()
-        if t.kp.Time != infinity {
-                go t.keepalive()
-        }
-        t.writableChan <- 0
-        return t, nil
-}
-
-func (t *http2Client) newStream(ctx context.Context, callHdr *CallHdr) *Stream {
-        // TODO(zhaoq): Handle uint32 overflow of Stream.id.
-        s := &Stream{
-                id:            t.nextID,
-                done:          make(chan struct{}),
-                goAway:        make(chan struct{}),
-                method:        callHdr.Method,
-                sendCompress:  callHdr.SendCompress,
-                buf:           newRecvBuffer(),
-                fc:            &inFlow{limit: uint32(t.initialWindowSize)},
-                sendQuotaPool: newQuotaPool(int(t.streamSendQuota)),
-                headerChan:    make(chan struct{}),
-        }
-        t.nextID += 2
-        s.requestRead = func(n int) {
-                t.adjustWindow(s, uint32(n))
-        }
-        // The client side stream context should have exactly the same life cycle with the user provided context.
-        // That means, s.ctx should be read-only. And s.ctx is done iff ctx is done.
-        // So we use the original context here instead of creating a copy.
-        s.ctx = ctx
-        s.trReader = &transportReader{
-                reader: &recvBufferReader{
-                        ctx:    s.ctx,
-                        goAway: s.goAway,
-                        recv:   s.buf,
-                },
-                windowHandler: func(n int) {
-                        t.updateWindow(s, uint32(n))
-                },
-        }
-
-        return s
-}
-
-// NewStream creates a stream and registers it into the transport as "active"
-// streams.
-func (t *http2Client) NewStream(ctx context.Context, callHdr *CallHdr) (_ *Stream, err error) {
-        pr := &peer.Peer{
-                Addr: t.remoteAddr,
-        }
-        // Attach Auth info if there is any.
-        if t.authInfo != nil {
-                pr.AuthInfo = t.authInfo
-        }
-        ctx = peer.NewContext(ctx, pr)
-        var (
-                authData = make(map[string]string)
-                audience string
-        )
-        // Create an audience string only if needed.
-        if len(t.creds) > 0 || callHdr.Creds != nil {
-                // Construct URI required to get auth request metadata.
-                var port string
-                if pos := strings.LastIndex(t.target, ":"); pos != -1 {
-                        // Omit port if it is the default one.
-                        if t.target[pos+1:] != "443" {
-                                port = ":" + t.target[pos+1:]
-                        }
-                }
-                pos := strings.LastIndex(callHdr.Method, "/")
-                if pos == -1 {
-                        pos = len(callHdr.Method)
-                }
-                audience = "https://" + callHdr.Host + port + callHdr.Method[:pos]
-        }
-        for _, c := range t.creds {
-                data, err := c.GetRequestMetadata(ctx, audience)
-                if err != nil {
-                        return nil, streamErrorf(codes.Internal, "transport: %v", err)
-                }
-                for k, v := range data {
-                        // Capital header names are illegal in HTTP/2.
-                        k = strings.ToLower(k)
-                        authData[k] = v
-                }
-        }
-        callAuthData := make(map[string]string)
-        // Check if credentials.PerRPCCredentials were provided via call options.
-        // Note: if these credentials are provided both via dial options and call
-        // options, then both sets of credentials will be applied.
-        if callCreds := callHdr.Creds; callCreds != nil {
-                if !t.isSecure && callCreds.RequireTransportSecurity() {
-                        return nil, streamErrorf(codes.Unauthenticated, "transport: cannot send secure credentials on an insecure conneciton")
-                }
-                data, err := callCreds.GetRequestMetadata(ctx, audience)
-                if err != nil {
-                        return nil, streamErrorf(codes.Internal, "transport: %v", err)
-                }
-                for k, v := range data {
-                        // Capital header names are illegal in HTTP/2
-                        k = strings.ToLower(k)
-                        callAuthData[k] = v
-                }
-        }
-        t.mu.Lock()
-        if t.activeStreams == nil {
-                t.mu.Unlock()
-                return nil, ErrConnClosing
-        }
-        if t.state == draining {
-                t.mu.Unlock()
-                return nil, ErrStreamDrain
-        }
-        if t.state != reachable {
-                t.mu.Unlock()
-                return nil, ErrConnClosing
-        }
-        t.mu.Unlock()
-        sq, err := wait(ctx, nil, nil, t.shutdownChan, t.streamsQuota.acquire())
-        if err != nil {
-                return nil, err
-        }
-        // Returns the quota balance back.
-        if sq > 1 {
-                t.streamsQuota.add(sq - 1)
-        }
-        if _, err := wait(ctx, nil, nil, t.shutdownChan, t.writableChan); err != nil {
-                // Return the quota back now because there is no stream returned to the caller.
-                if _, ok := err.(StreamError); ok {
-                        t.streamsQuota.add(1)
-                }
-                return nil, err
-        }
-        t.mu.Lock()
-        if t.state == draining {
-                t.mu.Unlock()
-                t.streamsQuota.add(1)
-                // Need to make t writable again so that the rpc in flight can still proceed.
-                t.writableChan <- 0
-                return nil, ErrStreamDrain
-        }
-        if t.state != reachable {
-                t.mu.Unlock()
-                return nil, ErrConnClosing
-        }
-        s := t.newStream(ctx, callHdr)
-        t.activeStreams[s.id] = s
-        // If the number of active streams change from 0 to 1, then check if keepalive
-        // has gone dormant. If so, wake it up.
-        if len(t.activeStreams) == 1 {
-                select {
-                case t.awakenKeepalive <- struct{}{}:
-                        t.framer.writePing(false, false, [8]byte{})
-                default:
-                }
-        }
-
-        t.mu.Unlock()
-
-        // HPACK encodes various headers. Note that once WriteField(...) is
-        // called, the corresponding headers/continuation frame has to be sent
-        // because hpack.Encoder is stateful.
-        t.hBuf.Reset()
-        t.hEnc.WriteField(hpack.HeaderField{Name: ":method", Value: "POST"})
-        t.hEnc.WriteField(hpack.HeaderField{Name: ":scheme", Value: t.scheme})
-        t.hEnc.WriteField(hpack.HeaderField{Name: ":path", Value: callHdr.Method})
-        t.hEnc.WriteField(hpack.HeaderField{Name: ":authority", Value: callHdr.Host})
-        t.hEnc.WriteField(hpack.HeaderField{Name: "content-type", Value: "application/grpc"})
-        t.hEnc.WriteField(hpack.HeaderField{Name: "user-agent", Value: t.userAgent})
-        t.hEnc.WriteField(hpack.HeaderField{Name: "te", Value: "trailers"})
-
-        if callHdr.SendCompress != "" {
-                t.hEnc.WriteField(hpack.HeaderField{Name: "grpc-encoding", Value: callHdr.SendCompress})
-        }
-        if dl, ok := ctx.Deadline(); ok {
-                // Send out timeout regardless its value. The server can detect timeout context by itself.
-                timeout := dl.Sub(time.Now())
-                t.hEnc.WriteField(hpack.HeaderField{Name: "grpc-timeout", Value: encodeTimeout(timeout)})
-        }
-
-        for k, v := range authData {
-                t.hEnc.WriteField(hpack.HeaderField{Name: k, Value: encodeMetadataHeader(k, v)})
-        }
-        for k, v := range callAuthData {
-                t.hEnc.WriteField(hpack.HeaderField{Name: k, Value: encodeMetadataHeader(k, v)})
-        }
-        var (
-                endHeaders bool
-        )
-        if md, ok := metadata.FromOutgoingContext(ctx); ok {
-                for k, vv := range md {
-                        // HTTP doesn't allow you to set pseudoheaders after non pseudoheaders were set.
-                        if isReservedHeader(k) {
-                                continue
-                        }
-                        for _, v := range vv {
-                                t.hEnc.WriteField(hpack.HeaderField{Name: k, Value: encodeMetadataHeader(k, v)})
-                        }
-                }
-        }
-        if md, ok := t.md.(*metadata.MD); ok {
-                for k, vv := range *md {
-                        if isReservedHeader(k) {
-                                continue
-                        }
-                        for _, v := range vv {
-                                t.hEnc.WriteField(hpack.HeaderField{Name: k, Value: encodeMetadataHeader(k, v)})
-                        }
-                }
-        }
-        first := true
-        bufLen := t.hBuf.Len()
-        // Sends the headers in a single batch even when they span multiple frames.
-        for !endHeaders {
-                size := t.hBuf.Len()
-                if size > http2MaxFrameLen {
-                        size = http2MaxFrameLen
-                } else {
-                        endHeaders = true
-                }
-                var flush bool
-                if callHdr.Flush && endHeaders {
-                        flush = true
-                }
-                if first {
-                        // Sends a HeadersFrame to server to start a new stream.
-                        p := http2.HeadersFrameParam{
-                                StreamID:      s.id,
-                                BlockFragment: t.hBuf.Next(size),
-                                EndStream:     false,
-                                EndHeaders:    endHeaders,
-                        }
-                        // Do a force flush for the buffered frames iff it is the last headers frame
-                        // and there is header metadata to be sent. Otherwise, there is flushing until
-                        // the corresponding data frame is written.
-                        err = t.framer.writeHeaders(flush, p)
-                        first = false
-                } else {
-                        // Sends Continuation frames for the leftover headers.
-                        err = t.framer.writeContinuation(flush, s.id, endHeaders, t.hBuf.Next(size))
-                }
-                if err != nil {
-                        t.notifyError(err)
-                        return nil, connectionErrorf(true, err, "transport: %v", err)
-                }
-        }
-        s.mu.Lock()
-        s.bytesSent = true
-        s.mu.Unlock()
-
-        if t.statsHandler != nil {
-                outHeader := &stats.OutHeader{
-                        Client:      true,
-                        WireLength:  bufLen,
-                        FullMethod:  callHdr.Method,
-                        RemoteAddr:  t.remoteAddr,
-                        LocalAddr:   t.localAddr,
-                        Compression: callHdr.SendCompress,
-                }
-                t.statsHandler.HandleRPC(s.ctx, outHeader)
-        }
-        t.writableChan <- 0
-        return s, nil
-}
-
-// CloseStream clears the footprint of a stream when the stream is not needed any more.
-// This must not be executed in reader's goroutine.
-func (t *http2Client) CloseStream(s *Stream, err error) {
-        t.mu.Lock()
-        if t.activeStreams == nil {
-                t.mu.Unlock()
-                return
-        }
-        if err != nil {
-                // notify in-flight streams, before the deletion
-                s.write(recvMsg{err: err})
-        }
-        delete(t.activeStreams, s.id)
-        if t.state == draining && len(t.activeStreams) == 0 {
-                // The transport is draining and s is the last live stream on t.
-                t.mu.Unlock()
-                t.Close()
-                return
-        }
-        t.mu.Unlock()
-        // rstStream is true in case the stream is being closed at the client-side
-        // and the server needs to be intimated about it by sending a RST_STREAM
-        // frame.
-        // To make sure this frame is written to the wire before the headers of the
-        // next stream waiting for streamsQuota, we add to streamsQuota pool only
-        // after having acquired the writableChan to send RST_STREAM out (look at
-        // the controller() routine).
-        var rstStream bool
-        var rstError http2.ErrCode
-        defer func() {
-                // In case, the client doesn't have to send RST_STREAM to server
-                // we can safely add back to streamsQuota pool now.
-                if !rstStream {
-                        t.streamsQuota.add(1)
-                        return
-                }
-                t.controlBuf.put(&resetStream{s.id, rstError})
-        }()
-        s.mu.Lock()
-        rstStream = s.rstStream
-        rstError = s.rstError
-        if s.state == streamDone {
-                s.mu.Unlock()
-                return
-        }
-        if !s.headerDone {
-                close(s.headerChan)
-                s.headerDone = true
-        }
-        s.state = streamDone
-        s.mu.Unlock()
-        if _, ok := err.(StreamError); ok {
-                rstStream = true
-                rstError = http2.ErrCodeCancel
-        }
-}
-
-// Close kicks off the shutdown process of the transport. This should be called
-// only once on a transport. Once it is called, the transport should not be
-// accessed any more.
-func (t *http2Client) Close() (err error) {
-        t.mu.Lock()
-        if t.state == closing {
-                t.mu.Unlock()
-                return
-        }
-        if t.state == reachable || t.state == draining {
-                close(t.errorChan)
-        }
-        t.state = closing
-        t.mu.Unlock()
-        close(t.shutdownChan)
-        err = t.conn.Close()
-        t.mu.Lock()
-        streams := t.activeStreams
-        t.activeStreams = nil
-        t.mu.Unlock()
-        // Notify all active streams.
-        for _, s := range streams {
-                s.mu.Lock()
-                if !s.headerDone {
-                        close(s.headerChan)
-                        s.headerDone = true
-                }
-                s.mu.Unlock()
-                s.write(recvMsg{err: ErrConnClosing})
-        }
-        if t.statsHandler != nil {
-                connEnd := &stats.ConnEnd{
-                        Client: true,
-                }
-                t.statsHandler.HandleConn(t.ctx, connEnd)
-        }
-        return
-}
-
-func (t *http2Client) GracefulClose() error {
-        t.mu.Lock()
-        switch t.state {
-        case unreachable:
-                // The server may close the connection concurrently. t is not available for
-                // any streams. Close it now.
-                t.mu.Unlock()
-                t.Close()
-                return nil
-        case closing:
-                t.mu.Unlock()
-                return nil
-        }
-        if t.state == draining {
-                t.mu.Unlock()
-                return nil
-        }
-        t.state = draining
-        active := len(t.activeStreams)
-        t.mu.Unlock()
-        if active == 0 {
-                return t.Close()
-        }
-        return nil
-}
-
-// Write formats the data into HTTP2 data frame(s) and sends it out. The caller
-// should proceed only if Write returns nil.
-// TODO(zhaoq): opts.Delay is ignored in this implementation. Support it later
-// if it improves the performance.
-func (t *http2Client) Write(s *Stream, data []byte, opts *Options) error {
-        r := bytes.NewBuffer(data)
-        var (
-                p   []byte
-                oqv uint32
-        )
-        for {
-                oqv = atomic.LoadUint32(&t.outQuotaVersion)
-                if r.Len() > 0 || p != nil {
-                        size := http2MaxFrameLen
-                        // Wait until the stream has some quota to send the data.
-                        sq, err := wait(s.ctx, s.done, s.goAway, t.shutdownChan, s.sendQuotaPool.acquire())
-                        if err != nil {
-                                return err
-                        }
-                        // Wait until the transport has some quota to send the data.
-                        tq, err := wait(s.ctx, s.done, s.goAway, t.shutdownChan, t.sendQuotaPool.acquire())
-                        if err != nil {
-                                return err
-                        }
-                        if sq < size {
-                                size = sq
-                        }
-                        if tq < size {
-                                size = tq
-                        }
-                        if p == nil {
-                                p = r.Next(size)
-                        }
-                        ps := len(p)
-                        if ps < sq {
-                                // Overbooked stream quota. Return it back.
-                                s.sendQuotaPool.add(sq - ps)
-                        }
-                        if ps < tq {
-                                // Overbooked transport quota. Return it back.
-                                t.sendQuotaPool.add(tq - ps)
-                        }
-                }
-                var (
-                        endStream  bool
-                        forceFlush bool
-                )
-                if opts.Last && r.Len() == 0 {
-                        endStream = true
-                }
-                // Indicate there is a writer who is about to write a data frame.
-                t.framer.adjustNumWriters(1)
-                // Got some quota. Try to acquire writing privilege on the transport.
-                if _, err := wait(s.ctx, s.done, s.goAway, t.shutdownChan, t.writableChan); err != nil {
-                        if _, ok := err.(StreamError); ok || err == io.EOF {
-                                // Return the connection quota back.
-                                t.sendQuotaPool.add(len(p))
-                        }
-                        if t.framer.adjustNumWriters(-1) == 0 {
-                                // This writer is the last one in this batch and has the
-                                // responsibility to flush the buffered frames. It queues
-                                // a flush request to controlBuf instead of flushing directly
-                                // in order to avoid the race with other writing or flushing.
-                                t.controlBuf.put(&flushIO{})
-                        }
-                        return err
-                }
-                select {
-                case <-s.ctx.Done():
-                        t.sendQuotaPool.add(len(p))
-                        if t.framer.adjustNumWriters(-1) == 0 {
-                                t.controlBuf.put(&flushIO{})
-                        }
-                        t.writableChan <- 0
-                        return ContextErr(s.ctx.Err())
-                default:
-                }
-                if oqv != atomic.LoadUint32(&t.outQuotaVersion) {
-                        // InitialWindowSize settings frame must have been received after we
-                        // acquired send quota but before we got the writable channel.
-                        // We must forsake this write.
-                        t.sendQuotaPool.add(len(p))
-                        s.sendQuotaPool.add(len(p))
-                        if t.framer.adjustNumWriters(-1) == 0 {
-                                t.controlBuf.put(&flushIO{})
-                        }
-                        t.writableChan <- 0
-                        continue
-                }
-                if r.Len() == 0 && t.framer.adjustNumWriters(0) == 1 {
-                        // Do a force flush iff this is last frame for the entire gRPC message
-                        // and the caller is the only writer at this moment.
-                        forceFlush = true
-                }
-                // If WriteData fails, all the pending streams will be handled
-                // by http2Client.Close(). No explicit CloseStream() needs to be
-                // invoked.
-                if err := t.framer.writeData(forceFlush, s.id, endStream, p); err != nil {
-                        t.notifyError(err)
-                        return connectionErrorf(true, err, "transport: %v", err)
-                }
-                p = nil
-                if t.framer.adjustNumWriters(-1) == 0 {
-                        t.framer.flushWrite()
-                }
-                t.writableChan <- 0
-                if r.Len() == 0 {
-                        break
-                }
-        }
-        if !opts.Last {
-                return nil
-        }
-        s.mu.Lock()
-        if s.state != streamDone {
-                s.state = streamWriteDone
-        }
-        s.mu.Unlock()
-        return nil
-}
-
-func (t *http2Client) getStream(f http2.Frame) (*Stream, bool) {
-        t.mu.Lock()
-        defer t.mu.Unlock()
-        s, ok := t.activeStreams[f.Header().StreamID]
-        return s, ok
-}
-
-// adjustWindow sends out extra window update over the initial window size
-// of stream if the application is requesting data larger in size than
-// the window.
-func (t *http2Client) adjustWindow(s *Stream, n uint32) {
-        s.mu.Lock()
-        defer s.mu.Unlock()
-        if s.state == streamDone {
-                return
-        }
-        if w := s.fc.maybeAdjust(n); w > 0 {
-                // Piggyback conneciton's window update along.
-                if cw := t.fc.resetPendingUpdate(); cw > 0 {
-                        t.controlBuf.put(&windowUpdate{0, cw, false})
-                }
-                t.controlBuf.put(&windowUpdate{s.id, w, true})
-        }
-}
-
-// updateWindow adjusts the inbound quota for the stream and the transport.
-// Window updates will deliver to the controller for sending when
-// the cumulative quota exceeds the corresponding threshold.
-func (t *http2Client) updateWindow(s *Stream, n uint32) {
-        s.mu.Lock()
-        defer s.mu.Unlock()
-        if s.state == streamDone {
-                return
-        }
-        if w := s.fc.onRead(n); w > 0 {
-                if cw := t.fc.resetPendingUpdate(); cw > 0 {
-                        t.controlBuf.put(&windowUpdate{0, cw, false})
-                }
-                t.controlBuf.put(&windowUpdate{s.id, w, true})
-        }
-}
-
-// updateFlowControl updates the incoming flow control windows
-// for the transport and the stream based on the current bdp
-// estimation.
-func (t *http2Client) updateFlowControl(n uint32) {
-        t.mu.Lock()
-        for _, s := range t.activeStreams {
-                s.fc.newLimit(n)
-        }
-        t.initialWindowSize = int32(n)
-        t.mu.Unlock()
-        t.controlBuf.put(&windowUpdate{0, t.fc.newLimit(n), false})
-        t.controlBuf.put(&settings{
-                ack: false,
-                ss: []http2.Setting{
-                        {
-                                ID:  http2.SettingInitialWindowSize,
-                                Val: uint32(n),
-                        },
-                },
-        })
-}
-
-func (t *http2Client) handleData(f *http2.DataFrame) {
-        size := f.Header().Length
-        var sendBDPPing bool
-        if t.bdpEst != nil {
-                sendBDPPing = t.bdpEst.add(uint32(size))
-        }
-        // Decouple connection's flow control from application's read.
-        // An update on connection's flow control should not depend on
-        // whether user application has read the data or not. Such a
-        // restriction is already imposed on the stream's flow control,
-        // and therefore the sender will be blocked anyways.
-        // Decoupling the connection flow control will prevent other
-        // active(fast) streams from starving in presence of slow or
-        // inactive streams.
-        //
-        // Furthermore, if a bdpPing is being sent out we can piggyback
-        // connection's window update for the bytes we just received.
-        if sendBDPPing {
-                t.controlBuf.put(&windowUpdate{0, uint32(size), false})
-                t.controlBuf.put(bdpPing)
-        } else {
-                if err := t.fc.onData(uint32(size)); err != nil {
-                        t.notifyError(connectionErrorf(true, err, "%v", err))
-                        return
-                }
-                if w := t.fc.onRead(uint32(size)); w > 0 {
-                        t.controlBuf.put(&windowUpdate{0, w, true})
-                }
-        }
-        // Select the right stream to dispatch.
-        s, ok := t.getStream(f)
-        if !ok {
-                return
-        }
-        if size > 0 {
-                s.mu.Lock()
-                if s.state == streamDone {
-                        s.mu.Unlock()
-                        return
-                }
-                if err := s.fc.onData(uint32(size)); err != nil {
-                        s.rstStream = true
-                        s.rstError = http2.ErrCodeFlowControl
-                        s.finish(status.New(codes.Internal, err.Error()))
-                        s.mu.Unlock()
-                        s.write(recvMsg{err: io.EOF})
-                        return
-                }
-                if f.Header().Flags.Has(http2.FlagDataPadded) {
-                        if w := s.fc.onRead(uint32(size) - uint32(len(f.Data()))); w > 0 {
-                                t.controlBuf.put(&windowUpdate{s.id, w, true})
-                        }
-                }
-                s.mu.Unlock()
-                // TODO(bradfitz, zhaoq): A copy is required here because there is no
-                // guarantee f.Data() is consumed before the arrival of next frame.
-                // Can this copy be eliminated?
-                if len(f.Data()) > 0 {
-                        data := make([]byte, len(f.Data()))
-                        copy(data, f.Data())
-                        s.write(recvMsg{data: data})
-                }
-        }
-        // The server has closed the stream without sending trailers.  Record that
-        // the read direction is closed, and set the status appropriately.
-        if f.FrameHeader.Flags.Has(http2.FlagDataEndStream) {
-                s.mu.Lock()
-                if s.state == streamDone {
-                        s.mu.Unlock()
-                        return
-                }
-                s.finish(status.New(codes.Internal, "server closed the stream without sending trailers"))
-                s.mu.Unlock()
-                s.write(recvMsg{err: io.EOF})
-        }
-}
-
-func (t *http2Client) handleRSTStream(f *http2.RSTStreamFrame) {
-        s, ok := t.getStream(f)
-        if !ok {
-                return
-        }
-        s.mu.Lock()
-        if s.state == streamDone {
-                s.mu.Unlock()
-                return
-        }
-        if !s.headerDone {
-                close(s.headerChan)
-                s.headerDone = true
-        }
-        statusCode, ok := http2ErrConvTab[http2.ErrCode(f.ErrCode)]
-        if !ok {
-                warningf("transport: http2Client.handleRSTStream found no mapped gRPC status for the received http2 error %v", f.ErrCode)
-                statusCode = codes.Unknown
-        }
-        s.finish(status.Newf(statusCode, "stream terminated by RST_STREAM with error code: %d", f.ErrCode))
-        s.mu.Unlock()
-        s.write(recvMsg{err: io.EOF})
-}
-
-func (t *http2Client) handleSettings(f *http2.SettingsFrame) {
-        if f.IsAck() {
-                return
-        }
-        var ss []http2.Setting
-        f.ForeachSetting(func(s http2.Setting) error {
-                ss = append(ss, s)
-                return nil
-        })
-        // The settings will be applied once the ack is sent.
-        t.controlBuf.put(&settings{ack: true, ss: ss})
-}
-
-func (t *http2Client) handlePing(f *http2.PingFrame) {
-        if f.IsAck() {
-                // Maybe it's a BDP ping.
-                if t.bdpEst != nil {
-                        t.bdpEst.calculate(f.Data)
-                }
-                return
-        }
-        pingAck := &ping{ack: true}
-        copy(pingAck.data[:], f.Data[:])
-        t.controlBuf.put(pingAck)
-}
-
-func (t *http2Client) handleGoAway(f *http2.GoAwayFrame) {
-        t.mu.Lock()
-        if t.state != reachable && t.state != draining {
-                t.mu.Unlock()
-                return
-        }
-        if f.ErrCode == http2.ErrCodeEnhanceYourCalm {
-                infof("Client received GoAway with http2.ErrCodeEnhanceYourCalm.")
-        }
-        id := f.LastStreamID
-        if id > 0 && id%2 != 1 {
-                t.mu.Unlock()
-                t.notifyError(connectionErrorf(true, nil, "received illegal http2 GOAWAY frame: stream ID %d is even", f.LastStreamID))
-                return
-        }
-        // A client can recieve multiple GoAways from server (look at https://github.com/grpc/grpc-go/issues/1387).
-        // The idea is that the first GoAway will be sent with an ID of MaxInt32 and the second GoAway will be sent after an RTT delay
-        // with the ID of the last stream the server will process.
-        // Therefore, when we get the first GoAway we don't really close any streams. While in case of second GoAway we
-        // close all streams created after the second GoAwayId. This way streams that were in-flight while the GoAway from server
-        // was being sent don't get killed.
-        select {
-        case <-t.goAway: // t.goAway has been closed (i.e.,multiple GoAways).
-                // If there are multiple GoAways the first one should always have an ID greater than the following ones.
-                if id > t.prevGoAwayID {
-                        t.mu.Unlock()
-                        t.notifyError(connectionErrorf(true, nil, "received illegal http2 GOAWAY frame: previously recv GOAWAY frame with LastStramID %d, currently recv %d", id, f.LastStreamID))
-                        return
-                }
-        default:
-                t.setGoAwayReason(f)
-                close(t.goAway)
-                t.state = draining
-        }
-        // All streams with IDs greater than the GoAwayId
-        // and smaller than the previous GoAway ID should be killed.
-        upperLimit := t.prevGoAwayID
-        if upperLimit == 0 { // This is the first GoAway Frame.
-                upperLimit = math.MaxUint32 // Kill all streams after the GoAway ID.
-        }
-        for streamID, stream := range t.activeStreams {
-                if streamID > id && streamID <= upperLimit {
-                        close(stream.goAway)
-                }
-        }
-        t.prevGoAwayID = id
-        active := len(t.activeStreams)
-        t.mu.Unlock()
-        if active == 0 {
-                t.Close()
-        }
-}
-
-// setGoAwayReason sets the value of t.goAwayReason based
-// on the GoAway frame received.
-// It expects a lock on transport's mutext to be held by
-// the caller.
-func (t *http2Client) setGoAwayReason(f *http2.GoAwayFrame) {
-        t.goAwayReason = NoReason
-        switch f.ErrCode {
-        case http2.ErrCodeEnhanceYourCalm:
-                if string(f.DebugData()) == "too_many_pings" {
-                        t.goAwayReason = TooManyPings
-                }
-        }
-}
-
-func (t *http2Client) GetGoAwayReason() GoAwayReason {
-        t.mu.Lock()
-        defer t.mu.Unlock()
-        return t.goAwayReason
-}
-
-func (t *http2Client) handleWindowUpdate(f *http2.WindowUpdateFrame) {
-        id := f.Header().StreamID
-        incr := f.Increment
-        if id == 0 {
-                t.sendQuotaPool.add(int(incr))
-                return
-        }
-        if s, ok := t.getStream(f); ok {
-                s.sendQuotaPool.add(int(incr))
-        }
-}
-
-// operateHeaders takes action on the decoded headers.
-func (t *http2Client) operateHeaders(frame *http2.MetaHeadersFrame) {
-        s, ok := t.getStream(frame)
-        if !ok {
-                return
-        }
-        s.mu.Lock()
-        s.bytesReceived = true
-        s.mu.Unlock()
-        var state decodeState
-        if err := state.decodeResponseHeader(frame); err != nil {
-                s.mu.Lock()
-                if !s.headerDone {
-                        close(s.headerChan)
-                        s.headerDone = true
-                }
-                s.mu.Unlock()
-                s.write(recvMsg{err: err})
-                // Something wrong. Stops reading even when there is remaining.
-                return
-        }
-
-        endStream := frame.StreamEnded()
-        var isHeader bool
-        defer func() {
-                if t.statsHandler != nil {
-                        if isHeader {
-                                inHeader := &stats.InHeader{
-                                        Client:     true,
-                                        WireLength: int(frame.Header().Length),
-                                }
-                                t.statsHandler.HandleRPC(s.ctx, inHeader)
-                        } else {
-                                inTrailer := &stats.InTrailer{
-                                        Client:     true,
-                                        WireLength: int(frame.Header().Length),
-                                }
-                                t.statsHandler.HandleRPC(s.ctx, inTrailer)
-                        }
-                }
-        }()
-
-        s.mu.Lock()
-        if !endStream {
-                s.recvCompress = state.encoding
-        }
-        if !s.headerDone {
-                if !endStream && len(state.mdata) > 0 {
-                        s.header = state.mdata
-                }
-                close(s.headerChan)
-                s.headerDone = true
-                isHeader = true
-        }
-        if !endStream || s.state == streamDone {
-                s.mu.Unlock()
-                return
-        }
-
-        if len(state.mdata) > 0 {
-                s.trailer = state.mdata
-        }
-        s.finish(state.status())
-        s.mu.Unlock()
-        s.write(recvMsg{err: io.EOF})
-}
-
-func handleMalformedHTTP2(s *Stream, err error) {
-        s.mu.Lock()
-        if !s.headerDone {
-                close(s.headerChan)
-                s.headerDone = true
-        }
-        s.mu.Unlock()
-        s.write(recvMsg{err: err})
-}
-
-// reader runs as a separate goroutine in charge of reading data from network
-// connection.
-//
-// TODO(zhaoq): currently one reader per transport. Investigate whether this is
-// optimal.
-// TODO(zhaoq): Check the validity of the incoming frame sequence.
-func (t *http2Client) reader() {
-        // Check the validity of server preface.
-        frame, err := t.framer.readFrame()
-        if err != nil {
-                t.notifyError(err)
-                return
-        }
-        atomic.CompareAndSwapUint32(&t.activity, 0, 1)
-        sf, ok := frame.(*http2.SettingsFrame)
-        if !ok {
-                t.notifyError(err)
-                return
-        }
-        t.handleSettings(sf)
-
-        // loop to keep reading incoming messages on this transport.
-        for {
-                frame, err := t.framer.readFrame()
-                atomic.CompareAndSwapUint32(&t.activity, 0, 1)
-                if err != nil {
-                        // Abort an active stream if the http2.Framer returns a
-                        // http2.StreamError. This can happen only if the server's response
-                        // is malformed http2.
-                        if se, ok := err.(http2.StreamError); ok {
-                                t.mu.Lock()
-                                s := t.activeStreams[se.StreamID]
-                                t.mu.Unlock()
-                                if s != nil {
-                                        // use error detail to provide better err message
-                                        handleMalformedHTTP2(s, streamErrorf(http2ErrConvTab[se.Code], "%v", t.framer.errorDetail()))
-                                }
-                                continue
-                        } else {
-                                // Transport error.
-                                t.notifyError(err)
-                                return
-                        }
-                }
-                switch frame := frame.(type) {
-                case *http2.MetaHeadersFrame:
-                        t.operateHeaders(frame)
-                case *http2.DataFrame:
-                        t.handleData(frame)
-                case *http2.RSTStreamFrame:
-                        t.handleRSTStream(frame)
-                case *http2.SettingsFrame:
-                        t.handleSettings(frame)
-                case *http2.PingFrame:
-                        t.handlePing(frame)
-                case *http2.GoAwayFrame:
-                        t.handleGoAway(frame)
-                case *http2.WindowUpdateFrame:
-                        t.handleWindowUpdate(frame)
-                default:
-                        errorf("transport: http2Client.reader got unhandled frame type %v.", frame)
-                }
-        }
-}
-
-func (t *http2Client) applySettings(ss []http2.Setting) {
-        for _, s := range ss {
-                switch s.ID {
-                case http2.SettingMaxConcurrentStreams:
-                        // TODO(zhaoq): This is a hack to avoid significant refactoring of the
-                        // code to deal with the unrealistic int32 overflow. Probably will try
-                        // to find a better way to handle this later.
-                        if s.Val > math.MaxInt32 {
-                                s.Val = math.MaxInt32
-                        }
-                        t.mu.Lock()
-                        ms := t.maxStreams
-                        t.maxStreams = int(s.Val)
-                        t.mu.Unlock()
-                        t.streamsQuota.add(int(s.Val) - ms)
-                case http2.SettingInitialWindowSize:
-                        t.mu.Lock()
-                        for _, stream := range t.activeStreams {
-                                // Adjust the sending quota for each stream.
-                                stream.sendQuotaPool.add(int(s.Val) - int(t.streamSendQuota))
-                        }
-                        t.streamSendQuota = s.Val
-                        t.mu.Unlock()
-                        atomic.AddUint32(&t.outQuotaVersion, 1)
-                }
-        }
-}
-
-// controller running in a separate goroutine takes charge of sending control
-// frames (e.g., window update, reset stream, setting, etc.) to the server.
-func (t *http2Client) controller() {
-        for {
-                select {
-                case i := <-t.controlBuf.get():
-                        t.controlBuf.load()
-                        select {
-                        case <-t.writableChan:
-                                switch i := i.(type) {
-                                case *windowUpdate:
-                                        t.framer.writeWindowUpdate(i.flush, i.streamID, i.increment)
-                                case *settings:
-                                        if i.ack {
-                                                t.framer.writeSettingsAck(true)
-                                                t.applySettings(i.ss)
-                                        } else {
-                                                t.framer.writeSettings(true, i.ss...)
-                                        }
-                                case *resetStream:
-                                        // If the server needs to be to intimated about stream closing,
-                                        // then we need to make sure the RST_STREAM frame is written to
-                                        // the wire before the headers of the next stream waiting on
-                                        // streamQuota. We ensure this by adding to the streamsQuota pool
-                                        // only after having acquired the writableChan to send RST_STREAM.
-                                        t.streamsQuota.add(1)
-                                        t.framer.writeRSTStream(true, i.streamID, i.code)
-                                case *flushIO:
-                                        t.framer.flushWrite()
-                                case *ping:
-                                        if !i.ack {
-                                                t.bdpEst.timesnap(i.data)
-                                        }
-                                        t.framer.writePing(true, i.ack, i.data)
-                                default:
-                                        errorf("transport: http2Client.controller got unexpected item type %v\n", i)
-                                }
-                                t.writableChan <- 0
-                                continue
-                        case <-t.shutdownChan:
-                                return
-                        }
-                case <-t.shutdownChan:
-                        return
-                }
-        }
-}
-
-// keepalive running in a separate goroutune makes sure the connection is alive by sending pings.
-func (t *http2Client) keepalive() {
-        p := &ping{data: [8]byte{}}
-        timer := time.NewTimer(t.kp.Time)
-        for {
-                select {
-                case <-timer.C:
-                        if atomic.CompareAndSwapUint32(&t.activity, 1, 0) {
-                                timer.Reset(t.kp.Time)
-                                continue
-                        }
-                        // Check if keepalive should go dormant.
-                        t.mu.Lock()
-                        if len(t.activeStreams) < 1 && !t.kp.PermitWithoutStream {
-                                // Make awakenKeepalive writable.
-                                <-t.awakenKeepalive
-                                t.mu.Unlock()
-                                select {
-                                case <-t.awakenKeepalive:
-                                        // If the control gets here a ping has been sent
-                                        // need to reset the timer with keepalive.Timeout.
-                                case <-t.shutdownChan:
-                                        return
-                                }
-                        } else {
-                                t.mu.Unlock()
-                                // Send ping.
-                                t.controlBuf.put(p)
-                        }
-
-                        // By the time control gets here a ping has been sent one way or the other.
-                        timer.Reset(t.kp.Timeout)
-                        select {
-                        case <-timer.C:
-                                if atomic.CompareAndSwapUint32(&t.activity, 1, 0) {
-                                        timer.Reset(t.kp.Time)
-                                        continue
-                                }
-                                t.Close()
-                                return
-                        case <-t.shutdownChan:
-                                if !timer.Stop() {
-                                        <-timer.C
-                                }
-                                return
-                        }
-                case <-t.shutdownChan:
-                        if !timer.Stop() {
-                                <-timer.C
-                        }
-                        return
-                }
-        }
-}
-
-func (t *http2Client) Error() <-chan struct{} {
-        return t.errorChan
-}
-
-func (t *http2Client) GoAway() <-chan struct{} {
-        return t.goAway
-}
-
-func (t *http2Client) notifyError(err error) {
-        t.mu.Lock()
-        // make sure t.errorChan is closed only once.
-        if t.state == draining {
-                t.mu.Unlock()
-                t.Close()
-                return
-        }
-        if t.state == reachable {
-                t.state = unreachable
-                close(t.errorChan)
-                infof("transport: http2Client.notifyError got notified that the client transport was broken %v.", err)
-        }
-        t.mu.Unlock()
-}
diff --git a/vendor/google.golang.org/grpc/naming/go18.go b/vendor/google.golang.org/grpc/version.go
index b5a0f84..45eace5 100644
--- a/vendor/google.golang.org/grpc/naming/go18.go
+++ b/vendor/google.golang.org/grpc/version.go
@@ -1,8 +1,6 @@
-// +build go1.8
-
 /*
  *
- * Copyright 2017 gRPC authors.
+ * Copyright 2018 gRPC authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,11 +16,7 @@
  *
  */
 
-package naming
-
-import "net"
+package grpc
 
-var (
-        lookupHost = net.DefaultResolver.LookupHost
-        lookupSRV  = net.DefaultResolver.LookupSRV
-)
+// Version is the current grpc version.
+const Version = "1.18.0"
diff --git a/vendor/google.golang.org/grpc/vet.sh b/vendor/google.golang.org/grpc/vet.sh
new file mode 100644
index 0000000..94a5064
--- /dev/null
+++ b/vendor/google.golang.org/grpc/vet.sh
@@ -0,0 +1,141 @@
+#!/bin/bash
+
+if [[ `uname -a` = *"Darwin"* ]]; then
+  echo "It seems you are running on Mac. This script does not work on Mac. See https://github.com/grpc/grpc-go/issues/2047"
+  exit 1
+fi
+
+set -ex  # Exit on error; debugging enabled.
+set -o pipefail  # Fail a pipe if any sub-command fails.
+
+die() {
+  echo "$@" >&2
+  exit 1
+}
+
+# Check to make sure it's safe to modify the user's git repo.
+if git status --porcelain | read; then
+  die "Uncommitted or untracked files found; commit changes first"
+fi
+
+if [[ -d "${GOPATH}/src" ]]; then
+  die "\${GOPATH}/src (${GOPATH}/src) exists; this script will delete it."
+fi
+
+# Undo any edits made by this script.
+cleanup() {
+  rm -rf "${GOPATH}/src"
+  git reset --hard HEAD
+}
+trap cleanup EXIT
+
+fail_on_output() {
+  tee /dev/stderr | (! read)
+}
+
+PATH="${GOPATH}/bin:${GOROOT}/bin:${PATH}"
+
+if [[ "$1" = "-install" ]]; then
+  # Check for module support
+  if go help mod >& /dev/null; then
+    go install \
+      golang.org/x/lint/golint \
+      golang.org/x/tools/cmd/goimports \
+      honnef.co/go/tools/cmd/staticcheck \
+      github.com/client9/misspell/cmd/misspell \
+      github.com/golang/protobuf/protoc-gen-go
+  else
+    # Ye olde `go get` incantation.
+    # Note: this gets the latest version of all tools (vs. the pinned versions
+    # with Go modules).
+    go get -u \
+      golang.org/x/lint/golint \
+      golang.org/x/tools/cmd/goimports \
+      honnef.co/go/tools/cmd/staticcheck \
+      github.com/client9/misspell/cmd/misspell \
+      github.com/golang/protobuf/protoc-gen-go
+  fi
+  if [[ -z "${VET_SKIP_PROTO}" ]]; then
+    if [[ "${TRAVIS}" = "true" ]]; then
+      PROTOBUF_VERSION=3.3.0
+      PROTOC_FILENAME=protoc-${PROTOBUF_VERSION}-linux-x86_64.zip
+      pushd /home/travis
+      wget https://github.com/google/protobuf/releases/download/v${PROTOBUF_VERSION}/${PROTOC_FILENAME}
+      unzip ${PROTOC_FILENAME}
+      bin/protoc --version
+      popd
+    elif ! which protoc > /dev/null; then
+      die "Please install protoc into your path"
+    fi
+  fi
+  exit 0
+elif [[ "$#" -ne 0 ]]; then
+  die "Unknown argument(s): $*"
+fi
+
+# - Ensure all source files contain a copyright message.
+git ls-files "*.go" | xargs grep -L "\(Copyright [0-9]\{4,\} gRPC authors\)\|DO NOT EDIT" 2>&1 | fail_on_output
+
+# - Make sure all tests in grpc and grpc/test use leakcheck via Teardown.
+(! grep 'func Test[^(]' *_test.go)
+(! grep 'func Test[^(]' test/*.go)
+
+# - Do not import math/rand for real library code.  Use internal/grpcrand for
+#   thread safety.
+git ls-files "*.go" | xargs grep -l '"math/rand"' 2>&1 | (! grep -v '^examples\|^stress\|grpcrand')
+
+# - Ensure all ptypes proto packages are renamed when importing.
+git ls-files "*.go" | (! xargs grep "\(import \|^\s*\)\"github.com/golang/protobuf/ptypes/")
+
+# - Check imports that are illegal in appengine (until Go 1.11).
+# TODO: Remove when we drop Go 1.10 support
+go list -f {{.Dir}} ./... | xargs go run test/go_vet/vet.go
+
+# - gofmt, goimports, golint (with exceptions for generated code), go vet.
+gofmt -s -d -l . 2>&1 | fail_on_output
+goimports -l . 2>&1 | fail_on_output
+golint ./... 2>&1 | (! grep -vE "(_mock|\.pb)\.go:")
+go tool vet -all .
+
+# - Check that generated proto files are up to date.
+if [[ -z "${VET_SKIP_PROTO}" ]]; then
+  PATH="/home/travis/bin:${PATH}" make proto && \
+    git status --porcelain 2>&1 | fail_on_output || \
+    (git status; git --no-pager diff; exit 1)
+fi
+
+# - Check that our module is tidy.
+if go help mod >& /dev/null; then
+  go mod tidy && \
+    git status --porcelain 2>&1 | fail_on_output || \
+    (git status; git --no-pager diff; exit 1)
+fi
+
+# - Collection of static analysis checks
+### HACK HACK HACK: Remove once staticcheck works with modules.
+# Make a symlink in ${GOPATH}/src to its ${GOPATH}/pkg/mod equivalent for every package we use.
+for x in $(find "${GOPATH}/pkg/mod" -name '*@*' | grep -v \/mod\/cache\/); do
+  pkg="$(echo ${x#"${GOPATH}/pkg/mod/"} | cut -f1 -d@)";
+  # If multiple versions exist, just use the existing one.
+  if [[ -L "${GOPATH}/src/${pkg}" ]]; then continue; fi
+  mkdir -p "$(dirname "${GOPATH}/src/${pkg}")";
+  ln -s $x "${GOPATH}/src/${pkg}";
+done
+### END HACK HACK HACK
+
+# TODO(menghanl): fix errors in transport_test.
+staticcheck -go 1.9 -ignore '
+balancer.go:SA1019
+balancer_test.go:SA1019
+clientconn_test.go:SA1019
+balancer/roundrobin/roundrobin_test.go:SA1019
+benchmark/benchmain/main.go:SA1019
+internal/transport/handler_server.go:SA1019
+internal/transport/handler_server_test.go:SA1019
+internal/transport/transport_test.go:SA2002
+stats/stats_test.go:SA1019
+test/channelz_test.go:SA1019
+test/end2end_test.go:SA1019
+test/healthcheck_test.go:SA1019
+' ./...
+misspell -error .