vendor: delete

15 files changed, 0 insertions, 3003 deletions

diff --git a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/LICENSE b/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/LICENSE
deleted file mode 100644
index d64569567..000000000
--- a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/LICENSE
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/README.md b/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/README.md
deleted file mode 100644
index 47d809846..000000000
--- a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/README.md
+++ /dev/null
@@ -1,18 +0,0 @@
-
-## How to test Spanner integration
-
-1. Set GCP project id with GCP_PROJECT_ID environment variable.
-
-        export GCP_PROJECT_ID=test-project
-
-1. Set service key credentials file using GOOGLE_APPLICATION_CREDENTIALS env variable.
-
-        export GOOGLE_APPLICATION_CREDENTIALS=/service/account/credentials.json
-
-1. Run the tests.
-
-        go test -v
-
-To skip Spanner setup run
-
-        SKIP_SPANNER=true go test -v
diff --git a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/doc.go b/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/doc.go
deleted file mode 100644
index aae869fb5..000000000
--- a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/doc.go
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- *
- * Copyright 2019 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 grpcgcp provides grpc supports for Google Cloud APIs.
-For now it provides connection management with affinity support.
-
-Note: "channel" is analagous to "connection" in our context.
-
-Usage:
-
-1. First, initialize the api configuration. There are two ways:
-
-	1a. Create a json file defining the configuration and read it.
-
-		// Create some_api_config.json
-		{
-			"channelPool": {
-				"maxSize": 4,
-				"maxConcurrentStreamsLowWatermark": 50
-			},
-			"method": [
-				{
-					"name": [ "/some.api.v1/Method1" ],
-					"affinity": {
-						"command": "BIND",
-						"affinityKey": "key1"
-					}
-				},
-				{
-					"name": [ "/some.api.v1/Method2" ],
-					"affinity": {
-						"command": "BOUND",
-						"affinityKey": "key2"
-					}
-				},
-				{
-					"name": [ "/some.api.v1/Method3" ],
-					"affinity": {
-						"command": "UNBIND",
-						"affinityKey": "key3"
-					}
-				}
-			]
-		}
-
-		jsonFile, err := ioutil.ReadFile("some_api_config.json")
-		if err != nil {
-			t.Fatalf("Failed to read config file: %v", err)
-		}
-		jsonCfg := string(jsonFile)
-
-	1b. Create apiConfig directly and convert it to json.
-
-		// import (
-		// 	configpb "github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/grpc_gcp"
-		// )
-
-		apiConfig := &configpb.ApiConfig{
-			ChannelPool: &configpb.ChannelPoolConfig{
-				MaxSize:                          4,
-				MaxConcurrentStreamsLowWatermark: 50,
-			},
-			Method: []*configpb.MethodConfig{
-				&configpb.MethodConfig{
-					Name: []string{"/some.api.v1/Method1"},
-					Affinity: &configpb.AffinityConfig{
-						Command:     configpb.AffinityConfig_BIND,
-						AffinityKey: "key1",
-					},
-				},
-				&configpb.MethodConfig{
-					Name: []string{"/some.api.v1/Method2"},
-					Affinity: &configpb.AffinityConfig{
-						Command:     configpb.AffinityConfig_BOUND,
-						AffinityKey: "key2",
-					},
-				},
-				&configpb.MethodConfig{
-					Name: []string{"/some.api.v1/Method3"},
-					Affinity: &configpb.AffinityConfig{
-						Command:     configpb.AffinityConfig_UNBIND,
-						AffinityKey: "key3",
-					},
-				},
-			},
-		}
-
-		c, err := protojson.Marshal(apiConfig)
-		if err != nil {
-			t.Fatalf("cannot json encode config: %v", err)
-		}
-		jsonCfg := string(c)
-
-2. Make ClientConn with specific DialOptions to enable grpc_gcp load balancer
-with provided configuration. And specify gRPC-GCP interceptors.
-
-	conn, err := grpc.Dial(
-		target,
-		// Register and specify the grpc-gcp load balancer.
-		grpc.WithDisableServiceConfig(),
-		grpc.WithDefaultServiceConfig(
-			fmt.Sprintf(
-				`{"loadBalancingConfig": [{"%s":%s}]}`,
-				grpcgcp.Name,
-				jsonCfg,
-			),
-		),
-		// Set grpcgcp interceptors.
-		grpc.WithUnaryInterceptor(grpcgcp.GCPUnaryClientInterceptor),
-		grpc.WithStreamInterceptor(grpcgcp.GCPStreamClientInterceptor),
-	)
-*/
-package grpcgcp // import "github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp"
diff --git a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/gcp_balancer.go b/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/gcp_balancer.go
deleted file mode 100644
index 6fdac53d6..000000000
--- a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/gcp_balancer.go
+++ /dev/null
@@ -1,576 +0,0 @@
-/*
- *
- * 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 grpcgcp
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"google.golang.org/grpc/balancer"
-	"google.golang.org/grpc/connectivity"
-	"google.golang.org/grpc/grpclog"
-	"google.golang.org/grpc/resolver"
-	"google.golang.org/grpc/serviceconfig"
-	"google.golang.org/protobuf/encoding/protojson"
-	"google.golang.org/protobuf/proto"
-
-	pb "github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/grpc_gcp"
-)
-
-var _ balancer.Balancer = (*gcpBalancer)(nil) // Ensure gcpBalancer implements Balancer
-
-const (
-	// Name is the name of grpc_gcp balancer.
-	Name = "grpc_gcp"
-
-	healthCheckEnabled = true
-	defaultMinSize     = 1
-	defaultMaxSize     = 4
-	defaultMaxStreams  = 100
-)
-
-func init() {
-	balancer.Register(newBuilder())
-}
-
-type gcpBalancerBuilder struct {
-	balancer.ConfigParser
-}
-
-type GCPBalancerConfig struct {
-	serviceconfig.LoadBalancingConfig
-	*pb.ApiConfig
-}
-
-func (bb *gcpBalancerBuilder) Build(
-	cc balancer.ClientConn,
-	opt balancer.BuildOptions,
-) balancer.Balancer {
-	gb := &gcpBalancer{
-		cc:               cc,
-		methodCfg:        make(map[string]*pb.AffinityConfig),
-		affinityMap:      make(map[string]balancer.SubConn),
-		fallbackMap:      make(map[string]balancer.SubConn),
-		scRefs:           make(map[balancer.SubConn]*subConnRef),
-		scStates:         make(map[balancer.SubConn]connectivity.State),
-		refreshingScRefs: make(map[balancer.SubConn]*subConnRef),
-		scRefList:        []*subConnRef{},
-		rrRefId:          ^uint32(0),
-		csEvltr:          &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),
-	}
-	gb.log = NewGCPLogger(compLogger, fmt.Sprintf("[gcpBalancer %p]", gb))
-	return gb
-}
-
-func (*gcpBalancerBuilder) Name() string {
-	return Name
-}
-
-// ParseConfig converts raw json config into GCPBalancerConfig.
-// This is called by ClientConn on any load balancer config update.
-// After parsing the config, ClientConn calls UpdateClientConnState passing the config.
-func (*gcpBalancerBuilder) ParseConfig(j json.RawMessage) (serviceconfig.LoadBalancingConfig, error) {
-	c := &GCPBalancerConfig{
-		ApiConfig: &pb.ApiConfig{},
-	}
-	err := protojson.Unmarshal(j, c)
-	return c, err
-}
-
-// newBuilder creates a new grpcgcp balancer builder.
-func newBuilder() balancer.Builder {
-	return &gcpBalancerBuilder{}
-}
-
-// connectivityStateEvaluator gets updated by addrConns when their
-// states transition, based on which it evaluates the state of
-// ClientConn.
-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 every subConn and based on
-// that it evaluates what aggregated state should be.
-// It can only transition between Ready, Connecting and TransientFailure. Other states,
-// Idle and Shutdown are transitioned into by ClientConn; in the beginning of the connection
-// before any subConn is created ClientConn is in idle state. In the end when ClientConn
-// closes it is in Shutdown state.
-//
-// recordTransition should only be called synchronously from the same goroutine.
-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
-}
-
-// subConnRef keeps reference to the real SubConn with its
-// connectivity state, affinity count and streams count.
-type subConnRef struct {
-	subConn     balancer.SubConn
-	stateSignal chan struct{} // This channel is closed and re-created when subConn or its state changes.
-	affinityCnt int32         // Keeps track of the number of keys bound to the subConn.
-	streamsCnt  int32         // Keeps track of the number of streams opened on the subConn.
-	lastResp    time.Time     // Timestamp of the last response from the server.
-	deCalls     uint32        // Keeps track of deadline exceeded calls since last response.
-	refreshing  bool          // If this subconn is in the process of refreshing.
-	refreshCnt  uint32        // Number of refreshes since last response.
-}
-
-func (ref *subConnRef) getAffinityCnt() int32 {
-	return atomic.LoadInt32(&ref.affinityCnt)
-}
-
-func (ref *subConnRef) getStreamsCnt() int32 {
-	return atomic.LoadInt32(&ref.streamsCnt)
-}
-
-func (ref *subConnRef) affinityIncr() {
-	atomic.AddInt32(&ref.affinityCnt, 1)
-}
-
-func (ref *subConnRef) affinityDecr() {
-	atomic.AddInt32(&ref.affinityCnt, -1)
-}
-
-func (ref *subConnRef) streamsIncr() {
-	atomic.AddInt32(&ref.streamsCnt, 1)
-}
-
-func (ref *subConnRef) streamsDecr() {
-	atomic.AddInt32(&ref.streamsCnt, -1)
-}
-
-func (ref *subConnRef) deCallsInc() uint32 {
-	return atomic.AddUint32(&ref.deCalls, 1)
-}
-
-func (ref *subConnRef) gotResp() {
-	ref.lastResp = time.Now()
-	atomic.StoreUint32(&ref.deCalls, 0)
-	ref.refreshCnt = 0
-}
-
-type gcpBalancer struct {
-	cfg       *GCPBalancerConfig
-	methodCfg map[string]*pb.AffinityConfig
-
-	addrs   []resolver.Address
-	cc      balancer.ClientConn
-	csEvltr *connectivityStateEvaluator
-	state   connectivity.State
-
-	mu          sync.RWMutex
-	affinityMap map[string]balancer.SubConn
-	fallbackMap map[string]balancer.SubConn
-	scStates    map[balancer.SubConn]connectivity.State
-	scRefs      map[balancer.SubConn]*subConnRef
-	scRefList   []*subConnRef
-	rrRefId     uint32
-
-	// Map from a fresh SubConn to the subConnRef where we want to refresh subConn.
-	refreshingScRefs map[balancer.SubConn]*subConnRef
-	// Unresponsive detection enabled flag.
-	unresponsiveDetection bool
-
-	picker balancer.Picker
-	log    grpclog.LoggerV2
-}
-
-func (gb *gcpBalancer) initializeConfig(cfg *GCPBalancerConfig) {
-	gb.cfg = &GCPBalancerConfig{
-		ApiConfig: &pb.ApiConfig{
-			ChannelPool: &pb.ChannelPoolConfig{},
-		},
-	}
-	if cfg != nil && cfg.ApiConfig != nil {
-		gb.cfg = &GCPBalancerConfig{
-			ApiConfig: proto.Clone(cfg.ApiConfig).(*pb.ApiConfig),
-		}
-	}
-
-	if gb.cfg.GetChannelPool() == nil {
-		gb.cfg.ChannelPool = &pb.ChannelPoolConfig{}
-	}
-	cp := gb.cfg.GetChannelPool()
-	if cp.GetMinSize() == 0 {
-		cp.MinSize = defaultMinSize
-	}
-	if cp.GetMaxSize() == 0 {
-		cp.MaxSize = defaultMaxSize
-	}
-	if cp.GetMaxConcurrentStreamsLowWatermark() == 0 {
-		cp.MaxConcurrentStreamsLowWatermark = defaultMaxStreams
-	}
-	mp := make(map[string]*pb.AffinityConfig)
-	methodCfgs := gb.cfg.GetMethod()
-	for _, methodCfg := range methodCfgs {
-		methodNames := methodCfg.GetName()
-		affinityCfg := methodCfg.GetAffinity()
-		if methodNames != nil && affinityCfg != nil {
-			for _, method := range methodNames {
-				mp[method] = affinityCfg
-			}
-		}
-	}
-	gb.methodCfg = mp
-	gb.unresponsiveDetection = cp.GetUnresponsiveCalls() > 0 && cp.GetUnresponsiveDetectionMs() > 0
-	gb.enforceMinSize()
-}
-
-func (gb *gcpBalancer) enforceMinSize() {
-	for len(gb.scRefs) < int(gb.cfg.GetChannelPool().GetMinSize()) {
-		gb.addSubConn()
-	}
-}
-
-func (gb *gcpBalancer) UpdateClientConnState(ccs balancer.ClientConnState) error {
-	gb.mu.Lock()
-	defer gb.mu.Unlock()
-	addrs := ccs.ResolverState.Addresses
-	if gb.log.V(FINE) {
-		gb.log.Infoln("got new resolved addresses: ", addrs, " and balancer config: ", ccs.BalancerConfig)
-	}
-	gb.addrs = addrs
-	if gb.cfg == nil {
-		cfg, ok := ccs.BalancerConfig.(*GCPBalancerConfig)
-		if !ok && ccs.BalancerConfig != nil {
-			return fmt.Errorf("provided config is not GCPBalancerConfig: %v", ccs.BalancerConfig)
-		}
-		gb.initializeConfig(cfg)
-	}
-
-	if len(gb.scRefs) == 0 {
-		gb.newSubConn()
-		return nil
-	}
-
-	for _, scRef := range gb.scRefs {
-		// TODO(weiranf): update streams count when new addrs resolved?
-		scRef.subConn.UpdateAddresses(addrs)
-		scRef.subConn.Connect()
-	}
-
-	return nil
-}
-
-func (gb *gcpBalancer) ResolverError(err error) {
-	gb.log.Warningf("ResolverError: %v", err)
-}
-
-// check current connection pool size
-func (gb *gcpBalancer) getConnectionPoolSize() int {
-	// TODO(golobokov): replace this with locked increase of subconns.
-	gb.mu.Lock()
-	defer gb.mu.Unlock()
-	return len(gb.scRefs)
-}
-
-// newSubConn creates a new SubConn using cc.NewSubConn and initialize the subConnRef
-// if none of the subconns are in the Connecting state.
-func (gb *gcpBalancer) newSubConn() {
-	gb.mu.Lock()
-	defer gb.mu.Unlock()
-
-	// there are chances the newly created subconns are still connecting,
-	// we can wait on those new subconns.
-	for _, scState := range gb.scStates {
-		if scState == connectivity.Connecting || scState == connectivity.Idle {
-			return
-		}
-	}
-	gb.addSubConn()
-}
-
-// addSubConn creates a new SubConn using cc.NewSubConn and initialize the subConnRef.
-// Must be called holding the mutex lock.
-func (gb *gcpBalancer) addSubConn() {
-	sc, err := gb.cc.NewSubConn(
-		gb.addrs,
-		balancer.NewSubConnOptions{HealthCheckEnabled: healthCheckEnabled},
-	)
-	if err != nil {
-		gb.log.Errorf("failed to NewSubConn: %v", err)
-		return
-	}
-	gb.scRefs[sc] = &subConnRef{
-		subConn:     sc,
-		stateSignal: make(chan struct{}),
-		lastResp:    time.Now(),
-	}
-	gb.scStates[sc] = connectivity.Idle
-	gb.scRefList = append(gb.scRefList, gb.scRefs[sc])
-	sc.Connect()
-}
-
-// getReadySubConnRef returns a subConnRef and a bool. The bool indicates whether
-// the boundKey exists in the affinityMap. If returned subConnRef is a nil, it
-// means the underlying subconn is not READY yet.
-func (gb *gcpBalancer) getReadySubConnRef(boundKey string) (*subConnRef, bool) {
-	gb.mu.Lock()
-	defer gb.mu.Unlock()
-
-	if sc, ok := gb.affinityMap[boundKey]; ok {
-		if gb.scStates[sc] != connectivity.Ready {
-			// It's possible that the bound subconn is not in the readySubConns list,
-			// If it's not ready, we throw ErrNoSubConnAvailable or
-			// fallback to a previously mapped ready subconn or the least busy.
-			if gb.cfg.GetChannelPool().GetFallbackToReady() {
-				if sc, ok := gb.fallbackMap[boundKey]; ok {
-					return gb.scRefs[sc], true
-				}
-				// Try to create fallback mapping.
-				if scRef, err := gb.picker.(*gcpPicker).getLeastBusySubConnRef(); err == nil {
-					gb.fallbackMap[boundKey] = scRef.subConn
-					return scRef, true
-				}
-			}
-			return nil, true
-		}
-		return gb.scRefs[sc], true
-	}
-	return nil, false
-}
-
-func (gb *gcpBalancer) getSubConnRoundRobin(ctx context.Context) *subConnRef {
-	if len(gb.scRefList) == 0 {
-		gb.newSubConn()
-	}
-	scRef := gb.scRefList[atomic.AddUint32(&gb.rrRefId, 1)%uint32(len(gb.scRefList))]
-
-	gb.mu.RLock()
-	if state := gb.scStates[scRef.subConn]; state == connectivity.Ready {
-		gb.mu.RUnlock()
-		return scRef
-	} else {
-		grpclog.Infof("grpcgcp.gcpBalancer: scRef is not ready: %v", state)
-	}
-
-	ticker := time.NewTicker(time.Millisecond * 100)
-	defer ticker.Stop()
-
-	// Wait until SubConn is ready or call context is done.
-	for gb.scStates[scRef.subConn] != connectivity.Ready {
-		sigChan := scRef.stateSignal
-		gb.mu.RUnlock()
-		select {
-		case <-ctx.Done():
-			return scRef
-		case <-ticker.C:
-		case <-sigChan:
-		}
-		gb.mu.RLock()
-	}
-	gb.mu.RUnlock()
-
-	return scRef
-}
-
-// bindSubConn binds the given affinity key to an existing subConnRef.
-func (gb *gcpBalancer) bindSubConn(bindKey string, sc balancer.SubConn) {
-	gb.mu.Lock()
-	defer gb.mu.Unlock()
-	_, ok := gb.affinityMap[bindKey]
-	if !ok {
-		gb.affinityMap[bindKey] = sc
-	}
-	gb.scRefs[sc].affinityIncr()
-}
-
-// unbindSubConn removes the existing binding associated with the key.
-func (gb *gcpBalancer) unbindSubConn(boundKey string) {
-	gb.mu.Lock()
-	defer gb.mu.Unlock()
-	boundSC, ok := gb.affinityMap[boundKey]
-	if ok {
-		gb.scRefs[boundSC].affinityDecr()
-		delete(gb.affinityMap, boundKey)
-	}
-}
-
-// 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 (gb *gcpBalancer) regeneratePicker() {
-	if gb.state == connectivity.TransientFailure {
-		gb.picker = newErrPicker(balancer.ErrTransientFailure)
-		return
-	}
-	readyRefs := []*subConnRef{}
-
-	// Select ready subConns from subConn map.
-	for sc, scState := range gb.scStates {
-		if scState == connectivity.Ready {
-			readyRefs = append(readyRefs, gb.scRefs[sc])
-		}
-	}
-	gb.picker = newGCPPicker(readyRefs, gb)
-}
-
-func (gb *gcpBalancer) UpdateSubConnState(sc balancer.SubConn, scs balancer.SubConnState) {
-	gb.mu.Lock()
-	defer gb.mu.Unlock()
-	s := scs.ConnectivityState
-
-	if scRef, found := gb.refreshingScRefs[sc]; found {
-		if gb.log.V(FINE) {
-			gb.log.Infof("handle replacement SubConn state change: %p, %v", sc, s)
-		}
-		if s != connectivity.Ready {
-			// Ignore the replacement sc until it's ready.
-			return
-		}
-
-		// Replace SubConn of the scRef with the fresh SubConn (sc) concluding
-		// the refresh process initiated by refresh(*subConnRef).
-		oldSc := scRef.subConn
-		gb.scStates[sc] = gb.scStates[oldSc]
-		delete(gb.refreshingScRefs, sc)
-		delete(gb.scRefs, oldSc)
-		delete(gb.scStates, oldSc)
-		gb.scRefs[sc] = scRef
-		scRef.subConn = sc
-		scRef.deCalls = 0
-		scRef.lastResp = time.Now()
-		scRef.refreshing = false
-		scRef.refreshCnt++
-		gb.cc.RemoveSubConn(oldSc)
-	}
-
-	if gb.log.V(FINE) {
-		gb.log.Infof("handle SubConn state change: %p, %v", sc, s)
-	}
-
-	oldS, ok := gb.scStates[sc]
-	if !ok {
-		if gb.log.V(FINE) {
-			gb.log.Infof(
-				"got state changes for an unknown/replaced SubConn: %p, %v",
-				sc,
-				s,
-			)
-		}
-		return
-	}
-	gb.scStates[sc] = s
-	switch s {
-	case connectivity.Idle:
-		sc.Connect()
-	case connectivity.Shutdown:
-		delete(gb.scRefs, sc)
-		delete(gb.scStates, sc)
-	}
-	if oldS == connectivity.Ready && s != oldS {
-		// Subconn is broken. Remove fallback mapping to this subconn.
-		for k, v := range gb.fallbackMap {
-			if v == sc {
-				delete(gb.fallbackMap, k)
-			}
-		}
-	}
-	if oldS != connectivity.Ready && s == connectivity.Ready {
-		// Remove fallback mapping for the keys of recovered subconn.
-		for k := range gb.fallbackMap {
-			if gb.affinityMap[k] == sc {
-				delete(gb.fallbackMap, k)
-			}
-		}
-	}
-
-	oldAggrState := gb.state
-	gb.state = gb.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) ||
-		(gb.state == connectivity.TransientFailure) != (oldAggrState == connectivity.TransientFailure) {
-		gb.regeneratePicker()
-		gb.cc.UpdateState(balancer.State{
-			ConnectivityState: gb.state,
-			Picker:            gb.picker,
-		})
-	}
-
-	if scRef := gb.scRefs[sc]; scRef != nil {
-		// Inform of the state change.
-		close(scRef.stateSignal)
-		scRef.stateSignal = make(chan struct{})
-	}
-}
-
-// refresh initiates a new SubConn for a specific subConnRef and starts connecting.
-// If the refresh is already initiated for the ref, then this is a no-op.
-func (gb *gcpBalancer) refresh(ref *subConnRef) {
-	if ref.refreshing {
-		return
-	}
-	gb.mu.Lock()
-	defer gb.mu.Unlock()
-	if ref.refreshing {
-		return
-	}
-	ref.refreshing = true
-	sc, err := gb.cc.NewSubConn(
-		gb.addrs,
-		balancer.NewSubConnOptions{HealthCheckEnabled: healthCheckEnabled},
-	)
-	if err != nil {
-		gb.log.Errorf("failed to create a replacement SubConn with NewSubConn: %v", err)
-		return
-	}
-	gb.refreshingScRefs[sc] = ref
-	sc.Connect()
-}
-
-func (gb *gcpBalancer) Close() {
-}
diff --git a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/gcp_interceptor.go b/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/gcp_interceptor.go
deleted file mode 100644
index c0d77f1ce..000000000
--- a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/gcp_interceptor.go
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- *
- * Copyright 2019 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 grpcgcp
-
-import (
-	"context"
-	"sync"
-
-	"google.golang.org/grpc"
-)
-
-type key int
-
-var gcpKey key
-
-type gcpContext struct {
-	// request message used for pre-process of an affinity call
-	reqMsg interface{}
-	// response message used for post-process of an affinity call
-	replyMsg interface{}
-}
-
-// GCPUnaryClientInterceptor intercepts the execution of a unary RPC
-// and injects necessary information to be used by the picker.
-func GCPUnaryClientInterceptor(
-	ctx context.Context,
-	method string,
-	req interface{},
-	reply interface{},
-	cc *grpc.ClientConn,
-	invoker grpc.UnaryInvoker,
-	opts ...grpc.CallOption,
-) error {
-	gcpCtx := &gcpContext{
-		reqMsg:   req,
-		replyMsg: reply,
-	}
-	ctx = context.WithValue(ctx, gcpKey, gcpCtx)
-
-	return invoker(ctx, method, req, reply, cc, opts...)
-}
-
-// GCPStreamClientInterceptor intercepts the execution of a client streaming RPC
-// and injects necessary information to be used by the picker.
-func GCPStreamClientInterceptor(
-	ctx context.Context,
-	desc *grpc.StreamDesc,
-	cc *grpc.ClientConn,
-	method string,
-	streamer grpc.Streamer,
-	opts ...grpc.CallOption,
-) (grpc.ClientStream, error) {
-	// This constructor does not create a real ClientStream,
-	// it only stores all parameters and let SendMsg() to create ClientStream.
-	cs := &gcpClientStream{
-		ctx:      ctx,
-		desc:     desc,
-		cc:       cc,
-		method:   method,
-		streamer: streamer,
-		opts:     opts,
-	}
-	cs.cond = sync.NewCond(cs)
-	return cs, nil
-}
-
-type gcpClientStream struct {
-	sync.Mutex
-	grpc.ClientStream
-
-	cond          *sync.Cond
-	initStreamErr error
-
-	ctx      context.Context
-	desc     *grpc.StreamDesc
-	cc       *grpc.ClientConn
-	method   string
-	streamer grpc.Streamer
-	opts     []grpc.CallOption
-}
-
-func (cs *gcpClientStream) SendMsg(m interface{}) error {
-	cs.Lock()
-	// Initialize underlying ClientStream when getting the first request.
-	if cs.ClientStream == nil {
-		ctx := context.WithValue(cs.ctx, gcpKey, &gcpContext{reqMsg: m})
-		realCS, err := cs.streamer(ctx, cs.desc, cs.cc, cs.method, cs.opts...)
-		if err != nil {
-			cs.initStreamErr = err
-			cs.Unlock()
-			cs.cond.Broadcast()
-			return err
-		}
-		cs.ClientStream = realCS
-	}
-	cs.Unlock()
-	cs.cond.Broadcast()
-	return cs.ClientStream.SendMsg(m)
-}
-
-func (cs *gcpClientStream) RecvMsg(m interface{}) error {
-	// If RecvMsg is called before SendMsg, it should wait until cs.ClientStream
-	// is initialized or the initialization failed.
-	cs.Lock()
-	for cs.initStreamErr == nil && cs.ClientStream == nil {
-		cs.cond.Wait()
-	}
-	if cs.initStreamErr != nil {
-		cs.Unlock()
-		return cs.initStreamErr
-	}
-	cs.Unlock()
-	return cs.ClientStream.RecvMsg(m)
-}
diff --git a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/gcp_logger.go b/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/gcp_logger.go
deleted file mode 100644
index cd1caf301..000000000
--- a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/gcp_logger.go
+++ /dev/null
@@ -1,98 +0,0 @@
-package grpcgcp
-
-import (
-	"strings"
-
-	"google.golang.org/grpc/grpclog"
-)
-
-const (
-	FINE   = 90
-	FINEST = 99
-)
-
-var compLogger = grpclog.Component("grpcgcp")
-
-type gcpLogger struct {
-	logger grpclog.LoggerV2
-	prefix string
-}
-
-// Make sure gcpLogger implements grpclog.LoggerV2.
-var _ grpclog.LoggerV2 = (*gcpLogger)(nil)
-
-func NewGCPLogger(logger grpclog.LoggerV2, prefix string) *gcpLogger {
-	p := prefix
-	if !strings.HasSuffix(p, " ") {
-		p = p + " "
-	}
-	return &gcpLogger{
-		logger: logger,
-		prefix: p,
-	}
-}
-
-// Error implements grpclog.LoggerV2.
-func (l *gcpLogger) Error(args ...interface{}) {
-	l.logger.Error(append([]interface{}{l.prefix}, args)...)
-}
-
-// Errorf implements grpclog.LoggerV2.
-func (l *gcpLogger) Errorf(format string, args ...interface{}) {
-	l.logger.Errorf(l.prefix+format, args...)
-}
-
-// Errorln implements grpclog.LoggerV2.
-func (l *gcpLogger) Errorln(args ...interface{}) {
-	l.logger.Errorln(append([]interface{}{l.prefix}, args)...)
-}
-
-// Fatal implements grpclog.LoggerV2.
-func (l *gcpLogger) Fatal(args ...interface{}) {
-	l.logger.Fatal(append([]interface{}{l.prefix}, args)...)
-}
-
-// Fatalf implements grpclog.LoggerV2.
-func (l *gcpLogger) Fatalf(format string, args ...interface{}) {
-	l.logger.Fatalf(l.prefix+format, args...)
-}
-
-// Fatalln implements grpclog.LoggerV2.
-func (l *gcpLogger) Fatalln(args ...interface{}) {
-	l.Fatalln(append([]interface{}{l.prefix}, args)...)
-}
-
-// Info implements grpclog.LoggerV2.
-func (l *gcpLogger) Info(args ...interface{}) {
-	l.logger.Info(append([]interface{}{l.prefix}, args)...)
-}
-
-// Infof implements grpclog.LoggerV2.
-func (l *gcpLogger) Infof(format string, args ...interface{}) {
-	l.logger.Infof(l.prefix+format, args...)
-}
-
-// Infoln implements grpclog.LoggerV2.
-func (l *gcpLogger) Infoln(args ...interface{}) {
-	l.logger.Infoln(append([]interface{}{l.prefix}, args)...)
-}
-
-// V implements grpclog.LoggerV2.
-func (l *gcpLogger) V(level int) bool {
-	return l.logger.V(level)
-}
-
-// Warning implements grpclog.LoggerV2.
-func (l *gcpLogger) Warning(args ...interface{}) {
-	l.logger.Warning(append([]interface{}{l.prefix}, args)...)
-}
-
-// Warningf implements grpclog.LoggerV2.
-func (l *gcpLogger) Warningf(format string, args ...interface{}) {
-	l.logger.Warningf(l.prefix+format, args...)
-}
-
-// Warningln implements grpclog.LoggerV2.
-func (l *gcpLogger) Warningln(args ...interface{}) {
-	l.logger.Warningln(append([]interface{}{l.prefix}, args)...)
-}
diff --git a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/gcp_multiendpoint.go b/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/gcp_multiendpoint.go
deleted file mode 100644
index 9ee507437..000000000
--- a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/gcp_multiendpoint.go
+++ /dev/null
@@ -1,408 +0,0 @@
-/*
- *
- * Copyright 2023 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 grpcgcp
-
-import (
-	"context"
-	"fmt"
-	"sync"
-	"sync/atomic"
-
-	"github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/multiendpoint"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/connectivity"
-	"google.golang.org/grpc/grpclog"
-	"google.golang.org/protobuf/encoding/protojson"
-	"google.golang.org/protobuf/proto"
-
-	pb "github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/grpc_gcp"
-)
-
-var gmeCounter uint32
-
-type contextMEKey int
-
-var meKey contextMEKey
-
-// NewMEContext returns a new Context that carries Multiendpoint name.
-func NewMEContext(ctx context.Context, name string) context.Context {
-	return context.WithValue(ctx, meKey, name)
-}
-
-// FromMEContext returns the MultiEndpoint name stored in ctx, if any.
-func FromMEContext(ctx context.Context) (string, bool) {
-	name, ok := ctx.Value(meKey).(string)
-	return name, ok
-}
-
-// GCPMultiEndpoint holds the state of MultiEndpoints-enabled gRPC client connection.
-//
-// The purposes of GCPMultiEndpoint are:
-//
-//   - Fallback to an alternative endpoint (host:port) of a gRPC service when the original
-//     endpoint is completely unavailable.
-//   - Be able to route an RPC call to a specific group of endpoints.
-//   - Be able to reconfigure endpoints in runtime.
-//
-// A group of endpoints is called a [multiendpoint.MultiEndpoint] and is essentially a list of endpoints
-// where priority is defined by the position in the list with the first endpoint having top
-// priority. A MultiEndpoint tracks endpoints' availability. When a MultiEndpoint is picked for an
-// RPC call, it picks the top priority endpoint that is currently available. More information on the
-// [multiendpoint.MultiEndpoint].
-//
-// GCPMultiEndpoint can have one or more MultiEndpoint identified by its name -- arbitrary
-// string provided in the [GCPMultiEndpointOptions] when configuring MultiEndpoints. This name
-// can be used to route an RPC call to this MultiEndpoint by using the [NewMEContext].
-//
-// GCPMultiEndpoint uses [GCPMultiEndpointOptions] for initial configuration.
-// An updated configuration can be provided at any time later using [UpdateMultiEndpoints].
-//
-// Example:
-//
-// Let's assume we have a service with read and write operations and the following backends:
-//
-//   - service.example.com -- the main set of backends supporting all operations
-//   - service-fallback.example.com -- read-write replica supporting all operations
-//   - ro-service.example.com -- read-only replica supporting only read operations
-//
-// Example configuration:
-//
-//   - MultiEndpoint named "default" with endpoints:
-//
-//     1. service.example.com:443
-//
-//     2. service-fallback.example.com:443
-//
-//   - MultiEndpoint named "read" with endpoints:
-//
-//     1. ro-service.example.com:443
-//
-//     2. service-fallback.example.com:443
-//
-//     3. service.example.com:443
-//
-// With the configuration above GCPMultiEndpoint will use the "default" MultiEndpoint by
-// default. It means that RPC calls by default will use the main endpoint and if it is not available
-// then the read-write replica.
-//
-// To offload some read calls to the read-only replica we can specify "read" MultiEndpoint in the
-// context. Then these calls will use the read-only replica endpoint and if it is not available
-// then the read-write replica and if it is also not available then the main endpoint.
-//
-// GCPMultiEndpoint creates a [grpcgcp] connection pool for every unique
-// endpoint. For the example above three connection pools will be created.
-//
-// [GCPMultiEndpoint] implements [grpc.ClientConnInterface] and can be used
-// as a [grpc.ClientConn] when creating gRPC clients.
-type GCPMultiEndpoint struct {
-	mu sync.RWMutex
-
-	defaultName string
-	mes         map[string]multiendpoint.MultiEndpoint
-	pools       map[string]*monitoredConn
-	opts        []grpc.DialOption
-	gcpConfig   *pb.ApiConfig
-	dialFunc    func(ctx context.Context, target string, dopts ...grpc.DialOption) (*grpc.ClientConn, error)
-	log         grpclog.LoggerV2
-
-	grpc.ClientConnInterface
-}
-
-// Make sure GCPMultiEndpoint implements grpc.ClientConnInterface.
-var _ grpc.ClientConnInterface = (*GCPMultiEndpoint)(nil)
-
-func (gme *GCPMultiEndpoint) Invoke(ctx context.Context, method string, args interface{}, reply interface{}, opts ...grpc.CallOption) error {
-	return gme.pickConn(ctx).Invoke(ctx, method, args, reply, opts...)
-}
-
-func (gme *GCPMultiEndpoint) NewStream(ctx context.Context, desc *grpc.StreamDesc, method string, opts ...grpc.CallOption) (grpc.ClientStream, error) {
-	return gme.pickConn(ctx).NewStream(ctx, desc, method, opts...)
-}
-
-func (gme *GCPMultiEndpoint) pickConn(ctx context.Context) *grpc.ClientConn {
-	name, ok := FromMEContext(ctx)
-	me, ook := gme.mes[name]
-	if !ok || !ook {
-		me = gme.mes[gme.defaultName]
-	}
-	return gme.pools[me.Current()].conn
-}
-
-func (gme *GCPMultiEndpoint) Close() error {
-	var errs multiError
-	for e, mc := range gme.pools {
-		mc.stopMonitoring()
-		if err := mc.conn.Close(); err != nil {
-			errs = append(errs, err)
-			gme.log.Errorf("error while closing the pool for %q endpoint: %v", e, err)
-		}
-		if gme.log.V(FINE) {
-			gme.log.Infof("closed channel pool for %q endpoint.", e)
-		}
-	}
-	return errs.Combine()
-}
-
-func (gme *GCPMultiEndpoint) GCPConfig() *pb.ApiConfig {
-	return proto.Clone(gme.gcpConfig).(*pb.ApiConfig)
-}
-
-// GCPMultiEndpointOptions holds options to construct a MultiEndpoints-enabled gRPC client
-// connection.
-type GCPMultiEndpointOptions struct {
-	// Regular gRPC-GCP configuration to be applied to every endpoint.
-	GRPCgcpConfig *pb.ApiConfig
-	// Map of MultiEndpoints where key is the MultiEndpoint name.
-	MultiEndpoints map[string]*multiendpoint.MultiEndpointOptions
-	// Name of the default MultiEndpoint.
-	Default string
-	// Func to dial grpc ClientConn.
-	DialFunc func(ctx context.Context, target string, dopts ...grpc.DialOption) (*grpc.ClientConn, error)
-}
-
-// NewGCPMultiEndpoint creates new [GCPMultiEndpoint] -- MultiEndpoints-enabled gRPC client
-// connection.
-//
-// Deprecated: use NewGCPMultiEndpoint.
-func NewGcpMultiEndpoint(meOpts *GCPMultiEndpointOptions, opts ...grpc.DialOption) (*GCPMultiEndpoint, error) {
-	return NewGCPMultiEndpoint(meOpts, opts...)
-}
-
-// NewGCPMultiEndpoint creates new [GCPMultiEndpoint] -- MultiEndpoints-enabled gRPC client
-// connection.
-//
-// [GCPMultiEndpoint] implements [grpc.ClientConnInterface] and can be used
-// as a [grpc.ClientConn] when creating gRPC clients.
-func NewGCPMultiEndpoint(meOpts *GCPMultiEndpointOptions, opts ...grpc.DialOption) (*GCPMultiEndpoint, error) {
-	// Read config, create multiendpoints and pools.
-	o, err := makeOpts(meOpts, opts)
-	if err != nil {
-		return nil, err
-	}
-	gme := &GCPMultiEndpoint{
-		mes:         make(map[string]multiendpoint.MultiEndpoint),
-		pools:       make(map[string]*monitoredConn),
-		defaultName: meOpts.Default,
-		opts:        o,
-		gcpConfig:   proto.Clone(meOpts.GRPCgcpConfig).(*pb.ApiConfig),
-		dialFunc:    meOpts.DialFunc,
-		log:         NewGCPLogger(compLogger, fmt.Sprintf("[GCPMultiEndpoint #%d]", atomic.AddUint32(&gmeCounter, 1))),
-	}
-	if gme.dialFunc == nil {
-		gme.dialFunc = func(_ context.Context, target string, opts ...grpc.DialOption) (*grpc.ClientConn, error) {
-			return grpc.Dial(target, opts...)
-		}
-	}
-	if err := gme.UpdateMultiEndpoints(meOpts); err != nil {
-		return nil, err
-	}
-	return gme, nil
-}
-
-func makeOpts(meOpts *GCPMultiEndpointOptions, opts []grpc.DialOption) ([]grpc.DialOption, error) {
-	grpcGCPjsonConfig, err := protojson.Marshal(meOpts.GRPCgcpConfig)
-	if err != nil {
-		return nil, err
-	}
-	o := append([]grpc.DialOption{}, opts...)
-	o = append(o, []grpc.DialOption{
-		grpc.WithDisableServiceConfig(),
-		grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"loadBalancingConfig": [{"%s":%s}]}`, Name, string(grpcGCPjsonConfig))),
-		grpc.WithChainUnaryInterceptor(GCPUnaryClientInterceptor),
-		grpc.WithChainStreamInterceptor(GCPStreamClientInterceptor),
-	}...)
-
-	return o, nil
-}
-
-type monitoredConn struct {
-	endpoint string
-	conn     *grpc.ClientConn
-	gme      *GCPMultiEndpoint
-	cancel   context.CancelFunc
-}
-
-func newMonitoredConn(endpoint string, conn *grpc.ClientConn, gme *GCPMultiEndpoint) (mc *monitoredConn) {
-	ctx, cancel := context.WithCancel(context.Background())
-	mc = &monitoredConn{
-		endpoint: endpoint,
-		conn:     conn,
-		gme:      gme,
-		cancel:   cancel,
-	}
-	go mc.monitor(ctx)
-	return
-}
-
-func (mc *monitoredConn) notify(state connectivity.State) {
-	if mc.gme.log.V(FINE) {
-		mc.gme.log.Infof("%q endpoint state changed to %v", mc.endpoint, state)
-	}
-	// Inform all multiendpoints.
-	mc.gme.mu.RLock()
-	for _, me := range mc.gme.mes {
-		me.SetEndpointAvailability(mc.endpoint, state == connectivity.Ready)
-	}
-	mc.gme.mu.RUnlock()
-}
-
-func (mc *monitoredConn) monitor(ctx context.Context) {
-	for {
-		currentState := mc.conn.GetState()
-		mc.notify(currentState)
-		if !mc.conn.WaitForStateChange(ctx, currentState) {
-			break
-		}
-	}
-}
-
-func (mc *monitoredConn) stopMonitoring() {
-	mc.cancel()
-}
-
-// UpdateMultiEndpoints reconfigures MultiEndpoints.
-//
-// MultiEndpoints are matched with the current ones by name.
-//
-//   - If a current MultiEndpoint is missing in the updated list, the MultiEndpoint will be
-//     removed.
-//   - A new MultiEndpoint will be created for every new name in the list.
-//   - For an existing MultiEndpoint only its endpoints will be updated (no recovery timeout
-//     change).
-//
-// Endpoints are matched by the endpoint address (usually in the form of address:port).
-//
-//   - If an existing endpoint is not used by any MultiEndpoint in the updated list, then the
-//     connection poll for this endpoint will be shutdown.
-//   - A connection pool will be created for every new endpoint.
-//   - For an existing endpoint nothing will change (the connection pool will not be re-created,
-//     thus no connection credentials change, nor connection configuration change).
-func (gme *GCPMultiEndpoint) UpdateMultiEndpoints(meOpts *GCPMultiEndpointOptions) error {
-	gme.mu.Lock()
-	defer gme.mu.Unlock()
-	if _, ok := meOpts.MultiEndpoints[meOpts.Default]; !ok {
-		return fmt.Errorf("default MultiEndpoint %q missing options", meOpts.Default)
-	}
-
-	validPools := make(map[string]bool)
-	for _, meo := range meOpts.MultiEndpoints {
-		for _, e := range meo.Endpoints {
-			validPools[e] = true
-		}
-	}
-
-	// Add missing pools.
-	for e := range validPools {
-		if _, ok := gme.pools[e]; !ok {
-			// This creates a ClientConn with the gRPC-GCP balancer managing connection pool.
-			conn, err := gme.dialFunc(context.Background(), e, gme.opts...)
-			if err != nil {
-				return err
-			}
-			if gme.log.V(FINE) {
-				gme.log.Infof("created new channel pool for %q endpoint.", e)
-			}
-			gme.pools[e] = newMonitoredConn(e, conn, gme)
-		}
-	}
-
-	// Add new multi-endpoints and update existing.
-	for name, meo := range meOpts.MultiEndpoints {
-		if me, ok := gme.mes[name]; ok {
-			// Updating existing MultiEndpoint.
-			me.SetEndpoints(meo.Endpoints)
-			continue
-		}
-
-		// Add new MultiEndpoint.
-		if gme.log.V(FINE) {
-			gme.log.Infof("creating new %q multiendpoint.", name)
-		}
-		me, err := multiendpoint.NewMultiEndpoint(meo)
-		if err != nil {
-			return err
-		}
-		gme.mes[name] = me
-	}
-	gme.defaultName = meOpts.Default
-
-	// Remove obsolete MultiEndpoints.
-	for name := range gme.mes {
-		if _, ok := meOpts.MultiEndpoints[name]; !ok {
-			delete(gme.mes, name)
-			if gme.log.V(FINE) {
-				gme.log.Infof("removed obsolete %q multiendpoint.", name)
-			}
-		}
-	}
-
-	// Remove obsolete pools.
-	for e, mc := range gme.pools {
-		if _, ok := validPools[e]; !ok {
-			if err := mc.conn.Close(); err != nil {
-				gme.log.Errorf("error while closing the pool for %q endpoint: %v", e, err)
-			}
-			if gme.log.V(FINE) {
-				gme.log.Infof("closed channel pool for %q endpoint.", e)
-			}
-			mc.stopMonitoring()
-			delete(gme.pools, e)
-		}
-	}
-
-	// Trigger status update.
-	for e, mc := range gme.pools {
-		s := mc.conn.GetState()
-		for _, me := range gme.mes {
-			me.SetEndpointAvailability(e, s == connectivity.Ready)
-		}
-	}
-	return nil
-}
-
-type multiError []error
-
-func (m multiError) Error() string {
-	s, n := "", 0
-	for _, e := range m {
-		if e != nil {
-			if n == 0 {
-				s = e.Error()
-			}
-			n++
-		}
-	}
-	switch n {
-	case 0:
-		return "(0 errors)"
-	case 1:
-		return s
-	case 2:
-		return s + " (and 1 other error)"
-	}
-	return fmt.Sprintf("%s (and %d other errors)", s, n-1)
-}
-
-func (m multiError) Combine() error {
-	if len(m) == 0 {
-		return nil
-	}
-
-	return m
-}
diff --git a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/gcp_picker.go b/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/gcp_picker.go
deleted file mode 100644
index 522323625..000000000
--- a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/gcp_picker.go
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
- *
- * Copyright 2019 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 grpcgcp
-
-import (
-	"context"
-	"fmt"
-	"reflect"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/grpc_gcp"
-	"google.golang.org/grpc/balancer"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/grpclog"
-	"google.golang.org/grpc/status"
-)
-
-// Deadline exceeded gRPC error caused by client-side context reached deadline.
-var deErr = status.Error(codes.DeadlineExceeded, context.DeadlineExceeded.Error())
-
-func newGCPPicker(readySCRefs []*subConnRef, gb *gcpBalancer) balancer.Picker {
-	gp := &gcpPicker{
-		gb:     gb,
-		scRefs: readySCRefs,
-	}
-	gp.log = NewGCPLogger(gb.log, fmt.Sprintf("[gcpPicker %p]", gp))
-	return gp
-}
-
-type gcpPicker struct {
-	gb     *gcpBalancer
-	mu     sync.Mutex
-	scRefs []*subConnRef
-	log    grpclog.LoggerV2
-}
-
-func (p *gcpPicker) Pick(info balancer.PickInfo) (balancer.PickResult, error) {
-	if len(p.scRefs) <= 0 {
-		if p.log.V(FINEST) {
-			p.log.Info("returning balancer.ErrNoSubConnAvailable as no subconns are available.")
-		}
-		return balancer.PickResult{}, balancer.ErrNoSubConnAvailable
-	}
-
-	ctx := info.Ctx
-	gcpCtx, hasGCPCtx := ctx.Value(gcpKey).(*gcpContext)
-	boundKey := ""
-	locator := ""
-	var cmd grpc_gcp.AffinityConfig_Command
-
-	if mcfg, ok := p.gb.methodCfg[info.FullMethodName]; ok {
-		locator = mcfg.GetAffinityKey()
-		cmd = mcfg.GetCommand()
-		if hasGCPCtx && (cmd == grpc_gcp.AffinityConfig_BOUND || cmd == grpc_gcp.AffinityConfig_UNBIND) {
-			a, err := getAffinityKeysFromMessage(locator, gcpCtx.reqMsg)
-			if err != nil {
-				return balancer.PickResult{}, fmt.Errorf(
-					"failed to retrieve affinity key from request message: %v", err)
-			}
-			boundKey = a[0]
-		}
-	}
-
-	scRef, err := p.getAndIncrementSubConnRef(info.Ctx, boundKey, cmd)
-	if err != nil {
-		return balancer.PickResult{}, err
-	}
-	if scRef == nil {
-		if p.log.V(FINEST) {
-			p.log.Info("returning balancer.ErrNoSubConnAvailable as no SubConn was picked.")
-		}
-		return balancer.PickResult{}, balancer.ErrNoSubConnAvailable
-	}
-
-	callStarted := time.Now()
-	// define callback for post process once call is done
-	callback := func(info balancer.DoneInfo) {
-		scRef.streamsDecr()
-		p.detectUnresponsive(ctx, scRef, callStarted, info.Err)
-		if info.Err != nil {
-			return
-		}
-
-		switch cmd {
-		case grpc_gcp.AffinityConfig_BIND:
-			bindKeys, err := getAffinityKeysFromMessage(locator, gcpCtx.replyMsg)
-			if err == nil {
-				for _, bk := range bindKeys {
-					p.gb.bindSubConn(bk, scRef.subConn)
-				}
-			}
-		case grpc_gcp.AffinityConfig_UNBIND:
-			p.gb.unbindSubConn(boundKey)
-		}
-	}
-
-	if p.log.V(FINEST) {
-		p.log.Infof("picked SubConn: %p", scRef.subConn)
-	}
-	return balancer.PickResult{SubConn: scRef.subConn, Done: callback}, nil
-}
-
-// unresponsiveWindow returns channel pool's unresponsiveDetectionMs multiplied
-// by 2^(refresh count since last response) as a time.Duration. This provides
-// exponential backoff when RPCs keep deadline exceeded after consecutive reconnections.
-func (p *gcpPicker) unresponsiveWindow(scRef *subConnRef) time.Duration {
-	factor := uint32(1 << scRef.refreshCnt)
-	return time.Millisecond * time.Duration(factor*p.gb.cfg.GetChannelPool().GetUnresponsiveDetectionMs())
-}
-
-func (p *gcpPicker) detectUnresponsive(ctx context.Context, scRef *subConnRef, callStarted time.Time, rpcErr error) {
-	if !p.gb.unresponsiveDetection {
-		return
-	}
-
-	// Treat as a response from the server if deadline exceeded was not caused by client side context reached deadline.
-	if dl, ok := ctx.Deadline(); rpcErr == nil || status.Code(rpcErr) != codes.DeadlineExceeded ||
-		rpcErr.Error() != deErr.Error() || !ok || dl.After(time.Now()) {
-		scRef.gotResp()
-		return
-	}
-
-	if callStarted.Before(scRef.lastResp) {
-		return
-	}
-
-	// Increment deadline exceeded calls and check if there were enough deadline
-	// exceeded calls and enough time passed since last response to trigger refresh.
-	if scRef.deCallsInc() >= p.gb.cfg.GetChannelPool().GetUnresponsiveCalls() &&
-		scRef.lastResp.Before(time.Now().Add(-p.unresponsiveWindow(scRef))) {
-		p.gb.refresh(scRef)
-	}
-}
-
-func (p *gcpPicker) getAndIncrementSubConnRef(ctx context.Context, boundKey string, cmd grpc_gcp.AffinityConfig_Command) (*subConnRef, error) {
-	if cmd == grpc_gcp.AffinityConfig_BIND && p.gb.cfg.GetChannelPool().GetBindPickStrategy() == grpc_gcp.ChannelPoolConfig_ROUND_ROBIN {
-		scRef := p.gb.getSubConnRoundRobin(ctx)
-		if p.log.V(FINEST) {
-			p.log.Infof("picking SubConn for round-robin bind: %p", scRef.subConn)
-		}
-		scRef.streamsIncr()
-		return scRef, nil
-	}
-
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	scRef, err := p.getSubConnRef(boundKey)
-	if err != nil {
-		return nil, err
-	}
-	if scRef != nil {
-		scRef.streamsIncr()
-	}
-	return scRef, nil
-}
-
-// getSubConnRef returns the subConnRef object that contains the subconn
-// ready to be used by picker.
-// Must be called holding the picker mutex lock.
-func (p *gcpPicker) getSubConnRef(boundKey string) (*subConnRef, error) {
-	if boundKey != "" {
-		if ref, ok := p.gb.getReadySubConnRef(boundKey); ok {
-			return ref, nil
-		}
-	}
-
-	return p.getLeastBusySubConnRef()
-}
-
-// Must be called holding the picker mutex lock.
-func (p *gcpPicker) getLeastBusySubConnRef() (*subConnRef, error) {
-	minScRef := p.scRefs[0]
-	minStreamsCnt := minScRef.getStreamsCnt()
-	for _, scRef := range p.scRefs {
-		if scRef.getStreamsCnt() < minStreamsCnt {
-			minStreamsCnt = scRef.getStreamsCnt()
-			minScRef = scRef
-		}
-	}
-
-	// If the least busy connection still has capacity, use it
-	if minStreamsCnt < int32(p.gb.cfg.GetChannelPool().GetMaxConcurrentStreamsLowWatermark()) {
-		return minScRef, nil
-	}
-
-	if p.gb.cfg.GetChannelPool().GetMaxSize() == 0 || p.gb.getConnectionPoolSize() < int(p.gb.cfg.GetChannelPool().GetMaxSize()) {
-		// Ask balancer to create new subconn when all current subconns are busy and
-		// the connection pool still has capacity (either unlimited or maxSize is not reached).
-		p.gb.newSubConn()
-
-		// Let this picker return ErrNoSubConnAvailable because it needs some time
-		// for the subconn to be READY.
-		return nil, balancer.ErrNoSubConnAvailable
-	}
-
-	// If no capacity for the pool size and every connection reachs the soft limit,
-	// Then picks the least busy one anyway.
-	return minScRef, nil
-}
-
-func keysFromMessage(val reflect.Value, path []string, start int) ([]string, error) {
-	if val.Kind() == reflect.Pointer || val.Kind() == reflect.Interface {
-		val = val.Elem()
-	}
-
-	if len(path) == start {
-		if val.Kind() != reflect.String {
-			return nil, fmt.Errorf("cannot get string value from %q which is %q", strings.Join(path, "."), val.Kind())
-		}
-		return []string{val.String()}, nil
-	}
-
-	if val.Kind() != reflect.Struct {
-		return nil, fmt.Errorf("path %q traversal error: cannot lookup field %q (index %d in the path) in a %q value", strings.Join(path, "."), path[start], start, val.Kind())
-	}
-	valField := val.FieldByName(strings.Title(path[start]))
-
-	if valField.Kind() != reflect.Slice {
-		return keysFromMessage(valField, path, start+1)
-	}
-
-	keys := []string{}
-	for i := 0; i < valField.Len(); i++ {
-		kk, err := keysFromMessage(valField.Index(i), path, start+1)
-		if err != nil {
-			return keys, err
-		}
-		keys = append(keys, kk...)
-	}
-	return keys, nil
-}
-
-// getAffinityKeysFromMessage retrieves the affinity key(s) from proto message using
-// the key locator defined in the affinity config.
-func getAffinityKeysFromMessage(
-	locator string,
-	msg interface{},
-) (affinityKeys []string, err error) {
-	names := strings.Split(locator, ".")
-	if len(names) == 0 {
-		return nil, fmt.Errorf("empty affinityKey locator")
-	}
-
-	return keysFromMessage(reflect.ValueOf(msg), names, 0)
-}
-
-// 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(info balancer.PickInfo) (balancer.PickResult, error) {
-	return balancer.PickResult{}, p.err
-}
diff --git a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/grpc_gcp/codegen.sh b/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/grpc_gcp/codegen.sh
deleted file mode 100644
index 334a718cc..000000000
--- a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/grpc_gcp/codegen.sh
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-cd "$(dirname "$0")"
-
-rm grpc_gcp.pb.go
-protoc --plugin=$(go env GOPATH)/bin/protoc-gen-go --proto_path=./ --go_out=.. ./grpc_gcp.proto
-
diff --git a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/grpc_gcp/grpc_gcp.pb.go b/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/grpc_gcp/grpc_gcp.pb.go
deleted file mode 100644
index 51dd4b27a..000000000
--- a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/grpc_gcp/grpc_gcp.pb.go
+++ /dev/null
@@ -1,638 +0,0 @@
-// 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.
-
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// versions:
-// 	protoc-gen-go v1.27.1
-// 	protoc        v3.12.4
-// source: grpc_gcp.proto
-
-package grpc_gcp
-
-import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
-)
-
-const (
-	// Verify that this generated code is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
-	// Verify that runtime/protoimpl is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
-)
-
-// A selection of strategies for picking a channel for a call with BIND command.
-type ChannelPoolConfig_BindPickStrategy int32
-
-const (
-	// No preference -- picking a channel for a BIND call will be no different
-	// than for any other calls.
-	ChannelPoolConfig_UNSPECIFIED ChannelPoolConfig_BindPickStrategy = 0
-	// A channel with the least active streams at the moment of a BIND call
-	// initiation will be picked.
-	ChannelPoolConfig_LEAST_ACTIVE_STREAMS ChannelPoolConfig_BindPickStrategy = 1
-	// Cycle through channels created by the BIND call initiation. I. e. pick
-	// a channel in a round-robin manner. Note that some channels may be
-	// skipped during channel pool resize.
-	ChannelPoolConfig_ROUND_ROBIN ChannelPoolConfig_BindPickStrategy = 2
-)
-
-// Enum value maps for ChannelPoolConfig_BindPickStrategy.
-var (
-	ChannelPoolConfig_BindPickStrategy_name = map[int32]string{
-		0: "UNSPECIFIED",
-		1: "LEAST_ACTIVE_STREAMS",
-		2: "ROUND_ROBIN",
-	}
-	ChannelPoolConfig_BindPickStrategy_value = map[string]int32{
-		"UNSPECIFIED":          0,
-		"LEAST_ACTIVE_STREAMS": 1,
-		"ROUND_ROBIN":          2,
-	}
-)
-
-func (x ChannelPoolConfig_BindPickStrategy) Enum() *ChannelPoolConfig_BindPickStrategy {
-	p := new(ChannelPoolConfig_BindPickStrategy)
-	*p = x
-	return p
-}
-
-func (x ChannelPoolConfig_BindPickStrategy) String() string {
-	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (ChannelPoolConfig_BindPickStrategy) Descriptor() protoreflect.EnumDescriptor {
-	return file_grpc_gcp_proto_enumTypes[0].Descriptor()
-}
-
-func (ChannelPoolConfig_BindPickStrategy) Type() protoreflect.EnumType {
-	return &file_grpc_gcp_proto_enumTypes[0]
-}
-
-func (x ChannelPoolConfig_BindPickStrategy) Number() protoreflect.EnumNumber {
-	return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Use ChannelPoolConfig_BindPickStrategy.Descriptor instead.
-func (ChannelPoolConfig_BindPickStrategy) EnumDescriptor() ([]byte, []int) {
-	return file_grpc_gcp_proto_rawDescGZIP(), []int{1, 0}
-}
-
-type AffinityConfig_Command int32
-
-const (
-	// The annotated method will be required to be bound to an existing session
-	// to execute the RPC. The corresponding <affinity_key_field_path> will be
-	// used to find the affinity key from the request message.
-	AffinityConfig_BOUND AffinityConfig_Command = 0
-	// The annotated method will establish the channel affinity with the
-	// channel which is used to execute the RPC. The corresponding
-	// <affinity_key_field_path> will be used to find the affinity key from the
-	// response message.
-	AffinityConfig_BIND AffinityConfig_Command = 1
-	// The annotated method will remove the channel affinity with the
-	// channel which is used to execute the RPC. The corresponding
-	// <affinity_key_field_path> will be used to find the affinity key from the
-	// request message.
-	AffinityConfig_UNBIND AffinityConfig_Command = 2
-)
-
-// Enum value maps for AffinityConfig_Command.
-var (
-	AffinityConfig_Command_name = map[int32]string{
-		0: "BOUND",
-		1: "BIND",
-		2: "UNBIND",
-	}
-	AffinityConfig_Command_value = map[string]int32{
-		"BOUND":  0,
-		"BIND":   1,
-		"UNBIND": 2,
-	}
-)
-
-func (x AffinityConfig_Command) Enum() *AffinityConfig_Command {
-	p := new(AffinityConfig_Command)
-	*p = x
-	return p
-}
-
-func (x AffinityConfig_Command) String() string {
-	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (AffinityConfig_Command) Descriptor() protoreflect.EnumDescriptor {
-	return file_grpc_gcp_proto_enumTypes[1].Descriptor()
-}
-
-func (AffinityConfig_Command) Type() protoreflect.EnumType {
-	return &file_grpc_gcp_proto_enumTypes[1]
-}
-
-func (x AffinityConfig_Command) Number() protoreflect.EnumNumber {
-	return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Use AffinityConfig_Command.Descriptor instead.
-func (AffinityConfig_Command) EnumDescriptor() ([]byte, []int) {
-	return file_grpc_gcp_proto_rawDescGZIP(), []int{3, 0}
-}
-
-type ApiConfig struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// The channel pool configurations.
-	ChannelPool *ChannelPoolConfig `protobuf:"bytes,2,opt,name=channel_pool,json=channelPool,proto3" json:"channel_pool,omitempty"`
-	// The method configurations.
-	Method []*MethodConfig `protobuf:"bytes,1001,rep,name=method,proto3" json:"method,omitempty"`
-}
-
-func (x *ApiConfig) Reset() {
-	*x = ApiConfig{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_grpc_gcp_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *ApiConfig) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ApiConfig) ProtoMessage() {}
-
-func (x *ApiConfig) ProtoReflect() protoreflect.Message {
-	mi := &file_grpc_gcp_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use ApiConfig.ProtoReflect.Descriptor instead.
-func (*ApiConfig) Descriptor() ([]byte, []int) {
-	return file_grpc_gcp_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *ApiConfig) GetChannelPool() *ChannelPoolConfig {
-	if x != nil {
-		return x.ChannelPool
-	}
-	return nil
-}
-
-func (x *ApiConfig) GetMethod() []*MethodConfig {
-	if x != nil {
-		return x.Method
-	}
-	return nil
-}
-
-// ChannelPoolConfig are options for configuring the channel pool.
-// RPCs will be scheduled onto existing channels in the pool until all channels
-// have <max_concurrent_streams_low_watermark> number of streams. At this point
-// a new channel is spun out. Once <max_size> channels have been spun out and
-// each has <max_concurrent_streams_low_watermark> streams, subsequent RPCs will
-// hang until any of the in-flight RPCs is finished, freeing up a channel.
-type ChannelPoolConfig struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// The max number of channels in the pool.
-	// Default value is 0, meaning 'unlimited' size.
-	MaxSize uint32 `protobuf:"varint,1,opt,name=max_size,json=maxSize,proto3" json:"max_size,omitempty"`
-	// The idle timeout (seconds) of channels without bound affinity sessions.
-	IdleTimeout uint64 `protobuf:"varint,2,opt,name=idle_timeout,json=idleTimeout,proto3" json:"idle_timeout,omitempty"`
-	// The low watermark of max number of concurrent streams in a channel.
-	// New channel will be created once it get hit, until we reach the max size of the channel pool.
-	// Default value is 100. The valid range is [1, 100]. Any value outside the range will be ignored and the default value will be used.
-	// Note: It is not recommended that users adjust this value, since a single channel should generally have no trouble managing the default (maximum) number of streams.
-	MaxConcurrentStreamsLowWatermark uint32 `protobuf:"varint,3,opt,name=max_concurrent_streams_low_watermark,json=maxConcurrentStreamsLowWatermark,proto3" json:"max_concurrent_streams_low_watermark,omitempty"`
-	// The minimum number of channels in the pool.
-	MinSize uint32 `protobuf:"varint,4,opt,name=min_size,json=minSize,proto3" json:"min_size,omitempty"`
-	// If a channel mapped to an affinity key is not ready, temporarily fallback
-	// to another ready channel.
-	// Enabling this fallback is beneficial in scenarios with short RPC timeouts
-	// and rather slow connection establishing or during incidents when new
-	// connections fail but existing connections still operate.
-	FallbackToReady bool `protobuf:"varint,5,opt,name=fallback_to_ready,json=fallbackToReady,proto3" json:"fallback_to_ready,omitempty"`
-	// Enables per channel unresponsive connection detection if > 0 and unresponsive_calls > 0.
-	// If enabled and more than unresponsive_detection_ms passed since the last response from the server,
-	// and >= unresponsive_calls RPC calls (started after last response from the server) timed-out on the client side,
-	// then the connection of that channel will be gracefully refreshed. I.e., a new connection will be created for
-	// that channel and after the new connection is ready it will replace the old connection. The calls on the old
-	// connection will not be interrupted. The unresponsive_detection_ms will be doubled every consecutive refresh
-	// if no response from the server is received.
-	UnresponsiveDetectionMs uint32 `protobuf:"varint,6,opt,name=unresponsive_detection_ms,json=unresponsiveDetectionMs,proto3" json:"unresponsive_detection_ms,omitempty"`
-	// Enables per channel unresponsive connection detection if > 0 and unresponsive_detection_ms > 0.
-	// If enabled and more than unresponsive_detection_ms passed since the last response from the server,
-	// and >= unresponsive_calls RPC calls (started after last response from the server) timed-out on the client side,
-	// then the connection of that channel will be gracefully refreshed. I.e., a new connection will be created for
-	// that channel and after the new connection is ready it will replace the old connection. The calls on the old
-	// connection will not be interrupted. The unresponsive_detection_ms will be doubled every consecutive refresh
-	// if no response from the server is received.
-	UnresponsiveCalls uint32 `protobuf:"varint,7,opt,name=unresponsive_calls,json=unresponsiveCalls,proto3" json:"unresponsive_calls,omitempty"`
-	// The strategy for picking a channel for a call with BIND command.
-	BindPickStrategy ChannelPoolConfig_BindPickStrategy `protobuf:"varint,8,opt,name=bind_pick_strategy,json=bindPickStrategy,proto3,enum=grpc.gcp.ChannelPoolConfig_BindPickStrategy" json:"bind_pick_strategy,omitempty"`
-}
-
-func (x *ChannelPoolConfig) Reset() {
-	*x = ChannelPoolConfig{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_grpc_gcp_proto_msgTypes[1]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *ChannelPoolConfig) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ChannelPoolConfig) ProtoMessage() {}
-
-func (x *ChannelPoolConfig) ProtoReflect() protoreflect.Message {
-	mi := &file_grpc_gcp_proto_msgTypes[1]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use ChannelPoolConfig.ProtoReflect.Descriptor instead.
-func (*ChannelPoolConfig) Descriptor() ([]byte, []int) {
-	return file_grpc_gcp_proto_rawDescGZIP(), []int{1}
-}
-
-func (x *ChannelPoolConfig) GetMaxSize() uint32 {
-	if x != nil {
-		return x.MaxSize
-	}
-	return 0
-}
-
-func (x *ChannelPoolConfig) GetIdleTimeout() uint64 {
-	if x != nil {
-		return x.IdleTimeout
-	}
-	return 0
-}
-
-func (x *ChannelPoolConfig) GetMaxConcurrentStreamsLowWatermark() uint32 {
-	if x != nil {
-		return x.MaxConcurrentStreamsLowWatermark
-	}
-	return 0
-}
-
-func (x *ChannelPoolConfig) GetMinSize() uint32 {
-	if x != nil {
-		return x.MinSize
-	}
-	return 0
-}
-
-func (x *ChannelPoolConfig) GetFallbackToReady() bool {
-	if x != nil {
-		return x.FallbackToReady
-	}
-	return false
-}
-
-func (x *ChannelPoolConfig) GetUnresponsiveDetectionMs() uint32 {
-	if x != nil {
-		return x.UnresponsiveDetectionMs
-	}
-	return 0
-}
-
-func (x *ChannelPoolConfig) GetUnresponsiveCalls() uint32 {
-	if x != nil {
-		return x.UnresponsiveCalls
-	}
-	return 0
-}
-
-func (x *ChannelPoolConfig) GetBindPickStrategy() ChannelPoolConfig_BindPickStrategy {
-	if x != nil {
-		return x.BindPickStrategy
-	}
-	return ChannelPoolConfig_UNSPECIFIED
-}
-
-type MethodConfig struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// A fully qualified name of a gRPC method, or a wildcard pattern ending
-	// with .*, such as foo.bar.A, foo.bar.*. Method configs are evaluated
-	// sequentially, and the first one takes precedence.
-	Name []string `protobuf:"bytes,1,rep,name=name,proto3" json:"name,omitempty"`
-	// The channel affinity configurations.
-	Affinity *AffinityConfig `protobuf:"bytes,1001,opt,name=affinity,proto3" json:"affinity,omitempty"`
-}
-
-func (x *MethodConfig) Reset() {
-	*x = MethodConfig{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_grpc_gcp_proto_msgTypes[2]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *MethodConfig) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*MethodConfig) ProtoMessage() {}
-
-func (x *MethodConfig) ProtoReflect() protoreflect.Message {
-	mi := &file_grpc_gcp_proto_msgTypes[2]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use MethodConfig.ProtoReflect.Descriptor instead.
-func (*MethodConfig) Descriptor() ([]byte, []int) {
-	return file_grpc_gcp_proto_rawDescGZIP(), []int{2}
-}
-
-func (x *MethodConfig) GetName() []string {
-	if x != nil {
-		return x.Name
-	}
-	return nil
-}
-
-func (x *MethodConfig) GetAffinity() *AffinityConfig {
-	if x != nil {
-		return x.Affinity
-	}
-	return nil
-}
-
-type AffinityConfig struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// The affinity command applies on the selected gRPC methods.
-	Command AffinityConfig_Command `protobuf:"varint,2,opt,name=command,proto3,enum=grpc.gcp.AffinityConfig_Command" json:"command,omitempty"`
-	// The field path of the affinity key in the request/response message.
-	// For example: "f.a", "f.b.d", etc.
-	AffinityKey string `protobuf:"bytes,3,opt,name=affinity_key,json=affinityKey,proto3" json:"affinity_key,omitempty"`
-}
-
-func (x *AffinityConfig) Reset() {
-	*x = AffinityConfig{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_grpc_gcp_proto_msgTypes[3]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *AffinityConfig) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*AffinityConfig) ProtoMessage() {}
-
-func (x *AffinityConfig) ProtoReflect() protoreflect.Message {
-	mi := &file_grpc_gcp_proto_msgTypes[3]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use AffinityConfig.ProtoReflect.Descriptor instead.
-func (*AffinityConfig) Descriptor() ([]byte, []int) {
-	return file_grpc_gcp_proto_rawDescGZIP(), []int{3}
-}
-
-func (x *AffinityConfig) GetCommand() AffinityConfig_Command {
-	if x != nil {
-		return x.Command
-	}
-	return AffinityConfig_BOUND
-}
-
-func (x *AffinityConfig) GetAffinityKey() string {
-	if x != nil {
-		return x.AffinityKey
-	}
-	return ""
-}
-
-var File_grpc_gcp_proto protoreflect.FileDescriptor
-
-var file_grpc_gcp_proto_rawDesc = []byte{
-	0x0a, 0x0e, 0x67, 0x72, 0x70, 0x63, 0x5f, 0x67, 0x63, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x12, 0x08, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x67, 0x63, 0x70, 0x22, 0x7c, 0x0a, 0x09, 0x41, 0x70,
-	0x69, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x3e, 0x0a, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x6e,
-	0x65, 0x6c, 0x5f, 0x70, 0x6f, 0x6f, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e,
-	0x67, 0x72, 0x70, 0x63, 0x2e, 0x67, 0x63, 0x70, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c,
-	0x50, 0x6f, 0x6f, 0x6c, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0b, 0x63, 0x68, 0x61, 0x6e,
-	0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x6f, 0x6c, 0x12, 0x2f, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f,
-	0x64, 0x18, 0xe9, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e,
-	0x67, 0x63, 0x70, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67,
-	0x52, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x22, 0xff, 0x03, 0x0a, 0x11, 0x43, 0x68, 0x61,
-	0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x6f, 0x6c, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x19,
-	0x0a, 0x08, 0x6d, 0x61, 0x78, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d,
-	0x52, 0x07, 0x6d, 0x61, 0x78, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x64, 0x6c,
-	0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52,
-	0x0b, 0x69, 0x64, 0x6c, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x12, 0x4e, 0x0a, 0x24,
-	0x6d, 0x61, 0x78, 0x5f, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73,
-	0x74, 0x72, 0x65, 0x61, 0x6d, 0x73, 0x5f, 0x6c, 0x6f, 0x77, 0x5f, 0x77, 0x61, 0x74, 0x65, 0x72,
-	0x6d, 0x61, 0x72, 0x6b, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x20, 0x6d, 0x61, 0x78, 0x43,
-	0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73,
-	0x4c, 0x6f, 0x77, 0x57, 0x61, 0x74, 0x65, 0x72, 0x6d, 0x61, 0x72, 0x6b, 0x12, 0x19, 0x0a, 0x08,
-	0x6d, 0x69, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07,
-	0x6d, 0x69, 0x6e, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x2a, 0x0a, 0x11, 0x66, 0x61, 0x6c, 0x6c, 0x62,
-	0x61, 0x63, 0x6b, 0x5f, 0x74, 0x6f, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x05, 0x20, 0x01,
-	0x28, 0x08, 0x52, 0x0f, 0x66, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x54, 0x6f, 0x52, 0x65,
-	0x61, 0x64, 0x79, 0x12, 0x3a, 0x0a, 0x19, 0x75, 0x6e, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x69, 0x76, 0x65, 0x5f, 0x64, 0x65, 0x74, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x73,
-	0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x17, 0x75, 0x6e, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x69, 0x76, 0x65, 0x44, 0x65, 0x74, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x73, 0x12,
-	0x2d, 0x0a, 0x12, 0x75, 0x6e, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x5f,
-	0x63, 0x61, 0x6c, 0x6c, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x11, 0x75, 0x6e, 0x72,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x43, 0x61, 0x6c, 0x6c, 0x73, 0x12, 0x5a,
-	0x0a, 0x12, 0x62, 0x69, 0x6e, 0x64, 0x5f, 0x70, 0x69, 0x63, 0x6b, 0x5f, 0x73, 0x74, 0x72, 0x61,
-	0x74, 0x65, 0x67, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x67, 0x72, 0x70,
-	0x63, 0x2e, 0x67, 0x63, 0x70, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x6f,
-	0x6c, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x42, 0x69, 0x6e, 0x64, 0x50, 0x69, 0x63, 0x6b,
-	0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x52, 0x10, 0x62, 0x69, 0x6e, 0x64, 0x50, 0x69,
-	0x63, 0x6b, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x22, 0x4e, 0x0a, 0x10, 0x42, 0x69,
-	0x6e, 0x64, 0x50, 0x69, 0x63, 0x6b, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x12, 0x0f,
-	0x0a, 0x0b, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12,
-	0x18, 0x0a, 0x14, 0x4c, 0x45, 0x41, 0x53, 0x54, 0x5f, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5f,
-	0x53, 0x54, 0x52, 0x45, 0x41, 0x4d, 0x53, 0x10, 0x01, 0x12, 0x0f, 0x0a, 0x0b, 0x52, 0x4f, 0x55,
-	0x4e, 0x44, 0x5f, 0x52, 0x4f, 0x42, 0x49, 0x4e, 0x10, 0x02, 0x22, 0x59, 0x0a, 0x0c, 0x4d, 0x65,
-	0x74, 0x68, 0x6f, 0x64, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61,
-	0x6d, 0x65, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x35,
-	0x0a, 0x08, 0x61, 0x66, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x18, 0xe9, 0x07, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x18, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x67, 0x63, 0x70, 0x2e, 0x41, 0x66, 0x66,
-	0x69, 0x6e, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x08, 0x61, 0x66, 0x66,
-	0x69, 0x6e, 0x69, 0x74, 0x79, 0x22, 0x9b, 0x01, 0x0a, 0x0e, 0x41, 0x66, 0x66, 0x69, 0x6e, 0x69,
-	0x74, 0x79, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x3a, 0x0a, 0x07, 0x63, 0x6f, 0x6d, 0x6d,
-	0x61, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x67, 0x72, 0x70, 0x63,
-	0x2e, 0x67, 0x63, 0x70, 0x2e, 0x41, 0x66, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x6e,
-	0x66, 0x69, 0x67, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x52, 0x07, 0x63, 0x6f, 0x6d,
-	0x6d, 0x61, 0x6e, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x66, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79,
-	0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x66, 0x66, 0x69,
-	0x6e, 0x69, 0x74, 0x79, 0x4b, 0x65, 0x79, 0x22, 0x2a, 0x0a, 0x07, 0x43, 0x6f, 0x6d, 0x6d, 0x61,
-	0x6e, 0x64, 0x12, 0x09, 0x0a, 0x05, 0x42, 0x4f, 0x55, 0x4e, 0x44, 0x10, 0x00, 0x12, 0x08, 0x0a,
-	0x04, 0x42, 0x49, 0x4e, 0x44, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x55, 0x4e, 0x42, 0x49, 0x4e,
-	0x44, 0x10, 0x02, 0x42, 0x0c, 0x5a, 0x0a, 0x2e, 0x2f, 0x67, 0x72, 0x70, 0x63, 0x5f, 0x67, 0x63,
-	0x70, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
-
-var (
-	file_grpc_gcp_proto_rawDescOnce sync.Once
-	file_grpc_gcp_proto_rawDescData = file_grpc_gcp_proto_rawDesc
-)
-
-func file_grpc_gcp_proto_rawDescGZIP() []byte {
-	file_grpc_gcp_proto_rawDescOnce.Do(func() {
-		file_grpc_gcp_proto_rawDescData = protoimpl.X.CompressGZIP(file_grpc_gcp_proto_rawDescData)
-	})
-	return file_grpc_gcp_proto_rawDescData
-}
-
-var file_grpc_gcp_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
-var file_grpc_gcp_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
-var file_grpc_gcp_proto_goTypes = []interface{}{
-	(ChannelPoolConfig_BindPickStrategy)(0), // 0: grpc.gcp.ChannelPoolConfig.BindPickStrategy
-	(AffinityConfig_Command)(0),             // 1: grpc.gcp.AffinityConfig.Command
-	(*ApiConfig)(nil),                       // 2: grpc.gcp.ApiConfig
-	(*ChannelPoolConfig)(nil),               // 3: grpc.gcp.ChannelPoolConfig
-	(*MethodConfig)(nil),                    // 4: grpc.gcp.MethodConfig
-	(*AffinityConfig)(nil),                  // 5: grpc.gcp.AffinityConfig
-}
-var file_grpc_gcp_proto_depIdxs = []int32{
-	3, // 0: grpc.gcp.ApiConfig.channel_pool:type_name -> grpc.gcp.ChannelPoolConfig
-	4, // 1: grpc.gcp.ApiConfig.method:type_name -> grpc.gcp.MethodConfig
-	0, // 2: grpc.gcp.ChannelPoolConfig.bind_pick_strategy:type_name -> grpc.gcp.ChannelPoolConfig.BindPickStrategy
-	5, // 3: grpc.gcp.MethodConfig.affinity:type_name -> grpc.gcp.AffinityConfig
-	1, // 4: grpc.gcp.AffinityConfig.command:type_name -> grpc.gcp.AffinityConfig.Command
-	5, // [5:5] is the sub-list for method output_type
-	5, // [5:5] is the sub-list for method input_type
-	5, // [5:5] is the sub-list for extension type_name
-	5, // [5:5] is the sub-list for extension extendee
-	0, // [0:5] is the sub-list for field type_name
-}
-
-func init() { file_grpc_gcp_proto_init() }
-func file_grpc_gcp_proto_init() {
-	if File_grpc_gcp_proto != nil {
-		return
-	}
-	if !protoimpl.UnsafeEnabled {
-		file_grpc_gcp_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ApiConfig); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_grpc_gcp_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ChannelPoolConfig); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_grpc_gcp_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MethodConfig); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_grpc_gcp_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*AffinityConfig); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_grpc_gcp_proto_rawDesc,
-			NumEnums:      2,
-			NumMessages:   4,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_grpc_gcp_proto_goTypes,
-		DependencyIndexes: file_grpc_gcp_proto_depIdxs,
-		EnumInfos:         file_grpc_gcp_proto_enumTypes,
-		MessageInfos:      file_grpc_gcp_proto_msgTypes,
-	}.Build()
-	File_grpc_gcp_proto = out.File
-	file_grpc_gcp_proto_rawDesc = nil
-	file_grpc_gcp_proto_goTypes = nil
-	file_grpc_gcp_proto_depIdxs = nil
-}
diff --git a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/grpc_gcp/grpc_gcp.proto b/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/grpc_gcp/grpc_gcp.proto
deleted file mode 100644
index 47eb8b87d..000000000
--- a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/grpc_gcp/grpc_gcp.proto
+++ /dev/null
@@ -1,129 +0,0 @@
-// 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.
-
-syntax = "proto3";
-
-option go_package = "./grpc_gcp";
-
-package grpc.gcp;
-
-message ApiConfig {
-  // The channel pool configurations.
-  ChannelPoolConfig channel_pool = 2;
-
-  // The method configurations.
-  repeated MethodConfig method = 1001;
-}
-
-// ChannelPoolConfig are options for configuring the channel pool.
-// RPCs will be scheduled onto existing channels in the pool until all channels
-// have <max_concurrent_streams_low_watermark> number of streams. At this point
-// a new channel is spun out. Once <max_size> channels have been spun out and
-// each has <max_concurrent_streams_low_watermark> streams, subsequent RPCs will
-// hang until any of the in-flight RPCs is finished, freeing up a channel.
-message ChannelPoolConfig {
-  // The max number of channels in the pool.
-  // Default value is 0, meaning 'unlimited' size.
-  uint32 max_size = 1;
-
-  // The idle timeout (seconds) of channels without bound affinity sessions.
-  uint64 idle_timeout = 2;
-
-  // The low watermark of max number of concurrent streams in a channel.
-  // New channel will be created once it get hit, until we reach the max size of the channel pool.
-  // Default value is 100. The valid range is [1, 100]. Any value outside the range will be ignored and the default value will be used.
-  // Note: It is not recommended that users adjust this value, since a single channel should generally have no trouble managing the default (maximum) number of streams.
-  uint32 max_concurrent_streams_low_watermark = 3;
-
-  // The minimum number of channels in the pool.
-  uint32 min_size = 4;
-
-  // If a channel mapped to an affinity key is not ready, temporarily fallback
-  // to another ready channel.
-  // Enabling this fallback is beneficial in scenarios with short RPC timeouts
-  // and rather slow connection establishing or during incidents when new
-  // connections fail but existing connections still operate.
-  bool fallback_to_ready = 5;
-
-  // Enables per channel unresponsive connection detection if > 0 and unresponsive_calls > 0.
-  // If enabled and more than unresponsive_detection_ms passed since the last response from the server,
-  // and >= unresponsive_calls RPC calls (started after last response from the server) timed-out on the client side,
-  // then the connection of that channel will be gracefully refreshed. I.e., a new connection will be created for
-  // that channel and after the new connection is ready it will replace the old connection. The calls on the old
-  // connection will not be interrupted. The unresponsive_detection_ms will be doubled every consecutive refresh
-  // if no response from the server is received.
-  uint32 unresponsive_detection_ms = 6;
-
-  // Enables per channel unresponsive connection detection if > 0 and unresponsive_detection_ms > 0.
-  // If enabled and more than unresponsive_detection_ms passed since the last response from the server,
-  // and >= unresponsive_calls RPC calls (started after last response from the server) timed-out on the client side,
-  // then the connection of that channel will be gracefully refreshed. I.e., a new connection will be created for
-  // that channel and after the new connection is ready it will replace the old connection. The calls on the old
-  // connection will not be interrupted. The unresponsive_detection_ms will be doubled every consecutive refresh
-  // if no response from the server is received.
-  uint32 unresponsive_calls = 7;
-
-  // A selection of strategies for picking a channel for a call with BIND command.
-  enum BindPickStrategy {
-    // No preference -- picking a channel for a BIND call will be no different
-    // than for any other calls.
-    UNSPECIFIED = 0;
-
-    // A channel with the least active streams at the moment of a BIND call
-    // initiation will be picked.
-    LEAST_ACTIVE_STREAMS = 1;
-
-    // Cycle through channels created by the BIND call initiation. I. e. pick
-    // a channel in a round-robin manner. Note that some channels may be
-    // skipped during channel pool resize.
-    ROUND_ROBIN = 2;
-  }
-
-  // The strategy for picking a channel for a call with BIND command.
-  BindPickStrategy bind_pick_strategy = 8;
-}
-
-message MethodConfig {
-  // A fully qualified name of a gRPC method, or a wildcard pattern ending
-  // with .*, such as foo.bar.A, foo.bar.*. Method configs are evaluated
-  // sequentially, and the first one takes precedence.
-  repeated string name = 1;
-
-  // The channel affinity configurations.
-  AffinityConfig affinity = 1001;
-}
-
-message AffinityConfig {
-  enum Command {
-    // The annotated method will be required to be bound to an existing session
-    // to execute the RPC. The corresponding <affinity_key_field_path> will be
-    // used to find the affinity key from the request message.
-    BOUND = 0;
-    // The annotated method will establish the channel affinity with the
-    // channel which is used to execute the RPC. The corresponding
-    // <affinity_key_field_path> will be used to find the affinity key from the
-    // response message.
-    BIND = 1;
-    // The annotated method will remove the channel affinity with the
-    // channel which is used to execute the RPC. The corresponding
-    // <affinity_key_field_path> will be used to find the affinity key from the
-    // request message.
-    UNBIND = 2;
-  }
-  // The affinity command applies on the selected gRPC methods.
-  Command command = 2;
-  // The field path of the affinity key in the request/response message.
-  // For example: "f.a", "f.b.d", etc.
-  string affinity_key = 3;
-}
diff --git a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/mockgen.sh b/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/mockgen.sh
deleted file mode 100644
index ff4de3390..000000000
--- a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/mockgen.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/usr/bin/env bash
-cd "$(dirname "$0")"
-mockgen -destination=mocks/mock_balancer.go -package=mocks google.golang.org/grpc/balancer ClientConn,SubConn
-mockgen -destination=mocks/mock_stream.go -package=mocks google.golang.org/grpc ClientStream
diff --git a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/multiendpoint/endpoint.go b/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/multiendpoint/endpoint.go
deleted file mode 100644
index 2a9c52eba..000000000
--- a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/multiendpoint/endpoint.go
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- *
- * Copyright 2023 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 multiendpoint
-
-import (
-	"fmt"
-	"time"
-)
-
-type status int
-
-// Status of an endpoint.
-const (
-	unavailable status = iota
-	available
-	recovering
-)
-
-func (s status) String() string {
-	switch s {
-	case unavailable:
-		return "Unavailable"
-	case available:
-		return "Available"
-	case recovering:
-		return "Recovering"
-	default:
-		return fmt.Sprintf("%d", s)
-	}
-}
-
-type endpoint struct {
-	id           string
-	priority     int
-	status       status
-	lastChange   time.Time
-	futureChange timerAlike
-}
diff --git a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/multiendpoint/multiendpoint.go b/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/multiendpoint/multiendpoint.go
deleted file mode 100644
index 7e70a6ea5..000000000
--- a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/multiendpoint/multiendpoint.go
+++ /dev/null
@@ -1,306 +0,0 @@
-/*
- *
- * Copyright 2023 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 multiendpoint implements multiendpoint feature. See [MultiEndpoint]
-package multiendpoint
-
-import (
-	"errors"
-	"fmt"
-	"sync"
-	"time"
-)
-
-type timerAlike interface {
-	Reset(time.Duration) bool
-	Stop() bool
-}
-
-// To be redefined in tests.
-var (
-	timeNow = func() time.Time {
-		return time.Now()
-	}
-	timeAfterFunc = func(d time.Duration, f func()) timerAlike {
-		return time.AfterFunc(d, f)
-	}
-)
-
-// MultiEndpoint holds a list of endpoints, tracks their availability and defines the current
-// endpoint. An endpoint has a priority defined by its position in the list (first item has top
-// priority).
-//
-// The current endpoint is the highest available endpoint in the list. If no endpoint is available,
-// MultiEndpoint sticks to the previously current endpoint.
-//
-// Sometimes switching between endpoints can be costly, and it is worth waiting for some time
-// after current endpoint becomes unavailable. For this case, use
-// [MultiEndpointOptions.RecoveryTimeout] to set the recovery timeout. MultiEndpoint will keep the
-// current endpoint for up to recovery timeout after it became unavailable to give it some time to
-// recover.
-//
-// The list of endpoints can be changed at any time with [MultiEndpoint.SetEndpoints] function.
-// MultiEndpoint will:
-//   - remove obsolete endpoints;
-//   - preserve remaining endpoints and their states;
-//   - add new endpoints;
-//   - update all endpoints priority according to the new order;
-//   - change current endpoint if necessary.
-//
-// After updating the list of endpoints, MultiEndpoint will switch the current endpoint to the
-// highest available endpoint in the list. If you have many processes using MultiEndpoint, this may
-// lead to immediate shift of all traffic which may be undesired. To smooth this transfer, use
-// [MultiEndpointOptions.SwitchingDelay] with randomized value to introduce a jitter. Each
-// MultiEndpoint will delay switching from an available endpoint to another endpoint for this amount
-// of time. This delay is only applicable when switching from a lower priority available endpoint to
-// a higher priority available endpoint.
-type MultiEndpoint interface {
-	// Current returns current endpoint.
-	//
-	// Note that the read is not synchronized and in case of a race condition there is a chance of
-	// getting an outdated current endpoint.
-	Current() string
-
-	// SetEndpointAvailability informs MultiEndpoint when an endpoint becomes available or unavailable.
-	// This may change the current endpoint.
-	SetEndpointAvailability(e string, avail bool)
-
-	// SetEndpoints updates a list of endpoints:
-	//   - remove obsolete endpoints
-	//   - preserve remaining endpoints and their states
-	//   - add new endpoints
-	//   - update all endpoints priority according to the new order
-	// This may change the current endpoint.
-	SetEndpoints(endpoints []string) error
-}
-
-// MultiEndpointOptions is used for configuring [MultiEndpoint].
-type MultiEndpointOptions struct {
-	// A list of endpoints ordered by priority (first endpoint has top priority).
-	Endpoints []string
-	// RecoveryTimeout sets the amount of time MultiEndpoint keeps endpoint as current after it
-	// became unavailable.
-	RecoveryTimeout time.Duration
-	// When switching from a lower priority available endpoint to a higher priority available
-	// endpoint the MultiEndpoint will delay the switch for this duration.
-	SwitchingDelay time.Duration
-}
-
-// NewMultiEndpoint validates options and creates a new [MultiEndpoint].
-func NewMultiEndpoint(b *MultiEndpointOptions) (MultiEndpoint, error) {
-	if len(b.Endpoints) == 0 {
-		return nil, fmt.Errorf("endpoints list cannot be empty")
-	}
-
-	me := &multiEndpoint{
-		recoveryTimeout: b.RecoveryTimeout,
-		switchingDelay:  b.SwitchingDelay,
-		current:         b.Endpoints[0],
-	}
-	eMap := make(map[string]*endpoint)
-	for i, e := range b.Endpoints {
-		eMap[e] = me.newEndpoint(e, i)
-	}
-	me.endpoints = eMap
-	return me, nil
-}
-
-type multiEndpoint struct {
-	sync.RWMutex
-
-	endpoints       map[string]*endpoint
-	recoveryTimeout time.Duration
-	switchingDelay  time.Duration
-	current         string
-	future          string
-}
-
-// Current returns current endpoint.
-func (me *multiEndpoint) Current() string {
-	me.RLock()
-	defer me.RUnlock()
-	return me.current
-}
-
-// SetEndpoints updates endpoints list:
-//   - remove obsolete endpoints;
-//   - preserve remaining endpoints and their states;
-//   - add new endpoints;
-//   - update all endpoints priority according to the new order;
-//   - change current endpoint if necessary.
-func (me *multiEndpoint) SetEndpoints(endpoints []string) error {
-	me.Lock()
-	defer me.Unlock()
-	if len(endpoints) == 0 {
-		return errors.New("endpoints list cannot be empty")
-	}
-	newEndpoints := make(map[string]struct{})
-	for _, v := range endpoints {
-		newEndpoints[v] = struct{}{}
-	}
-	// Remove obsolete endpoints.
-	for e := range me.endpoints {
-		if _, ok := newEndpoints[e]; !ok {
-			delete(me.endpoints, e)
-		}
-	}
-	// Add new endpoints and update priority.
-	for i, e := range endpoints {
-		if _, ok := me.endpoints[e]; !ok {
-			me.endpoints[e] = me.newEndpoint(e, i)
-		} else {
-			me.endpoints[e].priority = i
-		}
-	}
-
-	me.maybeUpdateCurrent()
-	return nil
-}
-
-// Updates current to the top-priority available endpoint unless the current endpoint is
-// recovering.
-//
-// Must be run under me.Lock.
-func (me *multiEndpoint) maybeUpdateCurrent() {
-	c, exists := me.endpoints[me.current]
-	var topA *endpoint
-	var top *endpoint
-	for _, e := range me.endpoints {
-		if e.status == available && (topA == nil || topA.priority > e.priority) {
-			topA = e
-		}
-		if top == nil || top.priority > e.priority {
-			top = e
-		}
-	}
-
-	if exists && c.status == recovering && (topA == nil || topA.priority > c.priority) {
-		// Let current endpoint recover while no higher priority endpoints available.
-		return
-	}
-
-	// Always prefer top available endpoint.
-	if topA != nil {
-		me.switchFromTo(c, topA)
-		return
-	}
-
-	// If no current endpoint exists, resort to the top priority endpoint immediately.
-	if !exists {
-		me.current = top.id
-	}
-}
-
-func (me *multiEndpoint) newEndpoint(id string, priority int) *endpoint {
-	s := unavailable
-	if me.recoveryTimeout > 0 {
-		s = recovering
-	}
-	e := &endpoint{
-		id:       id,
-		priority: priority,
-		status:   s,
-	}
-	if e.status == recovering {
-		me.scheduleUnavailable(e)
-	}
-	return e
-}
-
-// Changes or schedules a change of current to the endpoint t.
-//
-// Must be run under me.Lock.
-func (me *multiEndpoint) switchFromTo(f, t *endpoint) {
-	if me.current == t.id {
-		return
-	}
-
-	if me.switchingDelay == 0 || f == nil || f.status == unavailable {
-		// Switching immediately if no delay or no current or current is unavailable.
-		me.current = t.id
-		return
-	}
-
-	me.future = t.id
-	timeAfterFunc(me.switchingDelay, func() {
-		me.Lock()
-		defer me.Unlock()
-		if e, ok := me.endpoints[me.future]; ok && e.status == available {
-			me.current = e.id
-		}
-	})
-}
-
-// SetEndpointAvailability updates the state of an endpoint.
-func (me *multiEndpoint) SetEndpointAvailability(e string, avail bool) {
-	me.Lock()
-	defer me.Unlock()
-	me.setEndpointAvailability(e, avail)
-	me.maybeUpdateCurrent()
-}
-
-// Must be run under me.Lock.
-func (me *multiEndpoint) setEndpointAvailability(e string, avail bool) {
-	ee, ok := me.endpoints[e]
-	if !ok {
-		return
-	}
-
-	if avail {
-		setState(ee, available)
-		return
-	}
-
-	if ee.status != available {
-		return
-	}
-
-	if me.recoveryTimeout == 0 {
-		setState(ee, unavailable)
-		return
-	}
-
-	setState(ee, recovering)
-	me.scheduleUnavailable(ee)
-}
-
-// Change the state of endpoint e to state s.
-//
-// Must be run under me.Lock.
-func setState(e *endpoint, s status) {
-	if e.futureChange != nil {
-		e.futureChange.Stop()
-	}
-	e.status = s
-	e.lastChange = timeNow()
-}
-
-// Schedule endpoint e to become unavailable after recoveryTimeout.
-func (me *multiEndpoint) scheduleUnavailable(e *endpoint) {
-	stateChange := e.lastChange
-	e.futureChange = timeAfterFunc(me.recoveryTimeout, func() {
-		me.Lock()
-		defer me.Unlock()
-		if e.lastChange != stateChange {
-			// This timer is outdated.
-			return
-		}
-		setState(e, unavailable)
-		me.maybeUpdateCurrent()
-	})
-}
diff --git a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/test_config.json b/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/test_config.json
deleted file mode 100644
index 6291ae9cb..000000000
--- a/vendor/github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp/test_config.json
+++ /dev/null
@@ -1,29 +0,0 @@
-{
-	"channelPool": {
-		"maxSize": 10,
-		"maxConcurrentStreamsLowWatermark": 10
-	},
-	"method": [
-		{
-			"name": [ "method1" ],
-			"affinity": {
-				"command": "BIND",
-				"affinityKey": "key1"
-			}
-		},
-		{
-			"name": [ "method2" ],
-			"affinity": {
-				"command": "BOUND",
-				"affinityKey": "key2"
-			}
-		},
-		{
-			"name": [ "method3" ],
-			"affinity": {
-				"command": "UNBIND",
-				"affinityKey": "key3"
-			}
-		}
-	]
-}
\ No newline at end of file