Upgrade to 0.12

4 files changed, 617 insertions, 0 deletions

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
+}