From b694b715b052dd85692a7ff239c587ed04076ba8 Mon Sep 17 00:00:00 2001 From: Doug Fawley Date: Fri, 21 May 2021 16:05:33 -0700 Subject: [PATCH] xds: a myriad of cleanups --- xds/csds/csds.go | 38 +-- xds/csds/csds_test.go | 26 +- xds/googledirectpath/googlec2p.go | 4 +- xds/googledirectpath/googlec2p_test.go | 2 +- .../balancer/balancergroup/balancergroup.go | 2 +- .../balancergroup/balancergroup_test.go | 2 +- .../balancer/cdsbalancer/cdsbalancer.go | 20 +- .../cdsbalancer/cdsbalancer_security_test.go | 6 +- .../balancer/cdsbalancer/cdsbalancer_test.go | 7 +- .../balancer/cdsbalancer/cluster_handler.go | 6 +- .../cdsbalancer/cluster_handler_test.go | 2 +- .../balancer/clusterimpl/balancer_test.go | 32 +-- .../balancer/clusterimpl/clusterimpl.go | 224 +++++++++-------- xds/internal/balancer/clusterimpl/picker.go | 6 +- xds/internal/balancer/edsbalancer/eds.go | 226 +++++++++--------- xds/internal/balancer/edsbalancer/eds_impl.go | 13 +- .../balancer/edsbalancer/eds_impl_test.go | 7 +- xds/internal/balancer/edsbalancer/eds_test.go | 15 +- .../balancer/edsbalancer/eds_testutil.go | 2 +- xds/internal/balancer/edsbalancer/util.go | 2 +- .../balancer/edsbalancer/util_test.go | 2 +- .../balancer/edsbalancer/xds_lrs_test.go | 2 +- xds/internal/balancer/edsbalancer/xds_old.go | 12 +- .../balancer/loadstore/load_store_wrapper.go | 2 +- xds/internal/balancer/lrs/balancer.go | 42 ++-- xds/internal/balancer/lrs/balancer_test.go | 2 +- xds/internal/httpfilter/fault/fault_test.go | 6 +- xds/internal/resolver/matcher.go | 2 +- xds/internal/resolver/serviceconfig.go | 2 +- xds/internal/resolver/watch_service.go | 6 +- xds/internal/resolver/watch_service_test.go | 2 +- xds/internal/resolver/xds_resolver.go | 44 ++-- xds/internal/resolver/xds_resolver_test.go | 67 +++--- xds/internal/server/conn_wrapper.go | 2 +- xds/internal/server/listener_wrapper.go | 4 +- xds/internal/server/listener_wrapper_test.go | 2 +- xds/internal/testutils/fakeclient/client.go | 133 +++++------ .../{client => xdsclient}/attributes.go | 2 +- .../bootstrap/bootstrap.go | 0 .../bootstrap/bootstrap_test.go | 0 .../bootstrap/logging.go | 0 .../{client => xdsclient}/callback.go | 2 +- .../{client => xdsclient}/cds_test.go | 2 +- xds/internal/{client => xdsclient}/client.go | 10 +- .../{client => xdsclient}/client_test.go | 4 +- xds/internal/{client => xdsclient}/dump.go | 2 +- .../{client => xdsclient}/eds_test.go | 2 +- xds/internal/{client => xdsclient}/errors.go | 2 +- .../{client => xdsclient}/filter_chain.go | 2 +- .../filter_chain_test.go | 2 +- .../{client => xdsclient}/lds_test.go | 2 +- .../{client => xdsclient}/load/reporter.go | 0 .../{client => xdsclient}/load/store.go | 0 .../{client => xdsclient}/load/store_test.go | 0 .../{client => xdsclient}/loadreport.go | 4 +- xds/internal/{client => xdsclient}/logging.go | 2 +- .../{client => xdsclient}/rds_test.go | 2 +- .../{client => xdsclient}/requests_counter.go | 2 +- .../requests_counter_test.go | 2 +- .../{client => xdsclient}/singleton.go | 4 +- .../{client => xdsclient}/tests/README.md | 0 .../tests/client_test.go | 6 +- .../{client => xdsclient}/tests/dump_test.go | 4 +- .../tests/loadreport_test.go | 8 +- .../{client => xdsclient}/transport_helper.go | 4 +- .../{client => xdsclient}/v2/ack_test.go | 2 +- .../{client => xdsclient}/v2/cds_test.go | 2 +- .../{client => xdsclient}/v2/client.go | 2 +- .../{client => xdsclient}/v2/client_test.go | 2 +- .../{client => xdsclient}/v2/eds_test.go | 2 +- .../{client => xdsclient}/v2/lds_test.go | 2 +- .../{client => xdsclient}/v2/loadreport.go | 2 +- .../{client => xdsclient}/v2/rds_test.go | 2 +- .../{client => xdsclient}/v3/client.go | 2 +- .../{client => xdsclient}/v3/loadreport.go | 2 +- .../{client => xdsclient}/watchers.go | 2 +- .../watchers_cluster_test.go | 2 +- .../watchers_endpoints_test.go | 2 +- .../watchers_listener_test.go | 2 +- .../watchers_route_test.go | 2 +- xds/internal/{client => xdsclient}/xds.go | 2 +- xds/server.go | 32 +-- xds/server_test.go | 12 +- xds/xds.go | 4 +- 84 files changed, 546 insertions(+), 578 deletions(-) rename xds/internal/{client => xdsclient}/attributes.go (98%) rename xds/internal/{client => xdsclient}/bootstrap/bootstrap.go (100%) rename xds/internal/{client => xdsclient}/bootstrap/bootstrap_test.go (100%) rename xds/internal/{client => xdsclient}/bootstrap/logging.go (100%) rename xds/internal/{client => xdsclient}/callback.go (99%) rename xds/internal/{client => xdsclient}/cds_test.go (99%) rename xds/internal/{client => xdsclient}/client.go (98%) rename xds/internal/{client => xdsclient}/client_test.go (99%) rename xds/internal/{client => xdsclient}/dump.go (99%) rename xds/internal/{client => xdsclient}/eds_test.go (99%) rename xds/internal/{client => xdsclient}/errors.go (98%) rename xds/internal/{client => xdsclient}/filter_chain.go (99%) rename xds/internal/{client => xdsclient}/filter_chain_test.go (99%) rename xds/internal/{client => xdsclient}/lds_test.go (99%) rename xds/internal/{client => xdsclient}/load/reporter.go (100%) rename xds/internal/{client => xdsclient}/load/store.go (100%) rename xds/internal/{client => xdsclient}/load/store_test.go (100%) rename xds/internal/{client => xdsclient}/loadreport.go (98%) rename xds/internal/{client => xdsclient}/logging.go (98%) rename xds/internal/{client => xdsclient}/rds_test.go (99%) rename xds/internal/{client => xdsclient}/requests_counter.go (99%) rename xds/internal/{client => xdsclient}/requests_counter_test.go (99%) rename xds/internal/{client => xdsclient}/singleton.go (98%) rename xds/internal/{client => xdsclient}/tests/README.md (100%) rename xds/internal/{client => xdsclient}/tests/client_test.go (93%) rename xds/internal/{client => xdsclient}/tests/dump_test.go (99%) rename xds/internal/{client => xdsclient}/tests/loadreport_test.go (94%) rename xds/internal/{client => xdsclient}/transport_helper.go (99%) rename xds/internal/{client => xdsclient}/v2/ack_test.go (99%) rename xds/internal/{client => xdsclient}/v2/cds_test.go (99%) rename xds/internal/{client => xdsclient}/v2/client.go (99%) rename xds/internal/{client => xdsclient}/v2/client_test.go (99%) rename xds/internal/{client => xdsclient}/v2/eds_test.go (99%) rename xds/internal/{client => xdsclient}/v2/lds_test.go (99%) rename xds/internal/{client => xdsclient}/v2/loadreport.go (98%) rename xds/internal/{client => xdsclient}/v2/rds_test.go (99%) rename xds/internal/{client => xdsclient}/v3/client.go (99%) rename xds/internal/{client => xdsclient}/v3/loadreport.go (98%) rename xds/internal/{client => xdsclient}/watchers.go (99%) rename xds/internal/{client => xdsclient}/watchers_cluster_test.go (99%) rename xds/internal/{client => xdsclient}/watchers_endpoints_test.go (99%) rename xds/internal/{client => xdsclient}/watchers_listener_test.go (99%) rename xds/internal/{client => xdsclient}/watchers_route_test.go (99%) rename xds/internal/{client => xdsclient}/xds.go (99%) diff --git a/xds/csds/csds.go b/xds/csds/csds.go index 73b92e9443c..5e2407d8941 100644 --- a/xds/csds/csds.go +++ b/xds/csds/csds.go @@ -38,29 +38,29 @@ import ( "google.golang.org/grpc/codes" "google.golang.org/grpc/grpclog" "google.golang.org/grpc/status" - "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/bootstrap" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/bootstrap" "google.golang.org/protobuf/types/known/timestamppb" - _ "google.golang.org/grpc/xds/internal/client/v2" // Register v2 xds_client. - _ "google.golang.org/grpc/xds/internal/client/v3" // Register v3 xds_client. + _ "google.golang.org/grpc/xds/internal/xdsclient/v2" // Register v2 xds_client. + _ "google.golang.org/grpc/xds/internal/xdsclient/v3" // Register v3 xds_client. ) -// xdsClientInterface contains methods from xdsClient.Client which are used by +// xdsClient contains methods from xdsClient.Client which are used by // the server. This is useful for overriding in unit tests. -type xdsClientInterface interface { - DumpLDS() (string, map[string]client.UpdateWithMD) - DumpRDS() (string, map[string]client.UpdateWithMD) - DumpCDS() (string, map[string]client.UpdateWithMD) - DumpEDS() (string, map[string]client.UpdateWithMD) +type xdsClient interface { + DumpLDS() (string, map[string]xdsclient.UpdateWithMD) + DumpRDS() (string, map[string]xdsclient.UpdateWithMD) + DumpCDS() (string, map[string]xdsclient.UpdateWithMD) + DumpEDS() (string, map[string]xdsclient.UpdateWithMD) BootstrapConfig() *bootstrap.Config Close() } var ( logger = grpclog.Component("xds") - newXDSClient = func() (xdsClientInterface, error) { - return client.New() + newXDSClient = func() (xdsClient, error) { + return xdsclient.New() } ) @@ -68,7 +68,7 @@ var ( type ClientStatusDiscoveryServer struct { // xdsClient will always be the same in practise. But we keep a copy in each // server instance for testing. - xdsClient xdsClientInterface + xdsClient xdsClient } // NewClientStatusDiscoveryServer returns an implementation of the CSDS server that can be @@ -296,17 +296,17 @@ func (s *ClientStatusDiscoveryServer) buildEDSPerXDSConfig() *v3statuspb.PerXdsC } } -func serviceStatusToProto(serviceStatus client.ServiceStatus) v3adminpb.ClientResourceStatus { +func serviceStatusToProto(serviceStatus xdsclient.ServiceStatus) v3adminpb.ClientResourceStatus { switch serviceStatus { - case client.ServiceStatusUnknown: + case xdsclient.ServiceStatusUnknown: return v3adminpb.ClientResourceStatus_UNKNOWN - case client.ServiceStatusRequested: + case xdsclient.ServiceStatusRequested: return v3adminpb.ClientResourceStatus_REQUESTED - case client.ServiceStatusNotExist: + case xdsclient.ServiceStatusNotExist: return v3adminpb.ClientResourceStatus_DOES_NOT_EXIST - case client.ServiceStatusACKed: + case xdsclient.ServiceStatusACKed: return v3adminpb.ClientResourceStatus_ACKED - case client.ServiceStatusNACKed: + case xdsclient.ServiceStatusNACKed: return v3adminpb.ClientResourceStatus_NACKED default: return v3adminpb.ClientResourceStatus_UNKNOWN diff --git a/xds/csds/csds_test.go b/xds/csds/csds_test.go index 6cf88f6d394..b449798c804 100644 --- a/xds/csds/csds_test.go +++ b/xds/csds/csds_test.go @@ -36,10 +36,10 @@ import ( "google.golang.org/grpc" "google.golang.org/grpc/internal/testutils" "google.golang.org/grpc/internal/xds" - "google.golang.org/grpc/xds/internal/client" _ "google.golang.org/grpc/xds/internal/httpfilter/router" xtestutils "google.golang.org/grpc/xds/internal/testutils" "google.golang.org/grpc/xds/internal/testutils/e2e" + "google.golang.org/grpc/xds/internal/xdsclient" "google.golang.org/protobuf/testing/protocmp" "google.golang.org/protobuf/types/known/anypb" "google.golang.org/protobuf/types/known/timestamppb" @@ -59,11 +59,11 @@ const ( defaultTestTimeout = 10 * time.Second ) -type xdsClientInterfaceWithWatch interface { - WatchListener(string, func(client.ListenerUpdate, error)) func() - WatchRouteConfig(string, func(client.RouteConfigUpdate, error)) func() - WatchCluster(string, func(client.ClusterUpdate, error)) func() - WatchEndpoints(string, func(client.EndpointsUpdate, error)) func() +type xdsClientWithWatch interface { + WatchListener(string, func(xdsclient.ListenerUpdate, error)) func() + WatchRouteConfig(string, func(xdsclient.RouteConfigUpdate, error)) func() + WatchCluster(string, func(xdsclient.ClusterUpdate, error)) func() + WatchEndpoints(string, func(xdsclient.EndpointsUpdate, error)) func() } var cmpOpts = cmp.Options{ @@ -174,16 +174,16 @@ func TestCSDS(t *testing.T) { defer cleanup() for _, target := range ldsTargets { - xdsC.WatchListener(target, func(client.ListenerUpdate, error) {}) + xdsC.WatchListener(target, func(xdsclient.ListenerUpdate, error) {}) } for _, target := range rdsTargets { - xdsC.WatchRouteConfig(target, func(client.RouteConfigUpdate, error) {}) + xdsC.WatchRouteConfig(target, func(xdsclient.RouteConfigUpdate, error) {}) } for _, target := range cdsTargets { - xdsC.WatchCluster(target, func(client.ClusterUpdate, error) {}) + xdsC.WatchCluster(target, func(xdsclient.ClusterUpdate, error) {}) } for _, target := range edsTargets { - xdsC.WatchEndpoints(target, func(client.EndpointsUpdate, error) {}) + xdsC.WatchEndpoints(target, func(xdsclient.EndpointsUpdate, error) {}) } for i := 0; i < retryCount; i++ { @@ -250,7 +250,7 @@ func TestCSDS(t *testing.T) { } } -func commonSetup(t *testing.T) (xdsClientInterfaceWithWatch, *e2e.ManagementServer, string, v3statuspbgrpc.ClientStatusDiscoveryService_StreamClientStatusClient, func()) { +func commonSetup(t *testing.T) (xdsClientWithWatch, *e2e.ManagementServer, string, v3statuspbgrpc.ClientStatusDiscoveryService_StreamClientStatusClient, func()) { t.Helper() // Spin up a xDS management server on a local port. @@ -270,12 +270,12 @@ func commonSetup(t *testing.T) (xdsClientInterfaceWithWatch, *e2e.ManagementServ t.Fatal(err) } // Create xds_client. - xdsC, err := client.New() + xdsC, err := xdsclient.New() if err != nil { t.Fatalf("failed to create xds client: %v", err) } oldNewXDSClient := newXDSClient - newXDSClient = func() (xdsClientInterface, error) { + newXDSClient = func() (xdsClient, error) { return xdsC, nil } diff --git a/xds/googledirectpath/googlec2p.go b/xds/googledirectpath/googlec2p.go index 4ccec4ec412..ccf9f152ca7 100644 --- a/xds/googledirectpath/googlec2p.go +++ b/xds/googledirectpath/googlec2p.go @@ -38,9 +38,9 @@ import ( "google.golang.org/grpc/internal/xds/env" "google.golang.org/grpc/resolver" _ "google.golang.org/grpc/xds" // To register xds resolvers and balancers. - xdsclient "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/bootstrap" "google.golang.org/grpc/xds/internal/version" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/bootstrap" "google.golang.org/protobuf/types/known/structpb" ) diff --git a/xds/googledirectpath/googlec2p_test.go b/xds/googledirectpath/googlec2p_test.go index 524bb82e0f3..ba6167e5b6c 100644 --- a/xds/googledirectpath/googlec2p_test.go +++ b/xds/googledirectpath/googlec2p_test.go @@ -31,8 +31,8 @@ import ( "google.golang.org/grpc" "google.golang.org/grpc/internal/xds/env" "google.golang.org/grpc/resolver" - "google.golang.org/grpc/xds/internal/client/bootstrap" "google.golang.org/grpc/xds/internal/version" + "google.golang.org/grpc/xds/internal/xdsclient/bootstrap" "google.golang.org/protobuf/testing/protocmp" "google.golang.org/protobuf/types/known/structpb" ) diff --git a/xds/internal/balancer/balancergroup/balancergroup.go b/xds/internal/balancer/balancergroup/balancergroup.go index 5b6d42a25e4..b86dea50e80 100644 --- a/xds/internal/balancer/balancergroup/balancergroup.go +++ b/xds/internal/balancer/balancergroup/balancergroup.go @@ -24,7 +24,7 @@ import ( "time" orcapb "github.com/cncf/udpa/go/udpa/data/orca/v1" - "google.golang.org/grpc/xds/internal/client/load" + "google.golang.org/grpc/xds/internal/xdsclient/load" "google.golang.org/grpc/balancer" "google.golang.org/grpc/connectivity" diff --git a/xds/internal/balancer/balancergroup/balancergroup_test.go b/xds/internal/balancer/balancergroup/balancergroup_test.go index 1ba9195ab1d..cf9a228ec1f 100644 --- a/xds/internal/balancer/balancergroup/balancergroup_test.go +++ b/xds/internal/balancer/balancergroup/balancergroup_test.go @@ -44,8 +44,8 @@ import ( "google.golang.org/grpc/internal/balancer/stub" "google.golang.org/grpc/resolver" "google.golang.org/grpc/xds/internal/balancer/weightedtarget/weightedaggregator" - "google.golang.org/grpc/xds/internal/client/load" "google.golang.org/grpc/xds/internal/testutils" + "google.golang.org/grpc/xds/internal/xdsclient/load" ) var ( diff --git a/xds/internal/balancer/cdsbalancer/cdsbalancer.go b/xds/internal/balancer/cdsbalancer/cdsbalancer.go index 1e6b7a2c08c..6521b045e6a 100644 --- a/xds/internal/balancer/cdsbalancer/cdsbalancer.go +++ b/xds/internal/balancer/cdsbalancer/cdsbalancer.go @@ -35,8 +35,8 @@ import ( "google.golang.org/grpc/resolver" "google.golang.org/grpc/serviceconfig" "google.golang.org/grpc/xds/internal/balancer/edsbalancer" - xdsclient "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/bootstrap" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/bootstrap" ) const ( @@ -59,7 +59,7 @@ var ( // not deal with subConns. return builder.Build(cc, opts), nil } - newXDSClient func() (xdsClientInterface, error) + newXDSClient func() (xdsClient, error) buildProvider = buildProviderFunc ) @@ -73,6 +73,8 @@ func init() { // JSON service config, to be passed to the cdsBalancer. type cdsBB struct{} +var _ balancer.ConfigParser = cdsBB{} + // Build creates a new CDS balancer with the ClientConn. func (cdsBB) Build(cc balancer.ClientConn, opts balancer.BuildOptions) balancer.Balancer { b := &cdsBalancer{ @@ -138,12 +140,11 @@ func (cdsBB) ParseConfig(c json.RawMessage) (serviceconfig.LoadBalancingConfig, return &cfg, nil } -// xdsClientInterface contains methods from xdsClient.Client which are used by -// the cdsBalancer. This will be faked out in unittests. -type xdsClientInterface interface { +// xdsClient contains methods from xdsclient.Client which are used by the +// cdsBalancer. This will be faked out in unittests. +type xdsClient interface { WatchCluster(string, func(xdsclient.ClusterUpdate, error)) func() BootstrapConfig() *bootstrap.Config - Close() } // ccUpdate wraps a clientConn update received from gRPC (pushed from the @@ -185,7 +186,7 @@ type cdsBalancer struct { ccw *ccWrapper // ClientConn interface passed to child LB. bOpts balancer.BuildOptions // BuildOptions passed to child LB. updateCh *buffer.Unbounded // Channel for gRPC and xdsClient updates. - xdsClient xdsClientInterface // xDS client to watch Cluster resource. + xdsClient xdsClient // xDS client to watch Cluster resource. cancelWatch func() // Cluster watch cancel func. edsLB balancer.Balancer // EDS child policy. clusterToWatch string @@ -408,9 +409,6 @@ func (b *cdsBalancer) run() { b.edsLB.Close() b.edsLB = nil } - if newXDSClient != nil { - b.xdsClient.Close() - } if b.cachedRoot != nil { b.cachedRoot.Close() } diff --git a/xds/internal/balancer/cdsbalancer/cdsbalancer_security_test.go b/xds/internal/balancer/cdsbalancer/cdsbalancer_security_test.go index 52b1a05f136..9964b9de925 100644 --- a/xds/internal/balancer/cdsbalancer/cdsbalancer_security_test.go +++ b/xds/internal/balancer/cdsbalancer/cdsbalancer_security_test.go @@ -36,10 +36,10 @@ import ( "google.golang.org/grpc/internal/testutils" "google.golang.org/grpc/internal/xds/matcher" "google.golang.org/grpc/resolver" - xdsclient "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/bootstrap" xdstestutils "google.golang.org/grpc/xds/internal/testutils" "google.golang.org/grpc/xds/internal/testutils/fakeclient" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/bootstrap" ) const ( @@ -136,7 +136,7 @@ func setupWithXDSCreds(t *testing.T) (*fakeclient.Client, *cdsBalancer, *testEDS xdsC := fakeclient.NewClient() oldNewXDSClient := newXDSClient - newXDSClient = func() (xdsClientInterface, error) { return xdsC, nil } + newXDSClient = func() (xdsClient, error) { return xdsC, nil } builder := balancer.Get(cdsName) if builder == nil { diff --git a/xds/internal/balancer/cdsbalancer/cdsbalancer_test.go b/xds/internal/balancer/cdsbalancer/cdsbalancer_test.go index fba3ee1531e..5c5161807be 100644 --- a/xds/internal/balancer/cdsbalancer/cdsbalancer_test.go +++ b/xds/internal/balancer/cdsbalancer/cdsbalancer_test.go @@ -37,10 +37,9 @@ import ( "google.golang.org/grpc/resolver" "google.golang.org/grpc/serviceconfig" "google.golang.org/grpc/xds/internal/balancer/edsbalancer" - "google.golang.org/grpc/xds/internal/client" - xdsclient "google.golang.org/grpc/xds/internal/client" xdstestutils "google.golang.org/grpc/xds/internal/testutils" "google.golang.org/grpc/xds/internal/testutils/fakeclient" + "google.golang.org/grpc/xds/internal/xdsclient" ) const ( @@ -215,7 +214,7 @@ func setup(t *testing.T) (*fakeclient.Client, *cdsBalancer, *testEDSBalancer, *x xdsC := fakeclient.NewClient() oldNewXDSClient := newXDSClient - newXDSClient = func() (xdsClientInterface, error) { return xdsC, nil } + newXDSClient = func() (xdsClient, error) { return xdsC, nil } builder := balancer.Get(cdsName) if builder == nil { @@ -606,7 +605,7 @@ func (s) TestCircuitBreaking(t *testing.T) { // Since the counter's max requests was set to 1, the first request should // succeed and the second should fail. - counter := client.GetServiceRequestsCounter(serviceName) + counter := xdsclient.GetServiceRequestsCounter(serviceName) if err := counter.StartRequest(maxRequests); err != nil { t.Fatal(err) } diff --git a/xds/internal/balancer/cdsbalancer/cluster_handler.go b/xds/internal/balancer/cdsbalancer/cluster_handler.go index 4c13b55594d..c38d1a6c31a 100644 --- a/xds/internal/balancer/cdsbalancer/cluster_handler.go +++ b/xds/internal/balancer/cdsbalancer/cluster_handler.go @@ -20,7 +20,7 @@ import ( "errors" "sync" - xdsclient "google.golang.org/grpc/xds/internal/client" + "google.golang.org/grpc/xds/internal/xdsclient" ) var errNotReceivedUpdate = errors.New("tried to construct a cluster update on a cluster that has not received an update") @@ -40,7 +40,7 @@ type clusterHandler struct { // CDS Balancer cares about is the most recent update. updateChannel chan clusterHandlerUpdate - xdsClient xdsClientInterface + xdsClient xdsClient } func (ch *clusterHandler) updateRootCluster(rootClusterName string) { @@ -112,7 +112,7 @@ type clusterNode struct { // CreateClusterNode creates a cluster node from a given clusterName. This will // also start the watch for that cluster. -func createClusterNode(clusterName string, xdsClient xdsClientInterface, topLevelHandler *clusterHandler) *clusterNode { +func createClusterNode(clusterName string, xdsClient xdsClient, topLevelHandler *clusterHandler) *clusterNode { c := &clusterNode{ clusterHandler: topLevelHandler, } diff --git a/xds/internal/balancer/cdsbalancer/cluster_handler_test.go b/xds/internal/balancer/cdsbalancer/cluster_handler_test.go index 049cdf55ee6..886dba41643 100644 --- a/xds/internal/balancer/cdsbalancer/cluster_handler_test.go +++ b/xds/internal/balancer/cdsbalancer/cluster_handler_test.go @@ -24,8 +24,8 @@ import ( "testing" "github.com/google/go-cmp/cmp" - xdsclient "google.golang.org/grpc/xds/internal/client" "google.golang.org/grpc/xds/internal/testutils/fakeclient" + "google.golang.org/grpc/xds/internal/xdsclient" ) const ( diff --git a/xds/internal/balancer/clusterimpl/balancer_test.go b/xds/internal/balancer/clusterimpl/balancer_test.go index cfce6f67391..75c16f07167 100644 --- a/xds/internal/balancer/clusterimpl/balancer_test.go +++ b/xds/internal/balancer/clusterimpl/balancer_test.go @@ -34,10 +34,10 @@ import ( "google.golang.org/grpc/internal" internalserviceconfig "google.golang.org/grpc/internal/serviceconfig" "google.golang.org/grpc/resolver" - "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/load" "google.golang.org/grpc/xds/internal/testutils" "google.golang.org/grpc/xds/internal/testutils/fakeclient" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/load" ) const ( @@ -72,10 +72,10 @@ func init() { // TestDropByCategory verifies that the balancer correctly drops the picks, and // that the drops are reported. func TestDropByCategory(t *testing.T) { - defer client.ClearCounterForTesting(testClusterName) + defer xdsclient.ClearCounterForTesting(testClusterName) xdsC := fakeclient.NewClient() oldNewXDSClient := newXDSClient - newXDSClient = func() (xdsClientInterface, error) { return xdsC, nil } + newXDSClient = func() (xdsClient, error) { return xdsC, nil } defer func() { newXDSClient = oldNewXDSClient }() builder := balancer.Get(Name) @@ -113,10 +113,10 @@ func TestDropByCategory(t *testing.T) { got, err := xdsC.WaitForReportLoad(ctx) if err != nil { - t.Fatalf("xdsClient.ReportLoad failed with error: %v", err) + t.Fatalf("client.ReportLoad failed with error: %v", err) } if got.Server != testLRSServerName { - t.Fatalf("xdsClient.ReportLoad called with {%q}: want {%q}", got.Server, testLRSServerName) + t.Fatalf("client.ReportLoad called with {%q}: want {%q}", got.Server, testLRSServerName) } sc1 := <-cc.NewSubConnCh @@ -230,10 +230,10 @@ func TestDropByCategory(t *testing.T) { // TestDropCircuitBreaking verifies that the balancer correctly drops the picks // due to circuit breaking, and that the drops are reported. func TestDropCircuitBreaking(t *testing.T) { - defer client.ClearCounterForTesting(testClusterName) + defer xdsclient.ClearCounterForTesting(testClusterName) xdsC := fakeclient.NewClient() oldNewXDSClient := newXDSClient - newXDSClient = func() (xdsClientInterface, error) { return xdsC, nil } + newXDSClient = func() (xdsClient, error) { return xdsC, nil } defer func() { newXDSClient = oldNewXDSClient }() builder := balancer.Get(Name) @@ -264,10 +264,10 @@ func TestDropCircuitBreaking(t *testing.T) { got, err := xdsC.WaitForReportLoad(ctx) if err != nil { - t.Fatalf("xdsClient.ReportLoad failed with error: %v", err) + t.Fatalf("client.ReportLoad failed with error: %v", err) } if got.Server != testLRSServerName { - t.Fatalf("xdsClient.ReportLoad called with {%q}: want {%q}", got.Server, testLRSServerName) + t.Fatalf("client.ReportLoad called with {%q}: want {%q}", got.Server, testLRSServerName) } sc1 := <-cc.NewSubConnCh @@ -342,10 +342,10 @@ func TestDropCircuitBreaking(t *testing.T) { // picker after it's closed. Because picker updates are sent in the run() // goroutine. func TestPickerUpdateAfterClose(t *testing.T) { - defer client.ClearCounterForTesting(testClusterName) + defer xdsclient.ClearCounterForTesting(testClusterName) xdsC := fakeclient.NewClient() oldNewXDSClient := newXDSClient - newXDSClient = func() (xdsClientInterface, error) { return xdsC, nil } + newXDSClient = func() (xdsClient, error) { return xdsC, nil } defer func() { newXDSClient = oldNewXDSClient }() builder := balancer.Get(Name) @@ -387,10 +387,10 @@ func TestPickerUpdateAfterClose(t *testing.T) { // TestClusterNameInAddressAttributes covers the case that cluster name is // attached to the subconn address attributes. func TestClusterNameInAddressAttributes(t *testing.T) { - defer client.ClearCounterForTesting(testClusterName) + defer xdsclient.ClearCounterForTesting(testClusterName) xdsC := fakeclient.NewClient() oldNewXDSClient := newXDSClient - newXDSClient = func() (xdsClientInterface, error) { return xdsC, nil } + newXDSClient = func() (xdsClient, error) { return xdsC, nil } defer func() { newXDSClient = oldNewXDSClient }() builder := balancer.Get(Name) @@ -478,10 +478,10 @@ func TestClusterNameInAddressAttributes(t *testing.T) { // TestReResolution verifies that when a SubConn turns transient failure, // re-resolution is triggered. func TestReResolution(t *testing.T) { - defer client.ClearCounterForTesting(testClusterName) + defer xdsclient.ClearCounterForTesting(testClusterName) xdsC := fakeclient.NewClient() oldNewXDSClient := newXDSClient - newXDSClient = func() (xdsClientInterface, error) { return xdsC, nil } + newXDSClient = func() (xdsClient, error) { return xdsC, nil } defer func() { newXDSClient = oldNewXDSClient }() builder := balancer.Get(Name) diff --git a/xds/internal/balancer/clusterimpl/clusterimpl.go b/xds/internal/balancer/clusterimpl/clusterimpl.go index e72b867e2f2..c9a7b2d2668 100644 --- a/xds/internal/balancer/clusterimpl/clusterimpl.go +++ b/xds/internal/balancer/clusterimpl/clusterimpl.go @@ -38,8 +38,8 @@ import ( "google.golang.org/grpc/resolver" "google.golang.org/grpc/serviceconfig" "google.golang.org/grpc/xds/internal/balancer/loadstore" - xdsclient "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/load" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/load" ) const ( @@ -52,14 +52,14 @@ func init() { balancer.Register(clusterImplBB{}) } -var newXDSClient func() (xdsClientInterface, error) +var newXDSClient func() (xdsClient, error) type clusterImplBB struct{} func (clusterImplBB) Build(cc balancer.ClientConn, bOpts balancer.BuildOptions) balancer.Balancer { b := &clusterImplBalancer{ ClientConn: cc, - bOpts: bOpts, + buildOpts: bOpts, closed: grpcsync.NewEvent(), done: grpcsync.NewEvent(), loadWrapper: loadstore.NewWrapper(), @@ -75,7 +75,7 @@ func (clusterImplBB) Build(cc balancer.ClientConn, bOpts balancer.BuildOptions) b.logger.Errorf("failed to create xds-client: %v", err) return nil } - b.xdsC = client + b.xdsClient = client } go b.run() @@ -91,11 +91,10 @@ func (clusterImplBB) ParseConfig(c json.RawMessage) (serviceconfig.LoadBalancing return parseConfig(c) } -// xdsClientInterface contains only the xds_client methods needed by LRS -// balancer. It's defined so we can override xdsclient in tests. -type xdsClientInterface interface { +// xdsClient contains only the xds_client methods needed by LRS balancer. It's +// defined so we can override xdsclient in tests. +type xdsClient interface { ReportLoad(server string) (*load.Store, func()) - Close() } type clusterImplBalancer struct { @@ -113,9 +112,9 @@ type clusterImplBalancer struct { closed *grpcsync.Event done *grpcsync.Event - bOpts balancer.BuildOptions - logger *grpclog.PrefixLogger - xdsC xdsClientInterface + buildOpts balancer.BuildOptions + logger *grpclog.PrefixLogger + xdsClient xdsClient config *LBConfig childLB balancer.Balancer @@ -139,20 +138,20 @@ type clusterImplBalancer struct { // updateLoadStore checks the config for load store, and decides whether it // needs to restart the load reporting stream. -func (cib *clusterImplBalancer) updateLoadStore(newConfig *LBConfig) error { +func (b *clusterImplBalancer) updateLoadStore(newConfig *LBConfig) error { var updateLoadClusterAndService bool // ClusterName is different, restart. ClusterName is from ClusterName and // EDSServiceName. - clusterName := cib.getClusterName() + clusterName := b.getClusterName() if clusterName != newConfig.Cluster { updateLoadClusterAndService = true - cib.setClusterName(newConfig.Cluster) + b.setClusterName(newConfig.Cluster) clusterName = newConfig.Cluster } - if cib.edsServiceName != newConfig.EDSServiceName { + if b.edsServiceName != newConfig.EDSServiceName { updateLoadClusterAndService = true - cib.edsServiceName = newConfig.EDSServiceName + b.edsServiceName = newConfig.EDSServiceName } if updateLoadClusterAndService { // This updates the clusterName and serviceName that will be reported @@ -163,7 +162,7 @@ func (cib *clusterImplBalancer) updateLoadStore(newConfig *LBConfig) error { // On the other hand, this will almost never happen. Each LRS policy // shouldn't get updated config. The parent should do a graceful switch // when the clusterName or serviceName is changed. - cib.loadWrapper.UpdateClusterAndService(clusterName, cib.edsServiceName) + b.loadWrapper.UpdateClusterAndService(clusterName, b.edsServiceName) } // Check if it's necessary to restart load report. @@ -171,31 +170,31 @@ func (cib *clusterImplBalancer) updateLoadStore(newConfig *LBConfig) error { if newConfig.LoadReportingServerName != nil { newLRSServerName = *newConfig.LoadReportingServerName } - if cib.lrsServerName != newLRSServerName { + if b.lrsServerName != newLRSServerName { // LoadReportingServerName is different, load should be report to a // different server, restart. - cib.lrsServerName = newLRSServerName - if cib.cancelLoadReport != nil { - cib.cancelLoadReport() - cib.cancelLoadReport = nil + b.lrsServerName = newLRSServerName + if b.cancelLoadReport != nil { + b.cancelLoadReport() + b.cancelLoadReport = nil } var loadStore *load.Store - if cib.xdsC != nil { - loadStore, cib.cancelLoadReport = cib.xdsC.ReportLoad(cib.lrsServerName) + if b.xdsClient != nil { + loadStore, b.cancelLoadReport = b.xdsClient.ReportLoad(b.lrsServerName) } - cib.loadWrapper.UpdateLoadStore(loadStore) + b.loadWrapper.UpdateLoadStore(loadStore) } return nil } -func (cib *clusterImplBalancer) UpdateClientConnState(s balancer.ClientConnState) error { - if cib.closed.HasFired() { - cib.logger.Warningf("xds: received ClientConnState {%+v} after clusterImplBalancer was closed", s) +func (b *clusterImplBalancer) UpdateClientConnState(s balancer.ClientConnState) error { + if b.closed.HasFired() { + b.logger.Warningf("xds: received ClientConnState {%+v} after clusterImplBalancer was closed", s) return nil } - cib.logger.Infof("Received update from resolver, balancer config: %+v", pretty.ToJSON(s.BalancerConfig)) + b.logger.Infof("Received update from resolver, balancer config: %+v", pretty.ToJSON(s.BalancerConfig)) newConfig, ok := s.BalancerConfig.(*LBConfig) if !ok { return fmt.Errorf("unexpected balancer config with type: %T", s.BalancerConfig) @@ -209,36 +208,36 @@ func (cib *clusterImplBalancer) UpdateClientConnState(s balancer.ClientConnState return fmt.Errorf("balancer %q not registered", newConfig.ChildPolicy.Name) } - if cib.xdsC == nil { + if b.xdsClient == nil { c := xdsclient.FromResolverState(s.ResolverState) if c == nil { return balancer.ErrBadResolverState } - cib.xdsC = c + b.xdsClient = c } // Update load reporting config. This needs to be done before updating the // child policy because we need the loadStore from the updated client to be // passed to the ccWrapper, so that the next picker from the child policy // will pick up the new loadStore. - if err := cib.updateLoadStore(newConfig); err != nil { + if err := b.updateLoadStore(newConfig); err != nil { return err } // Compare new drop config. And update picker if it's changed. var updatePicker bool - if cib.config == nil || !equalDropCategories(cib.config.DropCategories, newConfig.DropCategories) { - cib.drops = make([]*dropper, 0, len(newConfig.DropCategories)) + if b.config == nil || !equalDropCategories(b.config.DropCategories, newConfig.DropCategories) { + b.drops = make([]*dropper, 0, len(newConfig.DropCategories)) for _, c := range newConfig.DropCategories { - cib.drops = append(cib.drops, newDropper(c)) + b.drops = append(b.drops, newDropper(c)) } updatePicker = true } // Compare cluster name. And update picker if it's changed, because circuit // breaking's stream counter will be different. - if cib.config == nil || cib.config.Cluster != newConfig.Cluster { - cib.requestCounter = xdsclient.GetServiceRequestsCounter(newConfig.Cluster) + if b.config == nil || b.config.Cluster != newConfig.Cluster { + b.requestCounter = xdsclient.GetServiceRequestsCounter(newConfig.Cluster) updatePicker = true } // Compare upper bound of stream count. And update picker if it's changed. @@ -247,29 +246,29 @@ func (cib *clusterImplBalancer) UpdateClientConnState(s balancer.ClientConnState if newConfig.MaxConcurrentRequests != nil { newRequestCountMax = *newConfig.MaxConcurrentRequests } - if cib.requestCountMax != newRequestCountMax { - cib.requestCountMax = newRequestCountMax + if b.requestCountMax != newRequestCountMax { + b.requestCountMax = newRequestCountMax updatePicker = true } if updatePicker { - cib.pickerUpdateCh.Put(&dropConfigs{ - drops: cib.drops, - requestCounter: cib.requestCounter, - requestCountMax: cib.requestCountMax, + b.pickerUpdateCh.Put(&dropConfigs{ + drops: b.drops, + requestCounter: b.requestCounter, + requestCountMax: b.requestCountMax, }) } // If child policy is a different type, recreate the sub-balancer. - if cib.config == nil || cib.config.ChildPolicy.Name != newConfig.ChildPolicy.Name { - if cib.childLB != nil { - cib.childLB.Close() + if b.config == nil || b.config.ChildPolicy.Name != newConfig.ChildPolicy.Name { + if b.childLB != nil { + b.childLB.Close() } - cib.childLB = bb.Build(cib, cib.bOpts) + b.childLB = bb.Build(b, b.buildOpts) } - cib.config = newConfig + b.config = newConfig - if cib.childLB == nil { + if b.childLB == nil { // This is not an expected situation, and should be super rare in // practice. // @@ -280,26 +279,26 @@ func (cib *clusterImplBalancer) UpdateClientConnState(s balancer.ClientConnState } // Addresses and sub-balancer config are sent to sub-balancer. - return cib.childLB.UpdateClientConnState(balancer.ClientConnState{ + return b.childLB.UpdateClientConnState(balancer.ClientConnState{ ResolverState: s.ResolverState, - BalancerConfig: cib.config.ChildPolicy.Config, + BalancerConfig: b.config.ChildPolicy.Config, }) } -func (cib *clusterImplBalancer) ResolverError(err error) { - if cib.closed.HasFired() { - cib.logger.Warningf("xds: received resolver error {%+v} after clusterImplBalancer was closed", err) +func (b *clusterImplBalancer) ResolverError(err error) { + if b.closed.HasFired() { + b.logger.Warningf("xds: received resolver error {%+v} after clusterImplBalancer was closed", err) return } - if cib.childLB != nil { - cib.childLB.ResolverError(err) + if b.childLB != nil { + b.childLB.ResolverError(err) } } -func (cib *clusterImplBalancer) UpdateSubConnState(sc balancer.SubConn, s balancer.SubConnState) { - if cib.closed.HasFired() { - cib.logger.Warningf("xds: received subconn state change {%+v, %+v} after clusterImplBalancer was closed", sc, s) +func (b *clusterImplBalancer) UpdateSubConnState(sc balancer.SubConn, s balancer.SubConnState) { + if b.closed.HasFired() { + b.logger.Warningf("xds: received subconn state change {%+v, %+v} after clusterImplBalancer was closed", sc, s) return } @@ -311,65 +310,62 @@ func (cib *clusterImplBalancer) UpdateSubConnState(sc balancer.SubConn, s balanc // knows). The parent priority policy is configured to ignore re-resolution // signal from the EDS children. if s.ConnectivityState == connectivity.TransientFailure { - cib.ClientConn.ResolveNow(resolver.ResolveNowOptions{}) + b.ClientConn.ResolveNow(resolver.ResolveNowOptions{}) } - if cib.childLB != nil { - cib.childLB.UpdateSubConnState(sc, s) + if b.childLB != nil { + b.childLB.UpdateSubConnState(sc, s) } } -func (cib *clusterImplBalancer) Close() { - cib.mu.Lock() - cib.closed.Fire() - cib.mu.Unlock() +func (b *clusterImplBalancer) Close() { + b.mu.Lock() + b.closed.Fire() + b.mu.Unlock() - if cib.childLB != nil { - cib.childLB.Close() - cib.childLB = nil + if b.childLB != nil { + b.childLB.Close() + b.childLB = nil } - if newXDSClient != nil { - cib.xdsC.Close() - } - <-cib.done.Done() - cib.logger.Infof("Shutdown") + <-b.done.Done() + b.logger.Infof("Shutdown") } // Override methods to accept updates from the child LB. -func (cib *clusterImplBalancer) UpdateState(state balancer.State) { +func (b *clusterImplBalancer) UpdateState(state balancer.State) { // Instead of updating parent ClientConn inline, send state to run(). - cib.pickerUpdateCh.Put(state) + b.pickerUpdateCh.Put(state) } -func (cib *clusterImplBalancer) setClusterName(n string) { - cib.clusterNameMu.Lock() - defer cib.clusterNameMu.Unlock() - cib.clusterName = n +func (b *clusterImplBalancer) setClusterName(n string) { + b.clusterNameMu.Lock() + defer b.clusterNameMu.Unlock() + b.clusterName = n } -func (cib *clusterImplBalancer) getClusterName() string { - cib.clusterNameMu.Lock() - defer cib.clusterNameMu.Unlock() - return cib.clusterName +func (b *clusterImplBalancer) getClusterName() string { + b.clusterNameMu.Lock() + defer b.clusterNameMu.Unlock() + return b.clusterName } -func (cib *clusterImplBalancer) NewSubConn(addrs []resolver.Address, opts balancer.NewSubConnOptions) (balancer.SubConn, error) { - clusterName := cib.getClusterName() +func (b *clusterImplBalancer) NewSubConn(addrs []resolver.Address, opts balancer.NewSubConnOptions) (balancer.SubConn, error) { + clusterName := b.getClusterName() newAddrs := make([]resolver.Address, len(addrs)) for i, addr := range addrs { newAddrs[i] = internal.SetXDSHandshakeClusterName(addr, clusterName) } - return cib.ClientConn.NewSubConn(newAddrs, opts) + return b.ClientConn.NewSubConn(newAddrs, opts) } -func (cib *clusterImplBalancer) UpdateAddresses(sc balancer.SubConn, addrs []resolver.Address) { - clusterName := cib.getClusterName() +func (b *clusterImplBalancer) UpdateAddresses(sc balancer.SubConn, addrs []resolver.Address) { + clusterName := b.getClusterName() newAddrs := make([]resolver.Address, len(addrs)) for i, addr := range addrs { newAddrs[i] = internal.SetXDSHandshakeClusterName(addr, clusterName) } - cib.ClientConn.UpdateAddresses(sc, newAddrs) + b.ClientConn.UpdateAddresses(sc, newAddrs) } type dropConfigs struct { @@ -378,40 +374,40 @@ type dropConfigs struct { requestCountMax uint32 } -func (cib *clusterImplBalancer) run() { - defer cib.done.Fire() +func (b *clusterImplBalancer) run() { + defer b.done.Fire() for { select { - case update := <-cib.pickerUpdateCh.Get(): - cib.pickerUpdateCh.Load() - cib.mu.Lock() - if cib.closed.HasFired() { - cib.mu.Unlock() + case update := <-b.pickerUpdateCh.Get(): + b.pickerUpdateCh.Load() + b.mu.Lock() + if b.closed.HasFired() { + b.mu.Unlock() return } switch u := update.(type) { case balancer.State: - cib.childState = u - cib.ClientConn.UpdateState(balancer.State{ - ConnectivityState: cib.childState.ConnectivityState, - Picker: newDropPicker(cib.childState, &dropConfigs{ - drops: cib.drops, - requestCounter: cib.requestCounter, - requestCountMax: cib.requestCountMax, - }, cib.loadWrapper), + b.childState = u + b.ClientConn.UpdateState(balancer.State{ + ConnectivityState: b.childState.ConnectivityState, + Picker: newDropPicker(b.childState, &dropConfigs{ + drops: b.drops, + requestCounter: b.requestCounter, + requestCountMax: b.requestCountMax, + }, b.loadWrapper), }) case *dropConfigs: - cib.drops = u.drops - cib.requestCounter = u.requestCounter - if cib.childState.Picker != nil { - cib.ClientConn.UpdateState(balancer.State{ - ConnectivityState: cib.childState.ConnectivityState, - Picker: newDropPicker(cib.childState, u, cib.loadWrapper), + b.drops = u.drops + b.requestCounter = u.requestCounter + if b.childState.Picker != nil { + b.ClientConn.UpdateState(balancer.State{ + ConnectivityState: b.childState.ConnectivityState, + Picker: newDropPicker(b.childState, u, b.loadWrapper), }) } } - cib.mu.Unlock() - case <-cib.closed.Done(): + b.mu.Unlock() + case <-b.closed.Done(): return } } diff --git a/xds/internal/balancer/clusterimpl/picker.go b/xds/internal/balancer/clusterimpl/picker.go index 7a31615510d..a03b89179ee 100644 --- a/xds/internal/balancer/clusterimpl/picker.go +++ b/xds/internal/balancer/clusterimpl/picker.go @@ -24,8 +24,8 @@ import ( "google.golang.org/grpc/connectivity" "google.golang.org/grpc/internal/wrr" "google.golang.org/grpc/status" - "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/load" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/load" ) // NewRandomWRR is used when calculating drops. It's exported so that tests can @@ -75,7 +75,7 @@ type dropPicker struct { drops []*dropper s balancer.State loadStore loadReporter - counter *client.ServiceRequestsCounter + counter *xdsclient.ServiceRequestsCounter countMax uint32 } diff --git a/xds/internal/balancer/edsbalancer/eds.go b/xds/internal/balancer/edsbalancer/eds.go index 21e3f43be74..376d1916891 100644 --- a/xds/internal/balancer/edsbalancer/eds.go +++ b/xds/internal/balancer/edsbalancer/eds.go @@ -35,36 +35,37 @@ import ( "google.golang.org/grpc/internal/grpclog" "google.golang.org/grpc/internal/grpcsync" "google.golang.org/grpc/serviceconfig" - xdsclient "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/load" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/load" ) const edsName = "eds_experimental" -// xdsClientInterface contains only the xds_client methods needed by EDS -// balancer. It's defined so we can override xdsclient.New function in tests. -type xdsClientInterface interface { +// xdsClient contains only the xds_client methods needed by EDS balancer. It's +// defined so we can override xdsclient.New function in tests. +type xdsClient interface { WatchEndpoints(clusterName string, edsCb func(xdsclient.EndpointsUpdate, error)) (cancel func()) ReportLoad(server string) (loadStore *load.Store, cancel func()) - Close() } var ( newEDSBalancer = func(cc balancer.ClientConn, opts balancer.BuildOptions, enqueueState func(priorityType, balancer.State), lw load.PerClusterReporter, logger *grpclog.PrefixLogger) edsBalancerImplInterface { return newEDSBalancerImpl(cc, opts, enqueueState, lw, logger) } - newXDSClient func() (xdsClientInterface, error) + newXDSClient func() (xdsClient, error) ) func init() { - balancer.Register(&edsBalancerBuilder{}) + balancer.Register(edsBB{}) } -type edsBalancerBuilder struct{} +type edsBB struct{} + +var _ balancer.ConfigParser = edsBB{} // Build helps implement the balancer.Builder interface. -func (b *edsBalancerBuilder) Build(cc balancer.ClientConn, opts balancer.BuildOptions) balancer.Balancer { - x := &edsBalancer{ +func (edsBB) Build(cc balancer.ClientConn, opts balancer.BuildOptions) balancer.Balancer { + b := &edsBalancer{ cc: cc, closed: grpcsync.NewEvent(), done: grpcsync.NewEvent(), @@ -74,29 +75,29 @@ func (b *edsBalancerBuilder) Build(cc balancer.ClientConn, opts balancer.BuildOp loadWrapper: loadstore.NewWrapper(), config: &EDSConfig{}, } - x.logger = prefixLogger(x) + b.logger = prefixLogger(b) if newXDSClient != nil { // For tests client, err := newXDSClient() if err != nil { - x.logger.Errorf("xds: failed to create xds-client: %v", err) + b.logger.Errorf("xds: failed to create xds-client: %v", err) return nil } - x.xdsClient = client + b.xdsClient = client } - x.edsImpl = newEDSBalancer(x.cc, opts, x.enqueueChildBalancerState, x.loadWrapper, x.logger) - x.logger.Infof("Created") - go x.run() - return x + b.edsImpl = newEDSBalancer(b.cc, opts, b.enqueueChildBalancerState, b.loadWrapper, b.logger) + b.logger.Infof("Created") + go b.run() + return b } -func (b *edsBalancerBuilder) Name() string { +func (edsBB) Name() string { return edsName } -func (b *edsBalancerBuilder) ParseConfig(c json.RawMessage) (serviceconfig.LoadBalancingConfig, error) { +func (edsBB) ParseConfig(c json.RawMessage) (serviceconfig.LoadBalancingConfig, error) { var cfg EDSConfig if err := json.Unmarshal(c, &cfg); err != nil { return nil, fmt.Errorf("unable to unmarshal balancer config %s into EDSConfig, error: %v", string(c), err) @@ -145,7 +146,7 @@ type edsBalancer struct { xdsClientUpdate chan *edsUpdate childPolicyUpdate *buffer.Unbounded - xdsClient xdsClientInterface + xdsClient xdsClient loadWrapper *loadstore.Wrapper config *EDSConfig // may change when passed a different service config edsImpl edsBalancerImplInterface @@ -162,25 +163,22 @@ type edsBalancer struct { // updates from grpc, xdsClient and load balancer. It synchronizes the // operations that happen inside edsBalancer. It exits when edsBalancer is // closed. -func (x *edsBalancer) run() { +func (b *edsBalancer) run() { for { select { - case update := <-x.grpcUpdate: - x.handleGRPCUpdate(update) - case update := <-x.xdsClientUpdate: - x.handleXDSClientUpdate(update) - case update := <-x.childPolicyUpdate.Get(): - x.childPolicyUpdate.Load() + case update := <-b.grpcUpdate: + b.handleGRPCUpdate(update) + case update := <-b.xdsClientUpdate: + b.handleXDSClientUpdate(update) + case update := <-b.childPolicyUpdate.Get(): + b.childPolicyUpdate.Load() u := update.(*balancerStateWithPriority) - x.edsImpl.updateState(u.priority, u.s) - case <-x.closed.Done(): - x.cancelWatch() - if newXDSClient != nil { - x.xdsClient.Close() - } - x.edsImpl.close() - x.logger.Infof("Shutdown") - x.done.Fire() + b.edsImpl.updateState(u.priority, u.s) + case <-b.closed.Done(): + b.cancelWatch() + b.edsImpl.close() + b.logger.Infof("Shutdown") + b.done.Fire() return } } @@ -199,68 +197,68 @@ func (x *edsBalancer) run() { // watcher should keep watching. // In both cases, the sub-balancers will be closed, and the future picks will // fail. -func (x *edsBalancer) handleErrorFromUpdate(err error, fromParent bool) { - x.logger.Warningf("Received error: %v", err) +func (b *edsBalancer) handleErrorFromUpdate(err error, fromParent bool) { + b.logger.Warningf("Received error: %v", err) if xdsclient.ErrType(err) == xdsclient.ErrorTypeResourceNotFound { if fromParent { // This is an error from the parent ClientConn (can be the parent // CDS balancer), and is a resource-not-found error. This means the // resource (can be either LDS or CDS) was removed. Stop the EDS // watch. - x.cancelWatch() + b.cancelWatch() } - x.edsImpl.handleEDSResponse(xdsclient.EndpointsUpdate{}) + b.edsImpl.handleEDSResponse(xdsclient.EndpointsUpdate{}) } } -func (x *edsBalancer) handleGRPCUpdate(update interface{}) { +func (b *edsBalancer) handleGRPCUpdate(update interface{}) { switch u := update.(type) { case *subConnStateUpdate: - x.edsImpl.handleSubConnStateChange(u.sc, u.state.ConnectivityState) + b.edsImpl.handleSubConnStateChange(u.sc, u.state.ConnectivityState) case *balancer.ClientConnState: - x.logger.Infof("Received update from resolver, balancer config: %+v", pretty.ToJSON(u.BalancerConfig)) + b.logger.Infof("Received update from resolver, balancer config: %+v", pretty.ToJSON(u.BalancerConfig)) cfg, _ := u.BalancerConfig.(*EDSConfig) if cfg == nil { // service config parsing failed. should never happen. return } - if err := x.handleServiceConfigUpdate(cfg); err != nil { - x.logger.Warningf("failed to update xDS client: %v", err) + if err := b.handleServiceConfigUpdate(cfg); err != nil { + b.logger.Warningf("failed to update xDS client: %v", err) } - x.edsImpl.updateServiceRequestsConfig(cfg.ClusterName, cfg.MaxConcurrentRequests) + b.edsImpl.updateServiceRequestsConfig(cfg.ClusterName, cfg.MaxConcurrentRequests) // We will update the edsImpl with the new child policy, if we got a // different one. - if !cmp.Equal(cfg.ChildPolicy, x.config.ChildPolicy, cmpopts.EquateEmpty()) { + if !cmp.Equal(cfg.ChildPolicy, b.config.ChildPolicy, cmpopts.EquateEmpty()) { if cfg.ChildPolicy != nil { - x.edsImpl.handleChildPolicy(cfg.ChildPolicy.Name, cfg.ChildPolicy.Config) + b.edsImpl.handleChildPolicy(cfg.ChildPolicy.Name, cfg.ChildPolicy.Config) } else { - x.edsImpl.handleChildPolicy(roundrobin.Name, nil) + b.edsImpl.handleChildPolicy(roundrobin.Name, nil) } } - x.config = cfg + b.config = cfg case error: - x.handleErrorFromUpdate(u, true) + b.handleErrorFromUpdate(u, true) default: // unreachable path - x.logger.Errorf("wrong update type: %T", update) + b.logger.Errorf("wrong update type: %T", update) } } // handleServiceConfigUpdate applies the service config update, watching a new // EDS service name and restarting LRS stream, as required. -func (x *edsBalancer) handleServiceConfigUpdate(config *EDSConfig) error { +func (b *edsBalancer) handleServiceConfigUpdate(config *EDSConfig) error { var updateLoadClusterAndService bool - if x.clusterName != config.ClusterName { + if b.clusterName != config.ClusterName { updateLoadClusterAndService = true - x.clusterName = config.ClusterName - x.edsImpl.updateClusterName(x.clusterName) + b.clusterName = config.ClusterName + b.edsImpl.updateClusterName(b.clusterName) } - if x.edsServiceName != config.EDSServiceName { + if b.edsServiceName != config.EDSServiceName { updateLoadClusterAndService = true - x.edsServiceName = config.EDSServiceName + b.edsServiceName = config.EDSServiceName } // If EDSServiceName is set, use it to watch EDS. Otherwise, use the cluster @@ -270,14 +268,14 @@ func (x *edsBalancer) handleServiceConfigUpdate(config *EDSConfig) error { newEDSToWatch = config.ClusterName } var restartEDSWatch bool - if x.edsToWatch != newEDSToWatch { + if b.edsToWatch != newEDSToWatch { restartEDSWatch = true - x.edsToWatch = newEDSToWatch + b.edsToWatch = newEDSToWatch } // Restart EDS watch when the eds name has changed. if restartEDSWatch { - x.startEndpointsWatch() + b.startEndpointsWatch() } if updateLoadClusterAndService { @@ -288,13 +286,13 @@ func (x *edsBalancer) handleServiceConfigUpdate(config *EDSConfig) error { // // This is OK for now, because we don't actually expect edsServiceName // to change. Fix this (a bigger change) will happen later. - x.loadWrapper.UpdateClusterAndService(x.clusterName, x.edsServiceName) + b.loadWrapper.UpdateClusterAndService(b.clusterName, b.edsServiceName) } // Restart load reporting when the loadReportServer name has changed. - if !equalStringPointers(x.loadReportServer, config.LrsLoadReportingServerName) { - loadStore := x.startLoadReport(config.LrsLoadReportingServerName) - x.loadWrapper.UpdateLoadStore(loadStore) + if !equalStringPointers(b.loadReportServer, config.LrsLoadReportingServerName) { + loadStore := b.startLoadReport(config.LrsLoadReportingServerName) + b.loadWrapper.UpdateLoadStore(loadStore) } return nil @@ -304,32 +302,32 @@ func (x *edsBalancer) handleServiceConfigUpdate(config *EDSConfig) error { // // This usually means load report needs to be restarted, but this function does // NOT do that. Caller needs to call startLoadReport separately. -func (x *edsBalancer) startEndpointsWatch() { - if x.cancelEndpointsWatch != nil { - x.cancelEndpointsWatch() +func (b *edsBalancer) startEndpointsWatch() { + if b.cancelEndpointsWatch != nil { + b.cancelEndpointsWatch() } - edsToWatch := x.edsToWatch - cancelEDSWatch := x.xdsClient.WatchEndpoints(edsToWatch, func(update xdsclient.EndpointsUpdate, err error) { - x.logger.Infof("Watch update from xds-client %p, content: %+v", x.xdsClient, pretty.ToJSON(update)) - x.handleEDSUpdate(update, err) + edsToWatch := b.edsToWatch + cancelEDSWatch := b.xdsClient.WatchEndpoints(edsToWatch, func(update xdsclient.EndpointsUpdate, err error) { + b.logger.Infof("Watch update from xds-client %p, content: %+v", b.xdsClient, pretty.ToJSON(update)) + b.handleEDSUpdate(update, err) }) - x.logger.Infof("Watch started on resource name %v with xds-client %p", edsToWatch, x.xdsClient) - x.cancelEndpointsWatch = func() { + b.logger.Infof("Watch started on resource name %v with xds-client %p", edsToWatch, b.xdsClient) + b.cancelEndpointsWatch = func() { cancelEDSWatch() - x.logger.Infof("Watch cancelled on resource name %v with xds-client %p", edsToWatch, x.xdsClient) + b.logger.Infof("Watch cancelled on resource name %v with xds-client %p", edsToWatch, b.xdsClient) } } -func (x *edsBalancer) cancelWatch() { - x.loadReportServer = nil - if x.cancelLoadReport != nil { - x.cancelLoadReport() - x.cancelLoadReport = nil +func (b *edsBalancer) cancelWatch() { + b.loadReportServer = nil + if b.cancelLoadReport != nil { + b.cancelLoadReport() + b.cancelLoadReport = nil } - if x.cancelEndpointsWatch != nil { - x.edsToWatch = "" - x.cancelEndpointsWatch() - x.cancelEndpointsWatch = nil + if b.cancelEndpointsWatch != nil { + b.edsToWatch = "" + b.cancelEndpointsWatch() + b.cancelEndpointsWatch = nil } } @@ -339,26 +337,26 @@ func (x *edsBalancer) cancelWatch() { // Caller can cal this when the loadReportServer name changes, but // edsServiceName doesn't (so we only need to restart load reporting, not EDS // watch). -func (x *edsBalancer) startLoadReport(loadReportServer *string) *load.Store { - x.loadReportServer = loadReportServer - if x.cancelLoadReport != nil { - x.cancelLoadReport() - x.cancelLoadReport = nil +func (b *edsBalancer) startLoadReport(loadReportServer *string) *load.Store { + b.loadReportServer = loadReportServer + if b.cancelLoadReport != nil { + b.cancelLoadReport() + b.cancelLoadReport = nil } if loadReportServer == nil { return nil } - ls, cancel := x.xdsClient.ReportLoad(*loadReportServer) - x.cancelLoadReport = cancel + ls, cancel := b.xdsClient.ReportLoad(*loadReportServer) + b.cancelLoadReport = cancel return ls } -func (x *edsBalancer) handleXDSClientUpdate(update *edsUpdate) { +func (b *edsBalancer) handleXDSClientUpdate(update *edsUpdate) { if err := update.err; err != nil { - x.handleErrorFromUpdate(err, false) + b.handleErrorFromUpdate(err, false) return } - x.edsImpl.handleEDSResponse(update.resp) + b.edsImpl.handleEDSResponse(update.resp) } type subConnStateUpdate struct { @@ -366,36 +364,36 @@ type subConnStateUpdate struct { state balancer.SubConnState } -func (x *edsBalancer) UpdateSubConnState(sc balancer.SubConn, state balancer.SubConnState) { +func (b *edsBalancer) UpdateSubConnState(sc balancer.SubConn, state balancer.SubConnState) { update := &subConnStateUpdate{ sc: sc, state: state, } select { - case x.grpcUpdate <- update: - case <-x.closed.Done(): + case b.grpcUpdate <- update: + case <-b.closed.Done(): } } -func (x *edsBalancer) ResolverError(err error) { +func (b *edsBalancer) ResolverError(err error) { select { - case x.grpcUpdate <- err: - case <-x.closed.Done(): + case b.grpcUpdate <- err: + case <-b.closed.Done(): } } -func (x *edsBalancer) UpdateClientConnState(s balancer.ClientConnState) error { - if x.xdsClient == nil { +func (b *edsBalancer) UpdateClientConnState(s balancer.ClientConnState) error { + if b.xdsClient == nil { c := xdsclient.FromResolverState(s.ResolverState) if c == nil { return balancer.ErrBadResolverState } - x.xdsClient = c + b.xdsClient = c } select { - case x.grpcUpdate <- &s: - case <-x.closed.Done(): + case b.grpcUpdate <- &s: + case <-b.closed.Done(): } return nil } @@ -405,10 +403,10 @@ type edsUpdate struct { err error } -func (x *edsBalancer) handleEDSUpdate(resp xdsclient.EndpointsUpdate, err error) { +func (b *edsBalancer) handleEDSUpdate(resp xdsclient.EndpointsUpdate, err error) { select { - case x.xdsClientUpdate <- &edsUpdate{resp: resp, err: err}: - case <-x.closed.Done(): + case b.xdsClientUpdate <- &edsUpdate{resp: resp, err: err}: + case <-b.closed.Done(): } } @@ -417,16 +415,16 @@ type balancerStateWithPriority struct { s balancer.State } -func (x *edsBalancer) enqueueChildBalancerState(p priorityType, s balancer.State) { - x.childPolicyUpdate.Put(&balancerStateWithPriority{ +func (b *edsBalancer) enqueueChildBalancerState(p priorityType, s balancer.State) { + b.childPolicyUpdate.Put(&balancerStateWithPriority{ priority: p, s: s, }) } -func (x *edsBalancer) Close() { - x.closed.Fire() - <-x.done.Done() +func (b *edsBalancer) Close() { + b.closed.Fire() + <-b.done.Done() } // equalStringPointers returns true if diff --git a/xds/internal/balancer/edsbalancer/eds_impl.go b/xds/internal/balancer/edsbalancer/eds_impl.go index 63b75caae8f..db11dec6f2f 100644 --- a/xds/internal/balancer/edsbalancer/eds_impl.go +++ b/xds/internal/balancer/edsbalancer/eds_impl.go @@ -37,9 +37,8 @@ import ( xdsi "google.golang.org/grpc/xds/internal" "google.golang.org/grpc/xds/internal/balancer/balancergroup" "google.golang.org/grpc/xds/internal/balancer/weightedtarget/weightedaggregator" - "google.golang.org/grpc/xds/internal/client" - xdsclient "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/load" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/load" ) // TODO: make this a environment variable? @@ -102,7 +101,7 @@ type edsBalancerImpl struct { dropConfig []xdsclient.OverloadDropConfig drops []*dropper innerState balancer.State // The state of the picker without drop support. - serviceRequestsCounter *client.ServiceRequestsCounter + serviceRequestsCounter *xdsclient.ServiceRequestsCounter serviceRequestCountMax uint32 clusterNameMu sync.Mutex @@ -425,7 +424,7 @@ func (edsImpl *edsBalancerImpl) updateServiceRequestsConfig(serviceName string, edsImpl.pickerMu.Lock() var updatePicker bool if edsImpl.serviceRequestsCounter == nil || edsImpl.serviceRequestsCounter.ServiceName != serviceName { - edsImpl.serviceRequestsCounter = client.GetServiceRequestsCounter(serviceName) + edsImpl.serviceRequestsCounter = xdsclient.GetServiceRequestsCounter(serviceName) updatePicker = true } @@ -540,11 +539,11 @@ type dropPicker struct { drops []*dropper p balancer.Picker loadStore load.PerClusterReporter - counter *client.ServiceRequestsCounter + counter *xdsclient.ServiceRequestsCounter countMax uint32 } -func newDropPicker(p balancer.Picker, drops []*dropper, loadStore load.PerClusterReporter, counter *client.ServiceRequestsCounter, countMax uint32) *dropPicker { +func newDropPicker(p balancer.Picker, drops []*dropper, loadStore load.PerClusterReporter, counter *xdsclient.ServiceRequestsCounter, countMax uint32) *dropPicker { return &dropPicker{ drops: drops, p: p, diff --git a/xds/internal/balancer/edsbalancer/eds_impl_test.go b/xds/internal/balancer/edsbalancer/eds_impl_test.go index 3cfc620a240..ec60dc1b1e6 100644 --- a/xds/internal/balancer/edsbalancer/eds_impl_test.go +++ b/xds/internal/balancer/edsbalancer/eds_impl_test.go @@ -38,10 +38,9 @@ import ( "google.golang.org/grpc/internal/xds/env" xdsinternal "google.golang.org/grpc/xds/internal" "google.golang.org/grpc/xds/internal/balancer/balancergroup" - "google.golang.org/grpc/xds/internal/client" - xdsclient "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/load" "google.golang.org/grpc/xds/internal/testutils" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/load" ) var ( @@ -835,7 +834,7 @@ func (s) TestEDS_LoadReport(t *testing.T) { ) var maxRequestsTemp uint32 = cbMaxRequests edsb.updateServiceRequestsConfig(testServiceName, &maxRequestsTemp) - defer client.ClearCounterForTesting(testServiceName) + defer xdsclient.ClearCounterForTesting(testServiceName) backendToBalancerID := make(map[balancer.SubConn]xdsinternal.LocalityID) diff --git a/xds/internal/balancer/edsbalancer/eds_test.go b/xds/internal/balancer/edsbalancer/eds_test.go index 3fe66098973..679fa321bd1 100644 --- a/xds/internal/balancer/edsbalancer/eds_test.go +++ b/xds/internal/balancer/edsbalancer/eds_test.go @@ -41,11 +41,11 @@ import ( "google.golang.org/grpc/resolver" "google.golang.org/grpc/serviceconfig" "google.golang.org/grpc/xds/internal" - xdsclient "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/load" "google.golang.org/grpc/xds/internal/testutils/fakeclient" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/load" - _ "google.golang.org/grpc/xds/internal/client/v2" // V2 client registration. + _ "google.golang.org/grpc/xds/internal/xdsclient/v2" // V2 client registration. ) const ( @@ -70,10 +70,6 @@ var ( } ) -func init() { - balancer.Register(&edsBalancerBuilder{}) -} - func subConnFromPicker(p balancer.Picker) func() balancer.SubConn { return func() balancer.SubConn { scst, _ := p.Pick(balancer.PickInfo{}) @@ -260,7 +256,7 @@ func waitForNewEDSLB(ctx context.Context, ch *testutils.Channel) (*fakeEDSBalanc func setup(edsLBCh *testutils.Channel) (*fakeclient.Client, func()) { xdsC := fakeclient.NewClientWithName(testBalancerNameFooBar) oldNewXDSClient := newXDSClient - newXDSClient = func() (xdsClientInterface, error) { return xdsC, nil } + newXDSClient = func() (xdsClient, error) { return xdsC, nil } origNewEDSBalancer := newEDSBalancer newEDSBalancer = func(cc balancer.ClientConn, _ balancer.BuildOptions, _ func(priorityType, balancer.State), _ load.PerClusterReporter, _ *grpclog.PrefixLogger) edsBalancerImplInterface { @@ -890,8 +886,7 @@ func (s) TestBalancerConfigParsing(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - b := &edsBalancerBuilder{} - got, err := b.ParseConfig(tt.js) + got, err := edsBB{}.ParseConfig(tt.js) if (err != nil) != tt.wantErr { t.Fatalf("edsBalancerBuilder.ParseConfig() error = %v, wantErr %v", err, tt.wantErr) } diff --git a/xds/internal/balancer/edsbalancer/eds_testutil.go b/xds/internal/balancer/edsbalancer/eds_testutil.go index 5e37cdcb47c..f6d86e950d9 100644 --- a/xds/internal/balancer/edsbalancer/eds_testutil.go +++ b/xds/internal/balancer/edsbalancer/eds_testutil.go @@ -26,7 +26,7 @@ import ( endpointpb "github.com/envoyproxy/go-control-plane/envoy/api/v2/endpoint" typepb "github.com/envoyproxy/go-control-plane/envoy/type" "google.golang.org/grpc/xds/internal" - xdsclient "google.golang.org/grpc/xds/internal/client" + "google.golang.org/grpc/xds/internal/xdsclient" ) // parseEDSRespProtoForTesting parses EDS response, and panic if parsing fails. diff --git a/xds/internal/balancer/edsbalancer/util.go b/xds/internal/balancer/edsbalancer/util.go index 13295042646..fa9ada6c9dd 100644 --- a/xds/internal/balancer/edsbalancer/util.go +++ b/xds/internal/balancer/edsbalancer/util.go @@ -18,7 +18,7 @@ package edsbalancer import ( "google.golang.org/grpc/internal/wrr" - xdsclient "google.golang.org/grpc/xds/internal/client" + "google.golang.org/grpc/xds/internal/xdsclient" ) var newRandomWRR = wrr.NewRandom diff --git a/xds/internal/balancer/edsbalancer/util_test.go b/xds/internal/balancer/edsbalancer/util_test.go index b94905d4988..2d08091fdfb 100644 --- a/xds/internal/balancer/edsbalancer/util_test.go +++ b/xds/internal/balancer/edsbalancer/util_test.go @@ -21,8 +21,8 @@ package edsbalancer import ( "testing" - xdsclient "google.golang.org/grpc/xds/internal/client" "google.golang.org/grpc/xds/internal/testutils" + "google.golang.org/grpc/xds/internal/xdsclient" ) func init() { diff --git a/xds/internal/balancer/edsbalancer/xds_lrs_test.go b/xds/internal/balancer/edsbalancer/xds_lrs_test.go index 8b7aab65766..d5b40dd98d3 100644 --- a/xds/internal/balancer/edsbalancer/xds_lrs_test.go +++ b/xds/internal/balancer/edsbalancer/xds_lrs_test.go @@ -34,7 +34,7 @@ import ( func (s) TestXDSLoadReporting(t *testing.T) { xdsC := fakeclient.NewClient() oldNewXDSClient := newXDSClient - newXDSClient = func() (xdsClientInterface, error) { return xdsC, nil } + newXDSClient = func() (xdsClient, error) { return xdsC, nil } defer func() { newXDSClient = oldNewXDSClient }() builder := balancer.Get(edsName) diff --git a/xds/internal/balancer/edsbalancer/xds_old.go b/xds/internal/balancer/edsbalancer/xds_old.go index 6729e6801f1..99621facf1f 100644 --- a/xds/internal/balancer/edsbalancer/xds_old.go +++ b/xds/internal/balancer/edsbalancer/xds_old.go @@ -32,15 +32,15 @@ import "google.golang.org/grpc/balancer" const xdsName = "xds_experimental" func init() { - balancer.Register(&xdsBalancerBuilder{}) + balancer.Register(xdsBB{}) } -// xdsBalancerBuilder register edsBalancerBuilder (now with name -// "eds_experimental") under the old name "xds_experimental". -type xdsBalancerBuilder struct { - edsBalancerBuilder +// xdsBB registers edsBB (now with name "eds_experimental") under the old name +// "xds_experimental". +type xdsBB struct { + edsBB } -func (b *xdsBalancerBuilder) Name() string { +func (xdsBB) Name() string { return xdsName } diff --git a/xds/internal/balancer/loadstore/load_store_wrapper.go b/xds/internal/balancer/loadstore/load_store_wrapper.go index 88fa344118c..8ce958d71ca 100644 --- a/xds/internal/balancer/loadstore/load_store_wrapper.go +++ b/xds/internal/balancer/loadstore/load_store_wrapper.go @@ -22,7 +22,7 @@ package loadstore import ( "sync" - "google.golang.org/grpc/xds/internal/client/load" + "google.golang.org/grpc/xds/internal/xdsclient/load" ) // NewWrapper creates a Wrapper. diff --git a/xds/internal/balancer/lrs/balancer.go b/xds/internal/balancer/lrs/balancer.go index 5b044f48034..9590cc3b59e 100644 --- a/xds/internal/balancer/lrs/balancer.go +++ b/xds/internal/balancer/lrs/balancer.go @@ -28,22 +28,22 @@ import ( "google.golang.org/grpc/internal/pretty" "google.golang.org/grpc/serviceconfig" "google.golang.org/grpc/xds/internal/balancer/loadstore" - xdsclient "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/load" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/load" ) func init() { - balancer.Register(&lrsBB{}) + balancer.Register(lrsBB{}) } -var newXDSClient func() (xdsClientInterface, error) +var newXDSClient func() (xdsClient, error) // Name is the name of the LRS balancer. const Name = "lrs_experimental" type lrsBB struct{} -func (l *lrsBB) Build(cc balancer.ClientConn, opts balancer.BuildOptions) balancer.Balancer { +func (lrsBB) Build(cc balancer.ClientConn, opts balancer.BuildOptions) balancer.Balancer { b := &lrsBalancer{ cc: cc, buildOpts: opts, @@ -58,17 +58,17 @@ func (l *lrsBB) Build(cc balancer.ClientConn, opts balancer.BuildOptions) balanc b.logger.Errorf("failed to create xds-client: %v", err) return nil } - b.client = newXDSClientWrapper(client) + b.xdsClient = newXDSClientWrapper(client) } return b } -func (l *lrsBB) Name() string { +func (lrsBB) Name() string { return Name } -func (l *lrsBB) ParseConfig(c json.RawMessage) (serviceconfig.LoadBalancingConfig, error) { +func (lrsBB) ParseConfig(c json.RawMessage) (serviceconfig.LoadBalancingConfig, error) { return parseConfig(c) } @@ -76,8 +76,8 @@ type lrsBalancer struct { cc balancer.ClientConn buildOpts balancer.BuildOptions - logger *grpclog.PrefixLogger - client *xdsClientWrapper + logger *grpclog.PrefixLogger + xdsClient *xdsClientWrapper config *LBConfig lb balancer.Balancer // The sub balancer. @@ -90,18 +90,18 @@ func (b *lrsBalancer) UpdateClientConnState(s balancer.ClientConnState) error { return fmt.Errorf("unexpected balancer config with type: %T", s.BalancerConfig) } - if b.client == nil { + if b.xdsClient == nil { c := xdsclient.FromResolverState(s.ResolverState) if c == nil { return balancer.ErrBadResolverState } - b.client = newXDSClientWrapper(c) + b.xdsClient = newXDSClientWrapper(c) } // Update load reporting config or xds client. This needs to be done before // updating the child policy because we need the loadStore from the updated // client to be passed to the ccWrapper. - if err := b.client.update(newConfig); err != nil { + if err := b.xdsClient.update(newConfig); err != nil { return err } @@ -118,7 +118,7 @@ func (b *lrsBalancer) UpdateClientConnState(s balancer.ClientConnState) error { if err != nil { return fmt.Errorf("failed to marshal LocalityID: %#v", newConfig.Locality) } - ccWrapper := newCCWrapper(b.cc, b.client.loadStore(), lidJSON) + ccWrapper := newCCWrapper(b.cc, b.xdsClient.loadStore(), lidJSON) b.lb = bb.Build(ccWrapper, b.buildOpts) } b.config = newConfig @@ -147,7 +147,7 @@ func (b *lrsBalancer) Close() { b.lb.Close() b.lb = nil } - b.client.close() + b.xdsClient.close() } type ccWrapper struct { @@ -169,15 +169,14 @@ func (ccw *ccWrapper) UpdateState(s balancer.State) { ccw.ClientConn.UpdateState(s) } -// xdsClientInterface contains only the xds_client methods needed by LRS +// xdsClient contains only the xds_client methods needed by LRS // balancer. It's defined so we can override xdsclient in tests. -type xdsClientInterface interface { +type xdsClient interface { ReportLoad(server string) (*load.Store, func()) - Close() } type xdsClientWrapper struct { - c xdsClientInterface + c xdsClient cancelLoadReport func() clusterName string edsServiceName string @@ -187,7 +186,7 @@ type xdsClientWrapper struct { loadWrapper *loadstore.Wrapper } -func newXDSClientWrapper(c xdsClientInterface) *xdsClientWrapper { +func newXDSClientWrapper(c xdsClient) *xdsClientWrapper { return &xdsClientWrapper{ c: c, loadWrapper: loadstore.NewWrapper(), @@ -256,7 +255,4 @@ func (w *xdsClientWrapper) close() { w.cancelLoadReport() w.cancelLoadReport = nil } - if newXDSClient != nil { - w.c.Close() - } } diff --git a/xds/internal/balancer/lrs/balancer_test.go b/xds/internal/balancer/lrs/balancer_test.go index f91937385a9..9ffa2894dad 100644 --- a/xds/internal/balancer/lrs/balancer_test.go +++ b/xds/internal/balancer/lrs/balancer_test.go @@ -56,7 +56,7 @@ var ( func TestLoadReporting(t *testing.T) { xdsC := fakeclient.NewClient() oldNewXDSClient := newXDSClient - newXDSClient = func() (xdsClientInterface, error) { return xdsC, nil } + newXDSClient = func() (xdsClient, error) { return xdsC, nil } defer func() { newXDSClient = oldNewXDSClient }() builder := balancer.Get(Name) diff --git a/xds/internal/httpfilter/fault/fault_test.go b/xds/internal/httpfilter/fault/fault_test.go index c132e912f92..1c6db707c6a 100644 --- a/xds/internal/httpfilter/fault/fault_test.go +++ b/xds/internal/httpfilter/fault/fault_test.go @@ -55,9 +55,9 @@ import ( tpb "github.com/envoyproxy/go-control-plane/envoy/type/v3" testpb "google.golang.org/grpc/test/grpc_testing" - _ "google.golang.org/grpc/xds/internal/balancer" // Register the balancers. - _ "google.golang.org/grpc/xds/internal/client/v3" // Register the v3 xDS API client. - _ "google.golang.org/grpc/xds/internal/resolver" // Register the xds_resolver. + _ "google.golang.org/grpc/xds/internal/balancer" // Register the balancers. + _ "google.golang.org/grpc/xds/internal/resolver" // Register the xds_resolver. + _ "google.golang.org/grpc/xds/internal/xdsclient/v3" // Register the v3 xDS API client. ) type s struct { diff --git a/xds/internal/resolver/matcher.go b/xds/internal/resolver/matcher.go index e329944e1db..42a843deeca 100644 --- a/xds/internal/resolver/matcher.go +++ b/xds/internal/resolver/matcher.go @@ -27,7 +27,7 @@ import ( iresolver "google.golang.org/grpc/internal/resolver" "google.golang.org/grpc/internal/xds/matcher" "google.golang.org/grpc/metadata" - xdsclient "google.golang.org/grpc/xds/internal/client" + "google.golang.org/grpc/xds/internal/xdsclient" ) func routeToMatcher(r *xdsclient.Route) (*compositeMatcher, error) { diff --git a/xds/internal/resolver/serviceconfig.go b/xds/internal/resolver/serviceconfig.go index 49ee8970d7d..31941fdc022 100644 --- a/xds/internal/resolver/serviceconfig.go +++ b/xds/internal/resolver/serviceconfig.go @@ -31,9 +31,9 @@ import ( "google.golang.org/grpc/internal/xds/env" "google.golang.org/grpc/status" "google.golang.org/grpc/xds/internal/balancer/clustermanager" - xdsclient "google.golang.org/grpc/xds/internal/client" "google.golang.org/grpc/xds/internal/httpfilter" "google.golang.org/grpc/xds/internal/httpfilter/router" + "google.golang.org/grpc/xds/internal/xdsclient" ) const ( diff --git a/xds/internal/resolver/watch_service.go b/xds/internal/resolver/watch_service.go index f29fb32832e..591cc383393 100644 --- a/xds/internal/resolver/watch_service.go +++ b/xds/internal/resolver/watch_service.go @@ -26,7 +26,7 @@ import ( "google.golang.org/grpc/internal/grpclog" "google.golang.org/grpc/internal/pretty" - xdsclient "google.golang.org/grpc/xds/internal/client" + "google.golang.org/grpc/xds/internal/xdsclient" ) // serviceUpdate contains information received from the LDS/RDS responses which @@ -54,7 +54,7 @@ type ldsConfig struct { // Note that during race (e.g. an xDS response is received while the user is // calling cancel()), there's a small window where the callback can be called // after the watcher is canceled. The caller needs to handle this case. -func watchService(c xdsClientInterface, serviceName string, cb func(serviceUpdate, error), logger *grpclog.PrefixLogger) (cancel func()) { +func watchService(c xdsClient, serviceName string, cb func(serviceUpdate, error), logger *grpclog.PrefixLogger) (cancel func()) { w := &serviceUpdateWatcher{ logger: logger, c: c, @@ -70,7 +70,7 @@ func watchService(c xdsClientInterface, serviceName string, cb func(serviceUpdat // callback at the right time. type serviceUpdateWatcher struct { logger *grpclog.PrefixLogger - c xdsClientInterface + c xdsClient serviceName string ldsCancel func() serviceCb func(serviceUpdate, error) diff --git a/xds/internal/resolver/watch_service_test.go b/xds/internal/resolver/watch_service_test.go index 421e5345a9d..31c45bf3977 100644 --- a/xds/internal/resolver/watch_service_test.go +++ b/xds/internal/resolver/watch_service_test.go @@ -29,8 +29,8 @@ import ( "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" "google.golang.org/grpc/internal/testutils" - xdsclient "google.golang.org/grpc/xds/internal/client" "google.golang.org/grpc/xds/internal/testutils/fakeclient" + "google.golang.org/grpc/xds/internal/xdsclient" "google.golang.org/protobuf/proto" ) diff --git a/xds/internal/resolver/xds_resolver.go b/xds/internal/resolver/xds_resolver.go index 41e3899c285..a6c2dd2e438 100644 --- a/xds/internal/resolver/xds_resolver.go +++ b/xds/internal/resolver/xds_resolver.go @@ -28,10 +28,10 @@ import ( "google.golang.org/grpc/internal/grpcsync" "google.golang.org/grpc/internal/pretty" "google.golang.org/grpc/resolver" - "google.golang.org/grpc/xds/internal/client/bootstrap" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/bootstrap" iresolver "google.golang.org/grpc/internal/resolver" - xdsclient "google.golang.org/grpc/xds/internal/client" ) const xdsScheme = "xds" @@ -41,26 +41,26 @@ const xdsScheme = "xds" // the same time. func NewBuilder(config []byte) (resolver.Builder, error) { return &xdsResolverBuilder{ - newXDSClient: func() (xdsClientInterface, error) { + newXDSClient: func() (xdsClient, error) { return xdsclient.NewClientWithBootstrapContents(config) }, }, nil } // For overriding in unittests. -var newXDSClient = func() (xdsClientInterface, error) { return xdsclient.New() } +var newXDSClient = func() (xdsClient, error) { return xdsclient.New() } func init() { resolver.Register(&xdsResolverBuilder{}) } type xdsResolverBuilder struct { - newXDSClient func() (xdsClientInterface, error) + newXDSClient func() (xdsClient, error) } // Build helps implement the resolver.Builder interface. // -// The xds bootstrap process is performed (and a new xds client is built) every +// The xds bootstrap process is performed (and a new xds xdsClient is built) every // time an xds resolver is built. func (b *xdsResolverBuilder) Build(t resolver.Target, cc resolver.ClientConn, opts resolver.BuildOptions) (resolver.Resolver, error) { r := &xdsResolver{ @@ -78,11 +78,11 @@ func (b *xdsResolverBuilder) Build(t resolver.Target, cc resolver.ClientConn, op newXDSClient = b.newXDSClient } - client, err := newXDSClient() + xdsClient, err := newXDSClient() if err != nil { return nil, fmt.Errorf("xds: failed to create xds-client: %v", err) } - r.client = client + r.xdsClient = xdsClient // If xds credentials were specified by the user, but bootstrap configs do // not contain any certificate provider configuration, it is better to fail @@ -96,18 +96,18 @@ func (b *xdsResolverBuilder) Build(t resolver.Target, cc resolver.ClientConn, op creds = opts.CredsBundle.TransportCredentials() } if xc, ok := creds.(interface{ UsesXDS() bool }); ok && xc.UsesXDS() { - bc := client.BootstrapConfig() + bc := xdsClient.BootstrapConfig() if len(bc.CertProviderConfigs) == 0 { return nil, errors.New("xds: xdsCreds specified but certificate_providers config missing in bootstrap file") } } // Register a watch on the xdsClient for the user's dial target. - cancelWatch := watchService(r.client, r.target.Endpoint, r.handleServiceUpdate, r.logger) - r.logger.Infof("Watch started on resource name %v with xds-client %p", r.target.Endpoint, r.client) + cancelWatch := watchService(r.xdsClient, r.target.Endpoint, r.handleServiceUpdate, r.logger) + r.logger.Infof("Watch started on resource name %v with xds-client %p", r.target.Endpoint, r.xdsClient) r.cancelWatch = func() { cancelWatch() - r.logger.Infof("Watch cancel on resource name %v with xds-client %p", r.target.Endpoint, r.client) + r.logger.Infof("Watch cancel on resource name %v with xds-client %p", r.target.Endpoint, r.xdsClient) } go r.run() @@ -119,9 +119,9 @@ func (*xdsResolverBuilder) Scheme() string { return xdsScheme } -// xdsClientInterface contains methods from xdsClient.Client which are used by +// xdsClient contains methods from xdsClient.XdsClient which are used by // the resolver. This will be faked out in unittests. -type xdsClientInterface interface { +type xdsClient interface { WatchListener(serviceName string, cb func(xdsclient.ListenerUpdate, error)) func() WatchRouteConfig(routeName string, cb func(xdsclient.RouteConfigUpdate, error)) func() BootstrapConfig() *bootstrap.Config @@ -149,7 +149,7 @@ type xdsResolver struct { logger *grpclog.PrefixLogger // The underlying xdsClient which performs all xDS requests and responses. - client xdsClientInterface + xdsClient xdsClient // A channel for the watch API callback to write service updates on to. The // updates are read by the run goroutine and passed on to the ClientConn. updateCh chan suWithError @@ -190,7 +190,7 @@ func (r *xdsResolver) sendNewServiceConfig(cs *configSelector) bool { r.cc.ReportError(err) return false } - r.logger.Infof("Received update on resource %v from xds-client %p, generated service config: %v", r.target.Endpoint, r.client, pretty.FormatJSON(sc)) + r.logger.Infof("Received update on resource %v from xds-client %p, generated service config: %v", r.target.Endpoint, r.xdsClient, pretty.FormatJSON(sc)) // Send the update to the ClientConn. state := iresolver.SetConfigSelector(resolver.State{ @@ -198,9 +198,9 @@ func (r *xdsResolver) sendNewServiceConfig(cs *configSelector) bool { }, cs) // Include the xds client for the LB policies to use. For unit tests, - // r.client may not be a full *xdsclient.Client, but it will always be in - // production. - if c, ok := r.client.(*xdsclient.Client); ok { + // r.xdsClient may not be a full *xdsclient.Client, but it will always be + // in production. + if c, ok := r.xdsClient.(*xdsclient.Client); ok { state = xdsclient.SetClient(state, c) } r.cc.UpdateState(state) @@ -216,7 +216,7 @@ func (r *xdsResolver) run() { return case update := <-r.updateCh: if update.err != nil { - r.logger.Warningf("Watch error on resource %v from xds-client %p, %v", r.target.Endpoint, r.client, update.err) + r.logger.Warningf("Watch error on resource %v from xds-client %p, %v", r.target.Endpoint, r.xdsClient, update.err) if xdsclient.ErrType(update.err) == xdsclient.ErrorTypeResourceNotFound { // If error is resource-not-found, it means the LDS // resource was removed. Ultimately send an empty service @@ -244,7 +244,7 @@ func (r *xdsResolver) run() { // Create the config selector for this update. cs, err := r.newConfigSelector(update.su) if err != nil { - r.logger.Warningf("Error parsing update on resource %v from xds-client %p: %v", r.target.Endpoint, r.client, err) + r.logger.Warningf("Error parsing update on resource %v from xds-client %p: %v", r.target.Endpoint, r.xdsClient, err) r.cc.ReportError(err) continue } @@ -287,7 +287,7 @@ func (*xdsResolver) ResolveNow(o resolver.ResolveNowOptions) {} // Close closes the resolver, and also closes the underlying xdsClient. func (r *xdsResolver) Close() { r.cancelWatch() - r.client.Close() + r.xdsClient.Close() r.closed.Fire() r.logger.Infof("Shutdown") } diff --git a/xds/internal/resolver/xds_resolver_test.go b/xds/internal/resolver/xds_resolver_test.go index eca561f369c..d3a66595a35 100644 --- a/xds/internal/resolver/xds_resolver_test.go +++ b/xds/internal/resolver/xds_resolver_test.go @@ -44,13 +44,12 @@ import ( "google.golang.org/grpc/status" _ "google.golang.org/grpc/xds/internal/balancer/cdsbalancer" // To parse LB config "google.golang.org/grpc/xds/internal/balancer/clustermanager" - "google.golang.org/grpc/xds/internal/client" - xdsclient "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/bootstrap" "google.golang.org/grpc/xds/internal/httpfilter" "google.golang.org/grpc/xds/internal/httpfilter/router" xdstestutils "google.golang.org/grpc/xds/internal/testutils" "google.golang.org/grpc/xds/internal/testutils/fakeclient" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/bootstrap" ) const ( @@ -115,19 +114,19 @@ func newTestClientConn() *testClientConn { func (s) TestResolverBuilder(t *testing.T) { tests := []struct { name string - xdsClientFunc func() (xdsClientInterface, error) + xdsClientFunc func() (xdsClient, error) wantErr bool }{ { name: "simple-good", - xdsClientFunc: func() (xdsClientInterface, error) { + xdsClientFunc: func() (xdsClient, error) { return fakeclient.NewClient(), nil }, wantErr: false, }, { name: "newXDSClient-throws-error", - xdsClientFunc: func() (xdsClientInterface, error) { + xdsClientFunc: func() (xdsClient, error) { return nil, errors.New("newXDSClient-throws-error") }, wantErr: true, @@ -168,7 +167,7 @@ func (s) TestResolverBuilder_xdsCredsBootstrapMismatch(t *testing.T) { // Fake out the xdsClient creation process by providing a fake, which does // not have any certificate provider configuration. oldClientMaker := newXDSClient - newXDSClient = func() (xdsClientInterface, error) { + newXDSClient = func() (xdsClient, error) { fc := fakeclient.NewClient() fc.SetBootstrapConfig(&bootstrap.Config{}) return fc, nil @@ -195,7 +194,7 @@ func (s) TestResolverBuilder_xdsCredsBootstrapMismatch(t *testing.T) { } type setupOpts struct { - xdsClientFunc func() (xdsClientInterface, error) + xdsClientFunc func() (xdsClient, error) } func testSetup(t *testing.T, opts setupOpts) (*xdsResolver, *testClientConn, func()) { @@ -255,7 +254,7 @@ func waitForWatchRouteConfig(ctx context.Context, t *testing.T, xdsC *fakeclient func (s) TestXDSResolverWatchCallbackAfterClose(t *testing.T) { xdsC := fakeclient.NewClient() xdsR, tcc, cancel := testSetup(t, setupOpts{ - xdsClientFunc: func() (xdsClientInterface, error) { return xdsC, nil }, + xdsClientFunc: func() (xdsClient, error) { return xdsC, nil }, }) defer cancel() @@ -272,7 +271,7 @@ func (s) TestXDSResolverWatchCallbackAfterClose(t *testing.T) { VirtualHosts: []*xdsclient.VirtualHost{ { Domains: []string{targetStr}, - Routes: []*client.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{cluster: {Weight: 1}}}}, + Routes: []*xdsclient.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{cluster: {Weight: 1}}}}, }, }, }, nil) @@ -287,7 +286,7 @@ func (s) TestXDSResolverWatchCallbackAfterClose(t *testing.T) { func (s) TestXDSResolverBadServiceUpdate(t *testing.T) { xdsC := fakeclient.NewClient() xdsR, tcc, cancel := testSetup(t, setupOpts{ - xdsClientFunc: func() (xdsClientInterface, error) { return xdsC, nil }, + xdsClientFunc: func() (xdsClient, error) { return xdsC, nil }, }) defer xdsR.Close() defer cancel() @@ -313,7 +312,7 @@ func (s) TestXDSResolverBadServiceUpdate(t *testing.T) { func (s) TestXDSResolverGoodServiceUpdate(t *testing.T) { xdsC := fakeclient.NewClient() xdsR, tcc, cancel := testSetup(t, setupOpts{ - xdsClientFunc: func() (xdsClientInterface, error) { return xdsC, nil }, + xdsClientFunc: func() (xdsClient, error) { return xdsC, nil }, }) defer xdsR.Close() defer cancel() @@ -331,7 +330,7 @@ func (s) TestXDSResolverGoodServiceUpdate(t *testing.T) { wantClusters map[string]bool }{ { - routes: []*client.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{"test-cluster-1": {Weight: 1}}}}, + routes: []*xdsclient.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{"test-cluster-1": {Weight: 1}}}}, wantJSON: `{"loadBalancingConfig":[{ "xds_cluster_manager_experimental":{ "children":{ @@ -343,7 +342,7 @@ func (s) TestXDSResolverGoodServiceUpdate(t *testing.T) { wantClusters: map[string]bool{"test-cluster-1": true}, }, { - routes: []*client.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{ + routes: []*xdsclient.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{ "cluster_1": {Weight: 75}, "cluster_2": {Weight: 25}, }}}, @@ -367,7 +366,7 @@ func (s) TestXDSResolverGoodServiceUpdate(t *testing.T) { wantClusters: map[string]bool{"cluster_1": true, "cluster_2": true}, }, { - routes: []*client.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{ + routes: []*xdsclient.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{ "cluster_1": {Weight: 75}, "cluster_2": {Weight: 25}, }}}, @@ -447,7 +446,7 @@ func (s) TestXDSResolverGoodServiceUpdate(t *testing.T) { func (s) TestXDSResolverRemovedWithRPCs(t *testing.T) { xdsC := fakeclient.NewClient() xdsR, tcc, cancel := testSetup(t, setupOpts{ - xdsClientFunc: func() (xdsClientInterface, error) { return xdsC, nil }, + xdsClientFunc: func() (xdsClient, error) { return xdsC, nil }, }) defer cancel() defer xdsR.Close() @@ -464,7 +463,7 @@ func (s) TestXDSResolverRemovedWithRPCs(t *testing.T) { VirtualHosts: []*xdsclient.VirtualHost{ { Domains: []string{targetStr}, - Routes: []*client.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{"test-cluster-1": {Weight: 1}}}}, + Routes: []*xdsclient.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{"test-cluster-1": {Weight: 1}}}}, }, }, }, nil) @@ -507,7 +506,7 @@ func (s) TestXDSResolverRemovedWithRPCs(t *testing.T) { func (s) TestXDSResolverRemovedResource(t *testing.T) { xdsC := fakeclient.NewClient() xdsR, tcc, cancel := testSetup(t, setupOpts{ - xdsClientFunc: func() (xdsClientInterface, error) { return xdsC, nil }, + xdsClientFunc: func() (xdsClient, error) { return xdsC, nil }, }) defer cancel() defer xdsR.Close() @@ -524,7 +523,7 @@ func (s) TestXDSResolverRemovedResource(t *testing.T) { VirtualHosts: []*xdsclient.VirtualHost{ { Domains: []string{targetStr}, - Routes: []*client.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{"test-cluster-1": {Weight: 1}}}}, + Routes: []*xdsclient.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{"test-cluster-1": {Weight: 1}}}}, }, }, }, nil) @@ -615,7 +614,7 @@ func (s) TestXDSResolverRemovedResource(t *testing.T) { func (s) TestXDSResolverWRR(t *testing.T) { xdsC := fakeclient.NewClient() xdsR, tcc, cancel := testSetup(t, setupOpts{ - xdsClientFunc: func() (xdsClientInterface, error) { return xdsC, nil }, + xdsClientFunc: func() (xdsClient, error) { return xdsC, nil }, }) defer xdsR.Close() defer cancel() @@ -635,7 +634,7 @@ func (s) TestXDSResolverWRR(t *testing.T) { VirtualHosts: []*xdsclient.VirtualHost{ { Domains: []string{targetStr}, - Routes: []*client.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{ + Routes: []*xdsclient.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{ "A": {Weight: 5}, "B": {Weight: 10}, }}}, @@ -676,7 +675,7 @@ func (s) TestXDSResolverMaxStreamDuration(t *testing.T) { defer func(old bool) { env.TimeoutSupport = old }(env.TimeoutSupport) xdsC := fakeclient.NewClient() xdsR, tcc, cancel := testSetup(t, setupOpts{ - xdsClientFunc: func() (xdsClientInterface, error) { return xdsC, nil }, + xdsClientFunc: func() (xdsClient, error) { return xdsC, nil }, }) defer xdsR.Close() defer cancel() @@ -696,7 +695,7 @@ func (s) TestXDSResolverMaxStreamDuration(t *testing.T) { VirtualHosts: []*xdsclient.VirtualHost{ { Domains: []string{targetStr}, - Routes: []*client.Route{{ + Routes: []*xdsclient.Route{{ Prefix: newStringP("/foo"), WeightedClusters: map[string]xdsclient.WeightedCluster{"A": {Weight: 1}}, MaxStreamDuration: newDurationP(5 * time.Second), @@ -779,7 +778,7 @@ func (s) TestXDSResolverMaxStreamDuration(t *testing.T) { func (s) TestXDSResolverDelayedOnCommitted(t *testing.T) { xdsC := fakeclient.NewClient() xdsR, tcc, cancel := testSetup(t, setupOpts{ - xdsClientFunc: func() (xdsClientInterface, error) { return xdsC, nil }, + xdsClientFunc: func() (xdsClient, error) { return xdsC, nil }, }) defer xdsR.Close() defer cancel() @@ -796,7 +795,7 @@ func (s) TestXDSResolverDelayedOnCommitted(t *testing.T) { VirtualHosts: []*xdsclient.VirtualHost{ { Domains: []string{targetStr}, - Routes: []*client.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{"test-cluster-1": {Weight: 1}}}}, + Routes: []*xdsclient.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{"test-cluster-1": {Weight: 1}}}}, }, }, }, nil) @@ -846,7 +845,7 @@ func (s) TestXDSResolverDelayedOnCommitted(t *testing.T) { VirtualHosts: []*xdsclient.VirtualHost{ { Domains: []string{targetStr}, - Routes: []*client.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{"NEW": {Weight: 1}}}}, + Routes: []*xdsclient.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{"NEW": {Weight: 1}}}}, }, }, }, nil) @@ -856,7 +855,7 @@ func (s) TestXDSResolverDelayedOnCommitted(t *testing.T) { VirtualHosts: []*xdsclient.VirtualHost{ { Domains: []string{targetStr}, - Routes: []*client.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{"NEW": {Weight: 1}}}}, + Routes: []*xdsclient.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{"NEW": {Weight: 1}}}}, }, }, }, nil) @@ -895,7 +894,7 @@ func (s) TestXDSResolverDelayedOnCommitted(t *testing.T) { VirtualHosts: []*xdsclient.VirtualHost{ { Domains: []string{targetStr}, - Routes: []*client.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{"NEW": {Weight: 1}}}}, + Routes: []*xdsclient.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{"NEW": {Weight: 1}}}}, }, }, }, nil) @@ -928,7 +927,7 @@ func (s) TestXDSResolverDelayedOnCommitted(t *testing.T) { func (s) TestXDSResolverGoodUpdateAfterError(t *testing.T) { xdsC := fakeclient.NewClient() xdsR, tcc, cancel := testSetup(t, setupOpts{ - xdsClientFunc: func() (xdsClientInterface, error) { return xdsC, nil }, + xdsClientFunc: func() (xdsClient, error) { return xdsC, nil }, }) defer xdsR.Close() defer cancel() @@ -954,7 +953,7 @@ func (s) TestXDSResolverGoodUpdateAfterError(t *testing.T) { VirtualHosts: []*xdsclient.VirtualHost{ { Domains: []string{targetStr}, - Routes: []*client.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{cluster: {Weight: 1}}}}, + Routes: []*xdsclient.Route{{Prefix: newStringP(""), WeightedClusters: map[string]xdsclient.WeightedCluster{cluster: {Weight: 1}}}}, }, }, }, nil) @@ -982,7 +981,7 @@ func (s) TestXDSResolverGoodUpdateAfterError(t *testing.T) { func (s) TestXDSResolverResourceNotFoundError(t *testing.T) { xdsC := fakeclient.NewClient() xdsR, tcc, cancel := testSetup(t, setupOpts{ - xdsClientFunc: func() (xdsClientInterface, error) { return xdsC, nil }, + xdsClientFunc: func() (xdsClient, error) { return xdsC, nil }, }) defer xdsR.Close() defer cancel() @@ -1028,7 +1027,7 @@ func (s) TestXDSResolverResourceNotFoundError(t *testing.T) { func (s) TestXDSResolverMultipleLDSUpdates(t *testing.T) { xdsC := fakeclient.NewClient() xdsR, tcc, cancel := testSetup(t, setupOpts{ - xdsClientFunc: func() (xdsClientInterface, error) { return xdsC, nil }, + xdsClientFunc: func() (xdsClient, error) { return xdsC, nil }, }) defer xdsR.Close() defer cancel() @@ -1203,7 +1202,7 @@ func (s) TestXDSResolverHTTPFilters(t *testing.T) { t.Run(tc.name, func(t *testing.T) { xdsC := fakeclient.NewClient() xdsR, tcc, cancel := testSetup(t, setupOpts{ - xdsClientFunc: func() (xdsClientInterface, error) { return xdsC, nil }, + xdsClientFunc: func() (xdsClient, error) { return xdsC, nil }, }) defer xdsR.Close() defer cancel() @@ -1229,7 +1228,7 @@ func (s) TestXDSResolverHTTPFilters(t *testing.T) { VirtualHosts: []*xdsclient.VirtualHost{ { Domains: []string{targetStr}, - Routes: []*client.Route{{ + Routes: []*xdsclient.Route{{ Prefix: newStringP("1"), WeightedClusters: map[string]xdsclient.WeightedCluster{ "A": {Weight: 1}, "B": {Weight: 1}, diff --git a/xds/internal/server/conn_wrapper.go b/xds/internal/server/conn_wrapper.go index a02d75b2144..0618a6cd4a4 100644 --- a/xds/internal/server/conn_wrapper.go +++ b/xds/internal/server/conn_wrapper.go @@ -27,7 +27,7 @@ import ( "google.golang.org/grpc/credentials/tls/certprovider" xdsinternal "google.golang.org/grpc/internal/credentials/xds" - xdsclient "google.golang.org/grpc/xds/internal/client" + "google.golang.org/grpc/xds/internal/xdsclient" ) // connWrapper is a thin wrapper around a net.Conn returned by Accept(). It diff --git a/xds/internal/server/listener_wrapper.go b/xds/internal/server/listener_wrapper.go index 17f31f28f57..7e5f7071a80 100644 --- a/xds/internal/server/listener_wrapper.go +++ b/xds/internal/server/listener_wrapper.go @@ -31,8 +31,8 @@ import ( internalbackoff "google.golang.org/grpc/internal/backoff" internalgrpclog "google.golang.org/grpc/internal/grpclog" "google.golang.org/grpc/internal/grpcsync" - xdsclient "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/bootstrap" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/bootstrap" ) var ( diff --git a/xds/internal/server/listener_wrapper_test.go b/xds/internal/server/listener_wrapper_test.go index b22f647a93c..848793ccdb7 100644 --- a/xds/internal/server/listener_wrapper_test.go +++ b/xds/internal/server/listener_wrapper_test.go @@ -34,8 +34,8 @@ import ( wrapperspb "github.com/golang/protobuf/ptypes/wrappers" "google.golang.org/grpc/internal/grpctest" "google.golang.org/grpc/internal/testutils" - xdsclient "google.golang.org/grpc/xds/internal/client" "google.golang.org/grpc/xds/internal/testutils/fakeclient" + "google.golang.org/grpc/xds/internal/xdsclient" ) const ( diff --git a/xds/internal/testutils/fakeclient/client.go b/xds/internal/testutils/fakeclient/client.go index f85f0ecbf3f..ab791d77206 100644 --- a/xds/internal/testutils/fakeclient/client.go +++ b/xds/internal/testutils/fakeclient/client.go @@ -23,9 +23,9 @@ import ( "context" "google.golang.org/grpc/internal/testutils" - xdsclient "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/bootstrap" - "google.golang.org/grpc/xds/internal/client/load" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/bootstrap" + "google.golang.org/grpc/xds/internal/xdsclient/load" ) // Client is a fake implementation of an xds client. It exposes a bunch of @@ -41,7 +41,6 @@ type Client struct { cdsCancelCh *testutils.Channel edsCancelCh *testutils.Channel loadReportCh *testutils.Channel - closeCh *testutils.Channel loadStore *load.Store bootstrapCfg *bootstrap.Config @@ -52,18 +51,18 @@ type Client struct { } // WatchListener registers a LDS watch. -func (xdsC *Client) WatchListener(serviceName string, callback func(xdsclient.ListenerUpdate, error)) func() { - xdsC.ldsCb = callback - xdsC.ldsWatchCh.Send(serviceName) +func (c *Client) WatchListener(serviceName string, callback func(xdsclient.ListenerUpdate, error)) func() { + c.ldsCb = callback + c.ldsWatchCh.Send(serviceName) return func() { - xdsC.ldsCancelCh.Send(nil) + c.ldsCancelCh.Send(nil) } } // WaitForWatchListener waits for WatchCluster to be invoked on this client and // returns the serviceName being watched. -func (xdsC *Client) WaitForWatchListener(ctx context.Context) (string, error) { - val, err := xdsC.ldsWatchCh.Receive(ctx) +func (c *Client) WaitForWatchListener(ctx context.Context) (string, error) { + val, err := c.ldsWatchCh.Receive(ctx) if err != nil { return "", err } @@ -74,30 +73,30 @@ func (xdsC *Client) WaitForWatchListener(ctx context.Context) (string, error) { // // Not thread safe with WatchListener. Only call this after // WaitForWatchListener. -func (xdsC *Client) InvokeWatchListenerCallback(update xdsclient.ListenerUpdate, err error) { - xdsC.ldsCb(update, err) +func (c *Client) InvokeWatchListenerCallback(update xdsclient.ListenerUpdate, err error) { + c.ldsCb(update, err) } // WaitForCancelListenerWatch waits for a LDS watch to be cancelled and returns // context.DeadlineExceeded otherwise. -func (xdsC *Client) WaitForCancelListenerWatch(ctx context.Context) error { - _, err := xdsC.ldsCancelCh.Receive(ctx) +func (c *Client) WaitForCancelListenerWatch(ctx context.Context) error { + _, err := c.ldsCancelCh.Receive(ctx) return err } // WatchRouteConfig registers a RDS watch. -func (xdsC *Client) WatchRouteConfig(routeName string, callback func(xdsclient.RouteConfigUpdate, error)) func() { - xdsC.rdsCb = callback - xdsC.rdsWatchCh.Send(routeName) +func (c *Client) WatchRouteConfig(routeName string, callback func(xdsclient.RouteConfigUpdate, error)) func() { + c.rdsCb = callback + c.rdsWatchCh.Send(routeName) return func() { - xdsC.rdsCancelCh.Send(nil) + c.rdsCancelCh.Send(nil) } } // WaitForWatchRouteConfig waits for WatchCluster to be invoked on this client and // returns the routeName being watched. -func (xdsC *Client) WaitForWatchRouteConfig(ctx context.Context) (string, error) { - val, err := xdsC.rdsWatchCh.Receive(ctx) +func (c *Client) WaitForWatchRouteConfig(ctx context.Context) (string, error) { + val, err := c.rdsWatchCh.Receive(ctx) if err != nil { return "", err } @@ -108,33 +107,33 @@ func (xdsC *Client) WaitForWatchRouteConfig(ctx context.Context) (string, error) // // Not thread safe with WatchRouteConfig. Only call this after // WaitForWatchRouteConfig. -func (xdsC *Client) InvokeWatchRouteConfigCallback(update xdsclient.RouteConfigUpdate, err error) { - xdsC.rdsCb(update, err) +func (c *Client) InvokeWatchRouteConfigCallback(update xdsclient.RouteConfigUpdate, err error) { + c.rdsCb(update, err) } // WaitForCancelRouteConfigWatch waits for a RDS watch to be cancelled and returns // context.DeadlineExceeded otherwise. -func (xdsC *Client) WaitForCancelRouteConfigWatch(ctx context.Context) error { - _, err := xdsC.rdsCancelCh.Receive(ctx) +func (c *Client) WaitForCancelRouteConfigWatch(ctx context.Context) error { + _, err := c.rdsCancelCh.Receive(ctx) return err } // WatchCluster registers a CDS watch. -func (xdsC *Client) WatchCluster(clusterName string, callback func(xdsclient.ClusterUpdate, error)) func() { +func (c *Client) WatchCluster(clusterName string, callback func(xdsclient.ClusterUpdate, error)) func() { // Due to the tree like structure of aggregate clusters, there can be multiple callbacks persisted for each cluster // node. However, the client doesn't care about the parent child relationship between the nodes, only that it invokes // the right callback for a particular cluster. - xdsC.cdsCbs[clusterName] = callback - xdsC.cdsWatchCh.Send(clusterName) + c.cdsCbs[clusterName] = callback + c.cdsWatchCh.Send(clusterName) return func() { - xdsC.cdsCancelCh.Send(clusterName) + c.cdsCancelCh.Send(clusterName) } } // WaitForWatchCluster waits for WatchCluster to be invoked on this client and // returns the clusterName being watched. -func (xdsC *Client) WaitForWatchCluster(ctx context.Context) (string, error) { - val, err := xdsC.cdsWatchCh.Receive(ctx) +func (c *Client) WaitForWatchCluster(ctx context.Context) (string, error) { + val, err := c.cdsWatchCh.Receive(ctx) if err != nil { return "", err } @@ -145,25 +144,25 @@ func (xdsC *Client) WaitForWatchCluster(ctx context.Context) (string, error) { // // Not thread safe with WatchCluster. Only call this after // WaitForWatchCluster. -func (xdsC *Client) InvokeWatchClusterCallback(update xdsclient.ClusterUpdate, err error) { +func (c *Client) InvokeWatchClusterCallback(update xdsclient.ClusterUpdate, err error) { // Keeps functionality with previous usage of this, if single callback call that callback. - if len(xdsC.cdsCbs) == 1 { + if len(c.cdsCbs) == 1 { var clusterName string - for cluster := range xdsC.cdsCbs { + for cluster := range c.cdsCbs { clusterName = cluster } - xdsC.cdsCbs[clusterName](update, err) + c.cdsCbs[clusterName](update, err) } else { // Have what callback you call with the update determined by the service name in the ClusterUpdate. Left up to the // caller to make sure the cluster update matches with a persisted callback. - xdsC.cdsCbs[update.ClusterName](update, err) + c.cdsCbs[update.ClusterName](update, err) } } // WaitForCancelClusterWatch waits for a CDS watch to be cancelled and returns // context.DeadlineExceeded otherwise. -func (xdsC *Client) WaitForCancelClusterWatch(ctx context.Context) (string, error) { - clusterNameReceived, err := xdsC.cdsCancelCh.Receive(ctx) +func (c *Client) WaitForCancelClusterWatch(ctx context.Context) (string, error) { + clusterNameReceived, err := c.cdsCancelCh.Receive(ctx) if err != nil { return "", err } @@ -171,18 +170,18 @@ func (xdsC *Client) WaitForCancelClusterWatch(ctx context.Context) (string, erro } // WatchEndpoints registers an EDS watch for provided clusterName. -func (xdsC *Client) WatchEndpoints(clusterName string, callback func(xdsclient.EndpointsUpdate, error)) (cancel func()) { - xdsC.edsCb = callback - xdsC.edsWatchCh.Send(clusterName) +func (c *Client) WatchEndpoints(clusterName string, callback func(xdsclient.EndpointsUpdate, error)) (cancel func()) { + c.edsCb = callback + c.edsWatchCh.Send(clusterName) return func() { - xdsC.edsCancelCh.Send(nil) + c.edsCancelCh.Send(nil) } } // WaitForWatchEDS waits for WatchEndpoints to be invoked on this client and // returns the clusterName being watched. -func (xdsC *Client) WaitForWatchEDS(ctx context.Context) (string, error) { - val, err := xdsC.edsWatchCh.Receive(ctx) +func (c *Client) WaitForWatchEDS(ctx context.Context) (string, error) { + val, err := c.edsWatchCh.Receive(ctx) if err != nil { return "", err } @@ -193,14 +192,14 @@ func (xdsC *Client) WaitForWatchEDS(ctx context.Context) (string, error) { // // Not thread safe with WatchEndpoints. Only call this after // WaitForWatchEDS. -func (xdsC *Client) InvokeWatchEDSCallback(update xdsclient.EndpointsUpdate, err error) { - xdsC.edsCb(update, err) +func (c *Client) InvokeWatchEDSCallback(update xdsclient.EndpointsUpdate, err error) { + c.edsCb(update, err) } // WaitForCancelEDSWatch waits for a EDS watch to be cancelled and returns // context.DeadlineExceeded otherwise. -func (xdsC *Client) WaitForCancelEDSWatch(ctx context.Context) error { - _, err := xdsC.edsCancelCh.Receive(ctx) +func (c *Client) WaitForCancelEDSWatch(ctx context.Context) error { + _, err := c.edsCancelCh.Receive(ctx) return err } @@ -211,48 +210,39 @@ type ReportLoadArgs struct { } // ReportLoad starts reporting load about clusterName to server. -func (xdsC *Client) ReportLoad(server string) (loadStore *load.Store, cancel func()) { - xdsC.loadReportCh.Send(ReportLoadArgs{Server: server}) - return xdsC.loadStore, func() {} +func (c *Client) ReportLoad(server string) (loadStore *load.Store, cancel func()) { + c.loadReportCh.Send(ReportLoadArgs{Server: server}) + return c.loadStore, func() {} } // LoadStore returns the underlying load data store. -func (xdsC *Client) LoadStore() *load.Store { - return xdsC.loadStore +func (c *Client) LoadStore() *load.Store { + return c.loadStore } // WaitForReportLoad waits for ReportLoad to be invoked on this client and // returns the arguments passed to it. -func (xdsC *Client) WaitForReportLoad(ctx context.Context) (ReportLoadArgs, error) { - val, err := xdsC.loadReportCh.Receive(ctx) +func (c *Client) WaitForReportLoad(ctx context.Context) (ReportLoadArgs, error) { + val, err := c.loadReportCh.Receive(ctx) return val.(ReportLoadArgs), err } -// Close closes the xds client. -func (xdsC *Client) Close() { - xdsC.closeCh.Send(nil) -} - -// WaitForClose waits for Close to be invoked on this client and returns -// context.DeadlineExceeded otherwise. -func (xdsC *Client) WaitForClose(ctx context.Context) error { - _, err := xdsC.closeCh.Receive(ctx) - return err -} +// Close is a nop. +func (c *Client) Close() {} // BootstrapConfig returns the bootstrap config. -func (xdsC *Client) BootstrapConfig() *bootstrap.Config { - return xdsC.bootstrapCfg +func (c *Client) BootstrapConfig() *bootstrap.Config { + return c.bootstrapCfg } // SetBootstrapConfig updates the bootstrap config. -func (xdsC *Client) SetBootstrapConfig(cfg *bootstrap.Config) { - xdsC.bootstrapCfg = cfg +func (c *Client) SetBootstrapConfig(cfg *bootstrap.Config) { + c.bootstrapCfg = cfg } // Name returns the name of the xds client. -func (xdsC *Client) Name() string { - return xdsC.name +func (c *Client) Name() string { + return c.name } // NewClient returns a new fake xds client. @@ -275,7 +265,6 @@ func NewClientWithName(name string) *Client { cdsCancelCh: testutils.NewChannelWithSize(10), edsCancelCh: testutils.NewChannel(), loadReportCh: testutils.NewChannel(), - closeCh: testutils.NewChannel(), loadStore: load.NewStore(), cdsCbs: make(map[string]func(xdsclient.ClusterUpdate, error)), } diff --git a/xds/internal/client/attributes.go b/xds/internal/xdsclient/attributes.go similarity index 98% rename from xds/internal/client/attributes.go rename to xds/internal/xdsclient/attributes.go index 50b98824529..99060177e1e 100644 --- a/xds/internal/client/attributes.go +++ b/xds/internal/xdsclient/attributes.go @@ -15,7 +15,7 @@ * */ -package client +package xdsclient import "google.golang.org/grpc/resolver" diff --git a/xds/internal/client/bootstrap/bootstrap.go b/xds/internal/xdsclient/bootstrap/bootstrap.go similarity index 100% rename from xds/internal/client/bootstrap/bootstrap.go rename to xds/internal/xdsclient/bootstrap/bootstrap.go diff --git a/xds/internal/client/bootstrap/bootstrap_test.go b/xds/internal/xdsclient/bootstrap/bootstrap_test.go similarity index 100% rename from xds/internal/client/bootstrap/bootstrap_test.go rename to xds/internal/xdsclient/bootstrap/bootstrap_test.go diff --git a/xds/internal/client/bootstrap/logging.go b/xds/internal/xdsclient/bootstrap/logging.go similarity index 100% rename from xds/internal/client/bootstrap/logging.go rename to xds/internal/xdsclient/bootstrap/logging.go diff --git a/xds/internal/client/callback.go b/xds/internal/xdsclient/callback.go similarity index 99% rename from xds/internal/client/callback.go rename to xds/internal/xdsclient/callback.go index ac6f0151a5f..64b7d6794c4 100644 --- a/xds/internal/client/callback.go +++ b/xds/internal/xdsclient/callback.go @@ -16,7 +16,7 @@ * */ -package client +package xdsclient import "google.golang.org/grpc/internal/pretty" diff --git a/xds/internal/client/cds_test.go b/xds/internal/xdsclient/cds_test.go similarity index 99% rename from xds/internal/client/cds_test.go rename to xds/internal/xdsclient/cds_test.go index 82b92372afc..83b9071ad13 100644 --- a/xds/internal/client/cds_test.go +++ b/xds/internal/xdsclient/cds_test.go @@ -18,7 +18,7 @@ * */ -package client +package xdsclient import ( "regexp" diff --git a/xds/internal/client/client.go b/xds/internal/xdsclient/client.go similarity index 98% rename from xds/internal/client/client.go rename to xds/internal/xdsclient/client.go index 4ed1c3a5833..ac832f205d5 100644 --- a/xds/internal/client/client.go +++ b/xds/internal/xdsclient/client.go @@ -16,9 +16,9 @@ * */ -// Package client implements a full fledged gRPC client for the xDS API used by -// the xds resolver and balancer implementations. -package client +// Package xdsclient implements a full fledged gRPC client for the xDS API used +// by the xds resolver and balancer implementations. +package xdsclient import ( "context" @@ -34,8 +34,8 @@ import ( "google.golang.org/protobuf/types/known/anypb" "google.golang.org/grpc/internal/xds/matcher" - "google.golang.org/grpc/xds/internal/client/load" "google.golang.org/grpc/xds/internal/httpfilter" + "google.golang.org/grpc/xds/internal/xdsclient/load" "google.golang.org/grpc" "google.golang.org/grpc/internal/backoff" @@ -44,8 +44,8 @@ import ( "google.golang.org/grpc/internal/grpcsync" "google.golang.org/grpc/keepalive" "google.golang.org/grpc/xds/internal" - "google.golang.org/grpc/xds/internal/client/bootstrap" "google.golang.org/grpc/xds/internal/version" + "google.golang.org/grpc/xds/internal/xdsclient/bootstrap" ) var ( diff --git a/xds/internal/client/client_test.go b/xds/internal/xdsclient/client_test.go similarity index 99% rename from xds/internal/client/client_test.go rename to xds/internal/xdsclient/client_test.go index d57bc20e2c2..c1d4b38e576 100644 --- a/xds/internal/client/client_test.go +++ b/xds/internal/xdsclient/client_test.go @@ -18,7 +18,7 @@ * */ -package client +package xdsclient import ( "context" @@ -34,9 +34,9 @@ import ( "google.golang.org/grpc/internal/grpcsync" "google.golang.org/grpc/internal/grpctest" "google.golang.org/grpc/internal/testutils" - "google.golang.org/grpc/xds/internal/client/bootstrap" xdstestutils "google.golang.org/grpc/xds/internal/testutils" "google.golang.org/grpc/xds/internal/version" + "google.golang.org/grpc/xds/internal/xdsclient/bootstrap" "google.golang.org/protobuf/testing/protocmp" ) diff --git a/xds/internal/client/dump.go b/xds/internal/xdsclient/dump.go similarity index 99% rename from xds/internal/client/dump.go rename to xds/internal/xdsclient/dump.go index 3fd18f6103b..db9b474f370 100644 --- a/xds/internal/client/dump.go +++ b/xds/internal/xdsclient/dump.go @@ -16,7 +16,7 @@ * */ -package client +package xdsclient import anypb "github.com/golang/protobuf/ptypes/any" diff --git a/xds/internal/client/eds_test.go b/xds/internal/xdsclient/eds_test.go similarity index 99% rename from xds/internal/client/eds_test.go rename to xds/internal/xdsclient/eds_test.go index 467f25269cd..ebd26a40f95 100644 --- a/xds/internal/client/eds_test.go +++ b/xds/internal/xdsclient/eds_test.go @@ -18,7 +18,7 @@ * */ -package client +package xdsclient import ( "fmt" diff --git a/xds/internal/client/errors.go b/xds/internal/xdsclient/errors.go similarity index 98% rename from xds/internal/client/errors.go rename to xds/internal/xdsclient/errors.go index 34ae2738db0..4d6cdaaf9b4 100644 --- a/xds/internal/client/errors.go +++ b/xds/internal/xdsclient/errors.go @@ -16,7 +16,7 @@ * */ -package client +package xdsclient import "fmt" diff --git a/xds/internal/client/filter_chain.go b/xds/internal/xdsclient/filter_chain.go similarity index 99% rename from xds/internal/client/filter_chain.go rename to xds/internal/xdsclient/filter_chain.go index 66d26d03b63..7303ebd3ce7 100644 --- a/xds/internal/client/filter_chain.go +++ b/xds/internal/xdsclient/filter_chain.go @@ -16,7 +16,7 @@ * */ -package client +package xdsclient import ( "errors" diff --git a/xds/internal/client/filter_chain_test.go b/xds/internal/xdsclient/filter_chain_test.go similarity index 99% rename from xds/internal/client/filter_chain_test.go rename to xds/internal/xdsclient/filter_chain_test.go index c68e2228676..25390b7f924 100644 --- a/xds/internal/client/filter_chain_test.go +++ b/xds/internal/xdsclient/filter_chain_test.go @@ -18,7 +18,7 @@ * */ -package client +package xdsclient import ( "fmt" diff --git a/xds/internal/client/lds_test.go b/xds/internal/xdsclient/lds_test.go similarity index 99% rename from xds/internal/client/lds_test.go rename to xds/internal/xdsclient/lds_test.go index ad9af4c885a..1667698bd57 100644 --- a/xds/internal/client/lds_test.go +++ b/xds/internal/xdsclient/lds_test.go @@ -18,7 +18,7 @@ * */ -package client +package xdsclient import ( "fmt" diff --git a/xds/internal/client/load/reporter.go b/xds/internal/xdsclient/load/reporter.go similarity index 100% rename from xds/internal/client/load/reporter.go rename to xds/internal/xdsclient/load/reporter.go diff --git a/xds/internal/client/load/store.go b/xds/internal/xdsclient/load/store.go similarity index 100% rename from xds/internal/client/load/store.go rename to xds/internal/xdsclient/load/store.go diff --git a/xds/internal/client/load/store_test.go b/xds/internal/xdsclient/load/store_test.go similarity index 100% rename from xds/internal/client/load/store_test.go rename to xds/internal/xdsclient/load/store_test.go diff --git a/xds/internal/client/loadreport.go b/xds/internal/xdsclient/loadreport.go similarity index 98% rename from xds/internal/client/loadreport.go rename to xds/internal/xdsclient/loadreport.go index be42a6e0c38..32a71dada7f 100644 --- a/xds/internal/client/loadreport.go +++ b/xds/internal/xdsclient/loadreport.go @@ -15,13 +15,13 @@ * limitations under the License. */ -package client +package xdsclient import ( "context" "google.golang.org/grpc" - "google.golang.org/grpc/xds/internal/client/load" + "google.golang.org/grpc/xds/internal/xdsclient/load" ) // ReportLoad starts an load reporting stream to the given server. If the server diff --git a/xds/internal/client/logging.go b/xds/internal/xdsclient/logging.go similarity index 98% rename from xds/internal/client/logging.go rename to xds/internal/xdsclient/logging.go index bff3fb1d3df..e28ea0d0410 100644 --- a/xds/internal/client/logging.go +++ b/xds/internal/xdsclient/logging.go @@ -16,7 +16,7 @@ * */ -package client +package xdsclient import ( "fmt" diff --git a/xds/internal/client/rds_test.go b/xds/internal/xdsclient/rds_test.go similarity index 99% rename from xds/internal/client/rds_test.go rename to xds/internal/xdsclient/rds_test.go index 33bcc2ad13f..660a2f29d21 100644 --- a/xds/internal/client/rds_test.go +++ b/xds/internal/xdsclient/rds_test.go @@ -18,7 +18,7 @@ * */ -package client +package xdsclient import ( "fmt" diff --git a/xds/internal/client/requests_counter.go b/xds/internal/xdsclient/requests_counter.go similarity index 99% rename from xds/internal/client/requests_counter.go rename to xds/internal/xdsclient/requests_counter.go index f033e192099..dacbc8fadb6 100644 --- a/xds/internal/client/requests_counter.go +++ b/xds/internal/xdsclient/requests_counter.go @@ -16,7 +16,7 @@ * */ -package client +package xdsclient import ( "fmt" diff --git a/xds/internal/client/requests_counter_test.go b/xds/internal/xdsclient/requests_counter_test.go similarity index 99% rename from xds/internal/client/requests_counter_test.go rename to xds/internal/xdsclient/requests_counter_test.go index 30892fc747a..f444e8f163e 100644 --- a/xds/internal/client/requests_counter_test.go +++ b/xds/internal/xdsclient/requests_counter_test.go @@ -18,7 +18,7 @@ * */ -package client +package xdsclient import ( "sync" diff --git a/xds/internal/client/singleton.go b/xds/internal/xdsclient/singleton.go similarity index 98% rename from xds/internal/client/singleton.go rename to xds/internal/xdsclient/singleton.go index 41dd16e26af..8d0e10f2c31 100644 --- a/xds/internal/client/singleton.go +++ b/xds/internal/xdsclient/singleton.go @@ -16,7 +16,7 @@ * */ -package client +package xdsclient import ( "bytes" @@ -25,7 +25,7 @@ import ( "sync" "time" - "google.golang.org/grpc/xds/internal/client/bootstrap" + "google.golang.org/grpc/xds/internal/xdsclient/bootstrap" ) const defaultWatchExpiryTimeout = 15 * time.Second diff --git a/xds/internal/client/tests/README.md b/xds/internal/xdsclient/tests/README.md similarity index 100% rename from xds/internal/client/tests/README.md rename to xds/internal/xdsclient/tests/README.md diff --git a/xds/internal/client/tests/client_test.go b/xds/internal/xdsclient/tests/client_test.go similarity index 93% rename from xds/internal/client/tests/client_test.go rename to xds/internal/xdsclient/tests/client_test.go index 755f0e05ea4..26c64bacd03 100644 --- a/xds/internal/client/tests/client_test.go +++ b/xds/internal/xdsclient/tests/client_test.go @@ -27,11 +27,11 @@ import ( "google.golang.org/grpc" "google.golang.org/grpc/credentials/insecure" "google.golang.org/grpc/internal/grpctest" - xdsclient "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/bootstrap" - _ "google.golang.org/grpc/xds/internal/client/v2" // Register the v2 API client. "google.golang.org/grpc/xds/internal/testutils" "google.golang.org/grpc/xds/internal/version" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/bootstrap" + _ "google.golang.org/grpc/xds/internal/xdsclient/v2" // Register the v2 API client. ) type s struct { diff --git a/xds/internal/client/tests/dump_test.go b/xds/internal/xdsclient/tests/dump_test.go similarity index 99% rename from xds/internal/client/tests/dump_test.go rename to xds/internal/xdsclient/tests/dump_test.go index 815850973e3..541f5901c12 100644 --- a/xds/internal/client/tests/dump_test.go +++ b/xds/internal/xdsclient/tests/dump_test.go @@ -39,9 +39,9 @@ import ( "google.golang.org/grpc" "google.golang.org/grpc/credentials/insecure" "google.golang.org/grpc/internal/testutils" - xdsclient "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/bootstrap" xdstestutils "google.golang.org/grpc/xds/internal/testutils" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/bootstrap" ) const defaultTestWatchExpiryTimeout = 500 * time.Millisecond diff --git a/xds/internal/client/tests/loadreport_test.go b/xds/internal/xdsclient/tests/loadreport_test.go similarity index 94% rename from xds/internal/client/tests/loadreport_test.go rename to xds/internal/xdsclient/tests/loadreport_test.go index b1ec3729477..1815f8a0ab4 100644 --- a/xds/internal/client/tests/loadreport_test.go +++ b/xds/internal/xdsclient/tests/loadreport_test.go @@ -34,13 +34,13 @@ import ( "google.golang.org/grpc/codes" "google.golang.org/grpc/credentials/insecure" "google.golang.org/grpc/status" - "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/bootstrap" "google.golang.org/grpc/xds/internal/testutils/fakeserver" "google.golang.org/grpc/xds/internal/version" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/bootstrap" "google.golang.org/protobuf/testing/protocmp" - _ "google.golang.org/grpc/xds/internal/client/v2" // Register the v2 xDS API client. + _ "google.golang.org/grpc/xds/internal/xdsclient/v2" // Register the v2 xDS API client. ) const ( @@ -56,7 +56,7 @@ func (s) TestLRSClient(t *testing.T) { } defer sCleanup() - xdsC, err := client.NewWithConfigForTesting(&bootstrap.Config{ + xdsC, err := xdsclient.NewWithConfigForTesting(&bootstrap.Config{ BalancerName: fs.Address, Creds: grpc.WithTransportCredentials(insecure.NewCredentials()), NodeProto: &v2corepb.Node{}, diff --git a/xds/internal/client/transport_helper.go b/xds/internal/xdsclient/transport_helper.go similarity index 99% rename from xds/internal/client/transport_helper.go rename to xds/internal/xdsclient/transport_helper.go index 671e5b3220f..1e3caa606d1 100644 --- a/xds/internal/client/transport_helper.go +++ b/xds/internal/xdsclient/transport_helper.go @@ -16,7 +16,7 @@ * */ -package client +package xdsclient import ( "context" @@ -24,7 +24,7 @@ import ( "time" "github.com/golang/protobuf/proto" - "google.golang.org/grpc/xds/internal/client/load" + "google.golang.org/grpc/xds/internal/xdsclient/load" "google.golang.org/grpc" "google.golang.org/grpc/internal/buffer" diff --git a/xds/internal/client/v2/ack_test.go b/xds/internal/xdsclient/v2/ack_test.go similarity index 99% rename from xds/internal/client/v2/ack_test.go rename to xds/internal/xdsclient/v2/ack_test.go index 53c8cef189d..1c41cd9d1ad 100644 --- a/xds/internal/client/v2/ack_test.go +++ b/xds/internal/xdsclient/v2/ack_test.go @@ -33,9 +33,9 @@ import ( "google.golang.org/grpc" "google.golang.org/grpc/codes" "google.golang.org/grpc/internal/testutils" - xdsclient "google.golang.org/grpc/xds/internal/client" "google.golang.org/grpc/xds/internal/testutils/fakeserver" "google.golang.org/grpc/xds/internal/version" + "google.golang.org/grpc/xds/internal/xdsclient" ) const ( diff --git a/xds/internal/client/v2/cds_test.go b/xds/internal/xdsclient/v2/cds_test.go similarity index 99% rename from xds/internal/client/v2/cds_test.go rename to xds/internal/xdsclient/v2/cds_test.go index ba7f627b25f..da473846093 100644 --- a/xds/internal/client/v2/cds_test.go +++ b/xds/internal/xdsclient/v2/cds_test.go @@ -28,8 +28,8 @@ import ( corepb "github.com/envoyproxy/go-control-plane/envoy/api/v2/core" anypb "github.com/golang/protobuf/ptypes/any" "google.golang.org/grpc/internal/testutils" - xdsclient "google.golang.org/grpc/xds/internal/client" "google.golang.org/grpc/xds/internal/version" + "google.golang.org/grpc/xds/internal/xdsclient" ) const ( diff --git a/xds/internal/client/v2/client.go b/xds/internal/xdsclient/v2/client.go similarity index 99% rename from xds/internal/client/v2/client.go rename to xds/internal/xdsclient/v2/client.go index b91482d13cf..311621f0405 100644 --- a/xds/internal/client/v2/client.go +++ b/xds/internal/xdsclient/v2/client.go @@ -28,8 +28,8 @@ import ( "google.golang.org/grpc/codes" "google.golang.org/grpc/internal/grpclog" "google.golang.org/grpc/internal/pretty" - xdsclient "google.golang.org/grpc/xds/internal/client" "google.golang.org/grpc/xds/internal/version" + "google.golang.org/grpc/xds/internal/xdsclient" v2xdspb "github.com/envoyproxy/go-control-plane/envoy/api/v2" v2corepb "github.com/envoyproxy/go-control-plane/envoy/api/v2/core" diff --git a/xds/internal/client/v2/client_test.go b/xds/internal/xdsclient/v2/client_test.go similarity index 99% rename from xds/internal/client/v2/client_test.go rename to xds/internal/xdsclient/v2/client_test.go index 371375f3ee5..efa228a8c6e 100644 --- a/xds/internal/client/v2/client_test.go +++ b/xds/internal/xdsclient/v2/client_test.go @@ -37,9 +37,9 @@ import ( "google.golang.org/grpc/internal/testutils" "google.golang.org/grpc/resolver" "google.golang.org/grpc/resolver/manual" - xdsclient "google.golang.org/grpc/xds/internal/client" "google.golang.org/grpc/xds/internal/testutils/fakeserver" "google.golang.org/grpc/xds/internal/version" + "google.golang.org/grpc/xds/internal/xdsclient" "google.golang.org/protobuf/testing/protocmp" xdspb "github.com/envoyproxy/go-control-plane/envoy/api/v2" diff --git a/xds/internal/client/v2/eds_test.go b/xds/internal/xdsclient/v2/eds_test.go similarity index 99% rename from xds/internal/client/v2/eds_test.go rename to xds/internal/xdsclient/v2/eds_test.go index 08e75d37301..7338ec80a5e 100644 --- a/xds/internal/client/v2/eds_test.go +++ b/xds/internal/xdsclient/v2/eds_test.go @@ -28,9 +28,9 @@ import ( anypb "github.com/golang/protobuf/ptypes/any" "google.golang.org/grpc/internal/testutils" "google.golang.org/grpc/xds/internal" - xdsclient "google.golang.org/grpc/xds/internal/client" xtestutils "google.golang.org/grpc/xds/internal/testutils" "google.golang.org/grpc/xds/internal/version" + "google.golang.org/grpc/xds/internal/xdsclient" ) var ( diff --git a/xds/internal/client/v2/lds_test.go b/xds/internal/xdsclient/v2/lds_test.go similarity index 99% rename from xds/internal/client/v2/lds_test.go rename to xds/internal/xdsclient/v2/lds_test.go index 22fa35d5e51..e6f1d8f1cf0 100644 --- a/xds/internal/client/v2/lds_test.go +++ b/xds/internal/xdsclient/v2/lds_test.go @@ -26,7 +26,7 @@ import ( v2xdspb "github.com/envoyproxy/go-control-plane/envoy/api/v2" - xdsclient "google.golang.org/grpc/xds/internal/client" + "google.golang.org/grpc/xds/internal/xdsclient" ) // TestLDSHandleResponse starts a fake xDS server, makes a ClientConn to it, diff --git a/xds/internal/client/v2/loadreport.go b/xds/internal/xdsclient/v2/loadreport.go similarity index 98% rename from xds/internal/client/v2/loadreport.go rename to xds/internal/xdsclient/v2/loadreport.go index 17ea8c8d4c4..77db5eb9d8d 100644 --- a/xds/internal/client/v2/loadreport.go +++ b/xds/internal/xdsclient/v2/loadreport.go @@ -27,7 +27,7 @@ import ( "github.com/golang/protobuf/proto" "github.com/golang/protobuf/ptypes" "google.golang.org/grpc/internal/pretty" - "google.golang.org/grpc/xds/internal/client/load" + "google.golang.org/grpc/xds/internal/xdsclient/load" v2corepb "github.com/envoyproxy/go-control-plane/envoy/api/v2/core" v2endpointpb "github.com/envoyproxy/go-control-plane/envoy/api/v2/endpoint" diff --git a/xds/internal/client/v2/rds_test.go b/xds/internal/xdsclient/v2/rds_test.go similarity index 99% rename from xds/internal/client/v2/rds_test.go rename to xds/internal/xdsclient/v2/rds_test.go index 12495428bf9..745308c4e5b 100644 --- a/xds/internal/client/v2/rds_test.go +++ b/xds/internal/xdsclient/v2/rds_test.go @@ -27,8 +27,8 @@ import ( xdspb "github.com/envoyproxy/go-control-plane/envoy/api/v2" - xdsclient "google.golang.org/grpc/xds/internal/client" "google.golang.org/grpc/xds/internal/testutils/fakeserver" + "google.golang.org/grpc/xds/internal/xdsclient" ) // doLDS makes a LDS watch, and waits for the response and ack to finish. diff --git a/xds/internal/client/v3/client.go b/xds/internal/xdsclient/v3/client.go similarity index 99% rename from xds/internal/client/v3/client.go rename to xds/internal/xdsclient/v3/client.go index 200da2ac7d7..be8ff7720d8 100644 --- a/xds/internal/client/v3/client.go +++ b/xds/internal/xdsclient/v3/client.go @@ -29,8 +29,8 @@ import ( "google.golang.org/grpc/codes" "google.golang.org/grpc/internal/grpclog" "google.golang.org/grpc/internal/pretty" - xdsclient "google.golang.org/grpc/xds/internal/client" "google.golang.org/grpc/xds/internal/version" + "google.golang.org/grpc/xds/internal/xdsclient" v3corepb "github.com/envoyproxy/go-control-plane/envoy/config/core/v3" v3adsgrpc "github.com/envoyproxy/go-control-plane/envoy/service/discovery/v3" diff --git a/xds/internal/client/v3/loadreport.go b/xds/internal/xdsclient/v3/loadreport.go similarity index 98% rename from xds/internal/client/v3/loadreport.go rename to xds/internal/xdsclient/v3/loadreport.go index 1de0ccf5750..147751baab0 100644 --- a/xds/internal/client/v3/loadreport.go +++ b/xds/internal/xdsclient/v3/loadreport.go @@ -27,7 +27,7 @@ import ( "github.com/golang/protobuf/proto" "github.com/golang/protobuf/ptypes" "google.golang.org/grpc/internal/pretty" - "google.golang.org/grpc/xds/internal/client/load" + "google.golang.org/grpc/xds/internal/xdsclient/load" v3corepb "github.com/envoyproxy/go-control-plane/envoy/config/core/v3" v3endpointpb "github.com/envoyproxy/go-control-plane/envoy/config/endpoint/v3" diff --git a/xds/internal/client/watchers.go b/xds/internal/xdsclient/watchers.go similarity index 99% rename from xds/internal/client/watchers.go rename to xds/internal/xdsclient/watchers.go index 446f5cca997..249db4de91e 100644 --- a/xds/internal/client/watchers.go +++ b/xds/internal/xdsclient/watchers.go @@ -16,7 +16,7 @@ * */ -package client +package xdsclient import ( "fmt" diff --git a/xds/internal/client/watchers_cluster_test.go b/xds/internal/xdsclient/watchers_cluster_test.go similarity index 99% rename from xds/internal/client/watchers_cluster_test.go rename to xds/internal/xdsclient/watchers_cluster_test.go index c9837cd5197..8c33486fa01 100644 --- a/xds/internal/client/watchers_cluster_test.go +++ b/xds/internal/xdsclient/watchers_cluster_test.go @@ -18,7 +18,7 @@ * */ -package client +package xdsclient import ( "context" diff --git a/xds/internal/client/watchers_endpoints_test.go b/xds/internal/xdsclient/watchers_endpoints_test.go similarity index 99% rename from xds/internal/client/watchers_endpoints_test.go rename to xds/internal/xdsclient/watchers_endpoints_test.go index bff4544d267..70f06514d9f 100644 --- a/xds/internal/client/watchers_endpoints_test.go +++ b/xds/internal/xdsclient/watchers_endpoints_test.go @@ -18,7 +18,7 @@ * */ -package client +package xdsclient import ( "context" diff --git a/xds/internal/client/watchers_listener_test.go b/xds/internal/xdsclient/watchers_listener_test.go similarity index 99% rename from xds/internal/client/watchers_listener_test.go rename to xds/internal/xdsclient/watchers_listener_test.go index fdd4ebd163f..79ef997a72d 100644 --- a/xds/internal/client/watchers_listener_test.go +++ b/xds/internal/xdsclient/watchers_listener_test.go @@ -18,7 +18,7 @@ * */ -package client +package xdsclient import ( "context" diff --git a/xds/internal/client/watchers_route_test.go b/xds/internal/xdsclient/watchers_route_test.go similarity index 99% rename from xds/internal/client/watchers_route_test.go rename to xds/internal/xdsclient/watchers_route_test.go index 41640b85b57..08b035a0b0a 100644 --- a/xds/internal/client/watchers_route_test.go +++ b/xds/internal/xdsclient/watchers_route_test.go @@ -18,7 +18,7 @@ * */ -package client +package xdsclient import ( "context" diff --git a/xds/internal/client/xds.go b/xds/internal/xdsclient/xds.go similarity index 99% rename from xds/internal/client/xds.go rename to xds/internal/xdsclient/xds.go index b9522411323..44fd883e3f3 100644 --- a/xds/internal/client/xds.go +++ b/xds/internal/xdsclient/xds.go @@ -16,7 +16,7 @@ * */ -package client +package xdsclient import ( "errors" diff --git a/xds/server.go b/xds/server.go index b83a073ac1c..61e22cee8ff 100644 --- a/xds/server.go +++ b/xds/server.go @@ -33,16 +33,16 @@ import ( "google.golang.org/grpc/internal/buffer" internalgrpclog "google.golang.org/grpc/internal/grpclog" "google.golang.org/grpc/internal/grpcsync" - xdsclient "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/bootstrap" "google.golang.org/grpc/xds/internal/server" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/bootstrap" ) const serverPrefix = "[xds-server %p] " var ( // These new functions will be overridden in unit tests. - newXDSClient = func() (xdsClientInterface, error) { + newXDSClient = func() (xdsClient, error) { return xdsclient.New() } newGRPCServer = func(opts ...grpc.ServerOption) grpcServerInterface { @@ -58,9 +58,9 @@ func prefixLogger(p *GRPCServer) *internalgrpclog.PrefixLogger { return internalgrpclog.NewPrefixLogger(logger, fmt.Sprintf(serverPrefix, p)) } -// xdsClientInterface contains methods from xdsClient.Client which are used by +// xdsClient contains methods from xdsClient.Client which are used by // the server. This is useful for overriding in unit tests. -type xdsClientInterface interface { +type xdsClient interface { WatchListener(string, func(xdsclient.ListenerUpdate, error)) func() BootstrapConfig() *bootstrap.Config Close() @@ -89,8 +89,8 @@ type GRPCServer struct { // clientMu is used only in initXDSClient(), which is called at the // beginning of Serve(), where we have to decide if we have to create a // client or use an existing one. - clientMu sync.Mutex - xdsC xdsClientInterface + clientMu sync.Mutex + xdsClient xdsClient } // NewGRPCServer creates an xDS-enabled gRPC server using the passed in opts. @@ -150,13 +150,13 @@ func (s *GRPCServer) initXDSClient() error { s.clientMu.Lock() defer s.clientMu.Unlock() - if s.xdsC != nil { + if s.xdsClient != nil { return nil } newXDSClient := newXDSClient if s.opts.bootstrapContents != nil { - newXDSClient = func() (xdsClientInterface, error) { + newXDSClient = func() (xdsClient, error) { return xdsclient.NewClientWithBootstrapContents(s.opts.bootstrapContents) } } @@ -164,7 +164,7 @@ func (s *GRPCServer) initXDSClient() error { if err != nil { return fmt.Errorf("xds: failed to create xds-client: %v", err) } - s.xdsC = client + s.xdsClient = client s.logger.Infof("Created an xdsClient") return nil } @@ -187,7 +187,7 @@ func (s *GRPCServer) Serve(lis net.Listener) error { if err := s.initXDSClient(); err != nil { return err } - cfg := s.xdsC.BootstrapConfig() + cfg := s.xdsClient.BootstrapConfig() if cfg == nil { return errors.New("bootstrap configuration is empty") } @@ -227,7 +227,7 @@ func (s *GRPCServer) Serve(lis net.Listener) error { Listener: lis, ListenerResourceName: name, XDSCredsInUse: s.xdsCredsInUse, - XDSClient: s.xdsC, + XDSClient: s.xdsClient, ModeCallback: func(addr net.Addr, mode server.ServingMode, err error) { modeUpdateCh.Put(&modeChangeArgs{ addr: addr, @@ -298,8 +298,8 @@ func (s *GRPCServer) handleServingModeChanges(updateCh *buffer.Unbounded) { func (s *GRPCServer) Stop() { s.quit.Fire() s.gs.Stop() - if s.xdsC != nil { - s.xdsC.Close() + if s.xdsClient != nil { + s.xdsClient.Close() } } @@ -309,8 +309,8 @@ func (s *GRPCServer) Stop() { func (s *GRPCServer) GracefulStop() { s.quit.Fire() s.gs.GracefulStop() - if s.xdsC != nil { - s.xdsC.Close() + if s.xdsClient != nil { + s.xdsClient.Close() } } diff --git a/xds/server_test.go b/xds/server_test.go index e16ac36b01f..858116762f2 100644 --- a/xds/server_test.go +++ b/xds/server_test.go @@ -39,10 +39,10 @@ import ( "google.golang.org/grpc/credentials/xds" "google.golang.org/grpc/internal/grpctest" "google.golang.org/grpc/internal/testutils" - xdsclient "google.golang.org/grpc/xds/internal/client" - "google.golang.org/grpc/xds/internal/client/bootstrap" xdstestutils "google.golang.org/grpc/xds/internal/testutils" "google.golang.org/grpc/xds/internal/testutils/fakeclient" + "google.golang.org/grpc/xds/internal/xdsclient" + "google.golang.org/grpc/xds/internal/xdsclient/bootstrap" ) const ( @@ -247,7 +247,7 @@ func (p *fakeProvider) Close() { func setupOverrides() (*fakeGRPCServer, *testutils.Channel, func()) { clientCh := testutils.NewChannel() origNewXDSClient := newXDSClient - newXDSClient = func() (xdsClientInterface, error) { + newXDSClient = func() (xdsClient, error) { c := fakeclient.NewClient() c.SetBootstrapConfig(&bootstrap.Config{ BalancerName: "dummyBalancer", @@ -277,7 +277,7 @@ func setupOverrides() (*fakeGRPCServer, *testutils.Channel, func()) { func setupOverridesForXDSCreds(includeCertProviderCfg bool) (*testutils.Channel, func()) { clientCh := testutils.NewChannel() origNewXDSClient := newXDSClient - newXDSClient = func() (xdsClientInterface, error) { + newXDSClient = func() (xdsClient, error) { c := fakeclient.NewClient() bc := &bootstrap.Config{ BalancerName: "dummyBalancer", @@ -544,7 +544,7 @@ func (s) TestServeBootstrapConfigInvalid(t *testing.T) { // xdsClient with the specified bootstrap configuration. clientCh := testutils.NewChannel() origNewXDSClient := newXDSClient - newXDSClient = func() (xdsClientInterface, error) { + newXDSClient = func() (xdsClient, error) { c := fakeclient.NewClient() c.SetBootstrapConfig(test.bootstrapConfig) clientCh.Send(c) @@ -587,7 +587,7 @@ func (s) TestServeBootstrapConfigInvalid(t *testing.T) { // verifies that Server() exits with a non-nil error. func (s) TestServeNewClientFailure(t *testing.T) { origNewXDSClient := newXDSClient - newXDSClient = func() (xdsClientInterface, error) { + newXDSClient = func() (xdsClient, error) { return nil, errors.New("xdsClient creation failed") } defer func() { newXDSClient = origNewXDSClient }() diff --git a/xds/xds.go b/xds/xds.go index bbd3fe54321..864d2e6a2e3 100644 --- a/xds/xds.go +++ b/xds/xds.go @@ -43,10 +43,10 @@ import ( _ "google.golang.org/grpc/credentials/tls/certprovider/pemfile" // Register the file watcher certificate provider plugin. _ "google.golang.org/grpc/xds/internal/balancer" // Register the balancers. - _ "google.golang.org/grpc/xds/internal/client/v2" // Register the v2 xDS API client. - _ "google.golang.org/grpc/xds/internal/client/v3" // Register the v3 xDS API client. _ "google.golang.org/grpc/xds/internal/httpfilter/fault" // Register the fault injection filter. xdsresolver "google.golang.org/grpc/xds/internal/resolver" // Register the xds_resolver. + _ "google.golang.org/grpc/xds/internal/xdsclient/v2" // Register the v2 xDS API client. + _ "google.golang.org/grpc/xds/internal/xdsclient/v3" // Register the v3 xDS API client. ) func init() {