lbconfig

Author: dfawley

Diff for: balancer/balancer.go

@@ -300,9 +300,9 @@ type SubConnState struct {
 // balancer.
 type ClientConnState struct {
 	ResolverState resolver.State
-	// The parsed load balancer configuration returned by the builder's
+	// The parsed load balancing configuration returned by the builder's
 	// ParseConfig method, if implemented.
-	BalancerConfig interface{}
+	BalancerConfig serviceconfig.LoadBalancingConfig
 }
 
 // V2Balancer is defined for documentation purposes.  If a Balancer also

Diff for: balancer/xds/xds_lrs_test.go

@@ -114,17 +114,11 @@ func (s) TestXdsLoadReporting(t *testing.T) {
 		Nanos:   intervalNano,
 	}
 
-	cfg := &testBalancerConfig{
+	cfg := &xdsConfig{
 		BalancerName: addr,
-		ChildPolicy:  []lbPolicy{fakeBalancerA}, // Set this to skip cds.
+		ChildPolicy:  &loadBalancingConfig{Name: fakeBalancerA}, // Set this to skip cds.
 	}
-	sc, lbc := constructServiceConfigFromXdsConfig(cfg)
-	lb.UpdateClientConnState(balancer.ClientConnState{
-		ResolverState: resolver.State{
-			ServiceConfig: sc,
-		},
-		BalancerConfig: lbc,
-	})
+	lb.UpdateClientConnState(balancer.ClientConnState{BalancerConfig: cfg})
 	td.sendResp(&response{resp: testEDSRespWithoutEndpoints})
 	var (
 		i     int

Diff for: balancer/xds/xds_test.go

@@ -22,7 +22,6 @@ package xds
 
 import (
 	"encoding/json"
-	"fmt"
 	"reflect"
 	"sync"
 	"testing"
@@ -37,19 +36,13 @@ import (
 	"google.golang.org/grpc/internal/grpctest"
 	"google.golang.org/grpc/internal/leakcheck"
 	"google.golang.org/grpc/resolver"
-	"google.golang.org/grpc/serviceconfig"
 )
 
 var lbABuilder = &balancerABuilder{}
 
 func init() {
 	balancer.Register(lbABuilder)
 	balancer.Register(&balancerBBuilder{})
-	testServiceConfigFooBar, testLBConfigFooBar = constructServiceConfigFromXdsConfig(&testBalancerConfig{
-		BalancerName:   testBalancerNameFooBar,
-		ChildPolicy:    []lbPolicy{fakeBalancerA},
-		FallbackPolicy: []lbPolicy{fakeBalancerA},
-	})
 }
 
 type s struct{}
@@ -62,18 +55,19 @@ func Test(t *testing.T) {
 	grpctest.RunSubTests(t, s{})
 }
 
-type lbPolicy string
-
 const (
-	fakeBalancerA lbPolicy = "fake_balancer_A"
-	fakeBalancerB lbPolicy = "fake_balancer_B"
-	fakeBalancerC lbPolicy = "fake_balancer_C"
+	fakeBalancerA = "fake_balancer_A"
+	fakeBalancerB = "fake_balancer_B"
+	fakeBalancerC = "fake_balancer_C"
 )
 
 var (
-	testBalancerNameFooBar  = "foo.bar"
-	testServiceConfigFooBar serviceconfig.Config
-	testLBConfigFooBar      serviceconfig.LoadBalancingConfig
+	testBalancerNameFooBar = "foo.bar"
+	testLBConfigFooBar     = &xdsConfig{
+		BalancerName:   testBalancerNameFooBar,
+		ChildPolicy:    &loadBalancingConfig{Name: fakeBalancerA},
+		FallBackPolicy: &loadBalancingConfig{Name: fakeBalancerA},
+	}
 
 	specialAddrForBalancerA = resolver.Address{Addr: "this.is.balancer.A"}
 	specialAddrForBalancerB = resolver.Address{Addr: "this.is.balancer.B"}
@@ -83,55 +77,6 @@ var (
 	latestFakeEdsBalancer *fakeEDSBalancer
 )
 
-type testBalancerConfig struct {
-	BalancerName   string     `json:"balancerName,omitempty"`
-	ChildPolicy    []lbPolicy `json:"childPolicy,omitempty"`
-	FallbackPolicy []lbPolicy `json:"fallbackPolicy,omitempty"`
-}
-
-func (l *lbPolicy) UnmarshalJSON(b []byte) error {
-	// no need to implement, not used.
-	return nil
-}
-
-func (l lbPolicy) MarshalJSON() ([]byte, error) {
-	m := make(map[string]struct{})
-	m[string(l)] = struct{}{}
-	return json.Marshal(m)
-}
-
-type serviceConfig struct {
-	LoadBalancingConfig []*loadBalancingConfig
-}
-
-func constructServiceConfigFromXdsConfig(xdsCfg *testBalancerConfig) (serviceconfig.Config, serviceconfig.LoadBalancingConfig) {
-	cfgRaw, err := json.Marshal(xdsCfg)
-	if err != nil {
-		panic(fmt.Sprintf("Error from json.Marshal(%+v): %v", xdsCfg, err))
-	}
-	sc := &serviceConfig{
-		LoadBalancingConfig: []*loadBalancingConfig{
-			{
-				Name:   xdsName,
-				Config: cfgRaw,
-			},
-		},
-	}
-	jsonSC, err := json.Marshal(sc)
-	if err != nil {
-		panic(fmt.Sprintf("Error from json.Marshal(%+v): %v", sc, err))
-	}
-	parsedSC, err := serviceconfig.Parse(string(jsonSC))
-	if err != nil {
-		panic(fmt.Sprintf("Error from serviceconfig.Parse(%q): %v", jsonSC, err))
-	}
-	parsedLBC, err := (&xdsBalancerBuilder{}).ParseConfig(cfgRaw)
-	if err != nil {
-		panic(fmt.Sprintf("Error from xdsBalancerBuilder.Parse(%q): %v", cfgRaw, err))
-	}
-	return parsedSC, parsedLBC
-}
-
 type balancerABuilder struct {
 	mu           sync.Mutex
 	lastBalancer *balancerA
@@ -306,10 +251,7 @@ func (s) TestXdsBalanceHandleResolvedAddrs(t *testing.T) {
 	addrs := []resolver.Address{{Addr: "1.1.1.1:10001"}, {Addr: "2.2.2.2:10002"}, {Addr: "3.3.3.3:10003"}}
 	for i := 0; i < 3; i++ {
 		lb.UpdateClientConnState(balancer.ClientConnState{
-			ResolverState: resolver.State{
-				Addresses:     addrs,
-				ServiceConfig: testServiceConfigFooBar,
-			},
+			ResolverState:  resolver.State{Addresses: addrs},
 			BalancerConfig: testLBConfigFooBar,
 		})
 		select {
@@ -342,10 +284,7 @@ func (s) TestXdsBalanceHandleBalancerConfigBalancerNameUpdate(t *testing.T) {
 	defer lb.Close()
 	addrs := []resolver.Address{{Addr: "1.1.1.1:10001"}, {Addr: "2.2.2.2:10002"}, {Addr: "3.3.3.3:10003"}}
 	lb.UpdateClientConnState(balancer.ClientConnState{
-		ResolverState: resolver.State{
-			Addresses:     addrs,
-			ServiceConfig: testServiceConfigFooBar,
-		},
+		ResolverState:  resolver.State{Addresses: addrs},
 		BalancerConfig: testLBConfigFooBar,
 	})
 
@@ -370,16 +309,13 @@ func (s) TestXdsBalanceHandleBalancerConfigBalancerNameUpdate(t *testing.T) {
 	for i := 0; i < 2; i++ {
 		addr, td, _, cleanup := setupServer(t)
 		cleanups = append(cleanups, cleanup)
-		workingServiceConfig, workingLBConfig := constructServiceConfigFromXdsConfig(&testBalancerConfig{
+		workingLBConfig := &xdsConfig{
 			BalancerName:   addr,
-			ChildPolicy:    []lbPolicy{fakeBalancerA},
-			FallbackPolicy: []lbPolicy{fakeBalancerA},
-		})
+			ChildPolicy:    &loadBalancingConfig{Name: fakeBalancerA},
+			FallBackPolicy: &loadBalancingConfig{Name: fakeBalancerA},
+		}
 		lb.UpdateClientConnState(balancer.ClientConnState{
-			ResolverState: resolver.State{
-				Addresses:     addrs,
-				ServiceConfig: workingServiceConfig,
-			},
+			ResolverState:  resolver.State{Addresses: addrs},
 			BalancerConfig: workingLBConfig,
 		})
 		td.sendResp(&response{resp: testEDSRespWithoutEndpoints})
@@ -429,13 +365,16 @@ func (s) TestXdsBalanceHandleBalancerConfigChildPolicyUpdate(t *testing.T) {
 		}
 	}()
 	for _, test := range []struct {
-		cfg                 *testBalancerConfig
+		cfg                 *xdsConfig
 		responseToSend      *discoverypb.DiscoveryResponse
 		expectedChildPolicy *loadBalancingConfig
 	}{
 		{
-			cfg: &testBalancerConfig{
-				ChildPolicy: []lbPolicy{fakeBalancerA},
+			cfg: &xdsConfig{
+				ChildPolicy: &loadBalancingConfig{
+					Name:   fakeBalancerA,
+					Config: json.RawMessage("{}"),
+				},
 			},
 			responseToSend: testEDSRespWithoutEndpoints,
 			expectedChildPolicy: &loadBalancingConfig{
@@ -444,16 +383,19 @@ func (s) TestXdsBalanceHandleBalancerConfigChildPolicyUpdate(t *testing.T) {
 			},
 		},
 		{
-			cfg: &testBalancerConfig{
-				ChildPolicy: []lbPolicy{fakeBalancerB},
+			cfg: &xdsConfig{
+				ChildPolicy: &loadBalancingConfig{
+					Name:   fakeBalancerB,
+					Config: json.RawMessage("{}"),
+				},
 			},
 			expectedChildPolicy: &loadBalancingConfig{
 				Name:   string(fakeBalancerB),
 				Config: json.RawMessage(`{}`),
 			},
 		},
 		{
-			cfg:            &testBalancerConfig{},
+			cfg:            &xdsConfig{},
 			responseToSend: testCDSResp,
 			expectedChildPolicy: &loadBalancingConfig{
 				Name: "ROUND_ROBIN",
@@ -464,13 +406,7 @@ func (s) TestXdsBalanceHandleBalancerConfigChildPolicyUpdate(t *testing.T) {
 		cleanups = append(cleanups, cleanup)
 		test.cfg.BalancerName = addr
 
-		sc, lbc := constructServiceConfigFromXdsConfig(test.cfg)
-		lb.UpdateClientConnState(balancer.ClientConnState{
-			ResolverState: resolver.State{
-				ServiceConfig: sc,
-			},
-			BalancerConfig: lbc,
-		})
+		lb.UpdateClientConnState(balancer.ClientConnState{BalancerConfig: test.cfg})
 		if test.responseToSend != nil {
 			td.sendResp(&response{resp: test.responseToSend})
 		}
@@ -497,7 +433,7 @@ func (s) TestXdsBalanceHandleBalancerConfigChildPolicyUpdate(t *testing.T) {
 
 // not in fallback mode, overwrite fallback info.
 // in fallback mode, update config or switch balancer.
-func (s) TestXdsBalanceHandleBalancerConfigFallbackUpdate(t *testing.T) {
+func (s) TestXdsBalanceHandleBalancerConfigFallBackUpdate(t *testing.T) {
 	originalNewEDSBalancer := newEDSBalancer
 	newEDSBalancer = newFakeEDSBalancer
 	defer func() {
@@ -514,28 +450,19 @@ func (s) TestXdsBalanceHandleBalancerConfigFallbackUpdate(t *testing.T) {
 
 	addr, td, _, cleanup := setupServer(t)
 
-	cfg := &testBalancerConfig{
+	cfg := xdsConfig{
 		BalancerName:   addr,
-		ChildPolicy:    []lbPolicy{fakeBalancerA},
-		FallbackPolicy: []lbPolicy{fakeBalancerA},
+		ChildPolicy:    &loadBalancingConfig{Name: fakeBalancerA},
+		FallBackPolicy: &loadBalancingConfig{Name: fakeBalancerA},
 	}
-	sc, lbc := constructServiceConfigFromXdsConfig(cfg)
-	lb.UpdateClientConnState(balancer.ClientConnState{
-		ResolverState: resolver.State{
-			ServiceConfig: sc,
-		},
-		BalancerConfig: lbc,
-	})
+	lb.UpdateClientConnState(balancer.ClientConnState{BalancerConfig: &cfg})
 
 	addrs := []resolver.Address{{Addr: "1.1.1.1:10001"}, {Addr: "2.2.2.2:10002"}, {Addr: "3.3.3.3:10003"}}
-	cfg.FallbackPolicy = []lbPolicy{fakeBalancerB}
-	sc, lbc = constructServiceConfigFromXdsConfig(cfg)
+	cfg2 := cfg
+	cfg2.FallBackPolicy = &loadBalancingConfig{Name: fakeBalancerB}
 	lb.UpdateClientConnState(balancer.ClientConnState{
-		ResolverState: resolver.State{
-			Addresses:     addrs,
-			ServiceConfig: sc,
-		},
-		BalancerConfig: lbc,
+		ResolverState:  resolver.State{Addresses: addrs},
+		BalancerConfig: &cfg2,
 	})
 
 	td.sendResp(&response{resp: testEDSRespWithoutEndpoints})
@@ -563,14 +490,11 @@ func (s) TestXdsBalanceHandleBalancerConfigFallbackUpdate(t *testing.T) {
 		t.Fatalf("timeout when geting new subconn result")
 	}
 
-	cfg.FallbackPolicy = []lbPolicy{fakeBalancerA}
-	sc, lbc = constructServiceConfigFromXdsConfig(cfg)
+	cfg3 := cfg
+	cfg3.FallBackPolicy = &loadBalancingConfig{Name: fakeBalancerA}
 	lb.UpdateClientConnState(balancer.ClientConnState{
-		ResolverState: resolver.State{
-			Addresses:     addrs,
-			ServiceConfig: sc,
-		},
-		BalancerConfig: lbc,
+		ResolverState:  resolver.State{Addresses: addrs},
+		BalancerConfig: &cfg3,
 	})
 
 	// verify fallback balancer A takes over
@@ -601,18 +525,12 @@ func (s) TestXdsBalancerHandlerSubConnStateChange(t *testing.T) {
 
 	addr, td, _, cleanup := setupServer(t)
 	defer cleanup()
-	cfg := &testBalancerConfig{
+	cfg := &xdsConfig{
 		BalancerName:   addr,
-		ChildPolicy:    []lbPolicy{fakeBalancerA},
-		FallbackPolicy: []lbPolicy{fakeBalancerA},
+		ChildPolicy:    &loadBalancingConfig{Name: fakeBalancerA},
+		FallBackPolicy: &loadBalancingConfig{Name: fakeBalancerA},
 	}
-	sc, lbc := constructServiceConfigFromXdsConfig(cfg)
-	lb.UpdateClientConnState(balancer.ClientConnState{
-		ResolverState: resolver.State{
-			ServiceConfig: sc,
-		},
-		BalancerConfig: lbc,
-	})
+	lb.UpdateClientConnState(balancer.ClientConnState{BalancerConfig: cfg})
 
 	td.sendResp(&response{resp: testEDSRespWithoutEndpoints})
 
@@ -668,7 +586,7 @@ func (s) TestXdsBalancerHandlerSubConnStateChange(t *testing.T) {
 	}
 }
 
-func (s) TestXdsBalancerFallbackSignalFromEdsBalancer(t *testing.T) {
+func (s) TestXdsBalancerFallBackSignalFromEdsBalancer(t *testing.T) {
 	originalNewEDSBalancer := newEDSBalancer
 	newEDSBalancer = newFakeEDSBalancer
 	defer func() {
@@ -685,18 +603,12 @@ func (s) TestXdsBalancerFallbackSignalFromEdsBalancer(t *testing.T) {
 
 	addr, td, _, cleanup := setupServer(t)
 	defer cleanup()
-	cfg := &testBalancerConfig{
+	cfg := &xdsConfig{
 		BalancerName:   addr,
-		ChildPolicy:    []lbPolicy{fakeBalancerA},
-		FallbackPolicy: []lbPolicy{fakeBalancerA},
+		ChildPolicy:    &loadBalancingConfig{Name: fakeBalancerA},
+		FallBackPolicy: &loadBalancingConfig{Name: fakeBalancerA},
 	}
-	sc, lbc := constructServiceConfigFromXdsConfig(cfg)
-	lb.UpdateClientConnState(balancer.ClientConnState{
-		ResolverState: resolver.State{
-			ServiceConfig: sc,
-		},
-		BalancerConfig: lbc,
-	})
+	lb.UpdateClientConnState(balancer.ClientConnState{BalancerConfig: cfg})
 
 	td.sendResp(&response{resp: testEDSRespWithoutEndpoints})
 
@@ -753,16 +665,16 @@ func (s) TestXdsBalancerFallbackSignalFromEdsBalancer(t *testing.T) {
 }
 
 func (s) TestXdsBalancerConfigParsingSelectingLBPolicy(t *testing.T) {
-	tesCfg := &testBalancerConfig{
-		BalancerName:   "fake.foo.bar",
-		ChildPolicy:    []lbPolicy{fakeBalancerC, fakeBalancerA, fakeBalancerB}, // selects fakeBalancerA
-		FallbackPolicy: []lbPolicy{fakeBalancerC, fakeBalancerB, fakeBalancerA}, // selects fakeBalancerB
-	}
-	js, _ := json.Marshal(tesCfg)
-	var xdsCfg xdsConfig
-	if err := json.Unmarshal(js, &xdsCfg); err != nil {
-		t.Fatal("unable to unmarshal balancer config into xds config")
+	js := json.RawMessage(`{
+"balancerName": "fake.foo.bar",
+"childPolicy": [{"fake_balancer_C": {}}, {"fake_balancer_A": {}}, {"fake_balancer_B": {}}],
+"fallbackPolicy": [{"fake_balancer_C": {}}, {"fake_balancer_B": {}}, {"fake_balancer_A": {}}]
+}`)
+	cfg, err := (&xdsBalancerBuilder{}).ParseConfig(js)
+	if err != nil {
+		t.Fatalf("unable to unmarshal balancer config into xds config: %v", err)
 	}
+	xdsCfg := cfg.(*xdsConfig)
 	wantChildPolicy := &loadBalancingConfig{Name: string(fakeBalancerA), Config: json.RawMessage(`{}`)}
 	if !reflect.DeepEqual(xdsCfg.ChildPolicy, wantChildPolicy) {
 		t.Fatalf("got child policy %v, want %v", xdsCfg.ChildPolicy, wantChildPolicy)