Upgrade to 0.12

102 files changed, 16140 insertions, 6970 deletions

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/grpc_health_v1/health.proto b/vendor/google.golang.org/grpc/health/grpc_health_v1/health.proto
deleted file mode 100644
index 6072fdc..0000000
--- a/vendor/google.golang.org/grpc/health/grpc_health_v1/health.proto
+++ /dev/null
@@ -1,34 +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.
-
-syntax = "proto3";
-
-package grpc.health.v1;
-
-message HealthCheckRequest {
-  string service = 1;
-}
-
-message HealthCheckResponse {
-  enum ServingStatus {
-        UNKNOWN = 0;
-        SERVING = 1;
-        NOT_SERVING = 2;
-  }
-  ServingStatus status = 1;
-}
-
-service Health{
-  rpc Check(HealthCheckRequest) returns (HealthCheckResponse);
-} 
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 .