authz/rbac_translator.go

@@ -154,21 +154,21 @@ func parsePrincipalNames(principalNames []string) []*v3rbacpb.Principal {
 	return ps
 }
 
-func parsePeer(source peer) (*v3rbacpb.Principal, error) {
+func parsePeer(source peer) *v3rbacpb.Principal {
 	if source.Principals == nil {
 		return &v3rbacpb.Principal{
 			Identifier: &v3rbacpb.Principal_Any{
 				Any: true,
 			},
-		}, nil
+		}
 	}
 	if len(source.Principals) == 0 {
 		return &v3rbacpb.Principal{
 			Identifier: &v3rbacpb.Principal_Authenticated_{
 				Authenticated: &v3rbacpb.Principal_Authenticated{},
-			}}, nil
+			}}
 	}
-	return principalOr(parsePrincipalNames(source.Principals)), nil
+	return principalOr(parsePrincipalNames(source.Principals))
 }
 
 func parsePaths(paths []string) []*v3rbacpb.Permission {
@@ -257,17 +257,13 @@ func parseRules(rules []rule, prefixName string) (map[string]*v3rbacpb.Policy, e
 		if rule.Name == "" {
 			return policies, fmt.Errorf(`%d: "name" is not present`, i)
 		}
-		principal, err := parsePeer(rule.Source)
-		if err != nil {
-			return nil, fmt.Errorf("%d: %v", i, err)
-		}
 		permission, err := parseRequest(rule.Request)
 		if err != nil {
 			return nil, fmt.Errorf("%d: %v", i, err)
 		}
 		policyName := prefixName + "_" + rule.Name
 		policies[policyName] = &v3rbacpb.Policy{
-			Principals:  []*v3rbacpb.Principal{principal},
+			Principals:  []*v3rbacpb.Principal{parsePeer(rule.Source)},
 			Permissions: []*v3rbacpb.Permission{permission},
 		}
 	}

balancer/balancer.go

@@ -174,25 +174,32 @@ type ClientConn interface {
 
 // BuildOptions contains additional information for Build.
 type BuildOptions struct {
-	// DialCreds is the transport credential the Balancer implementation can
-	// use to dial to a remote load balancer server. The Balancer implementations
-	// can ignore this if it does not need to talk to another party securely.
+	// DialCreds is the transport credentials to use when communicating with a
+	// remote load balancer server. Balancer implementations which do not
+	// communicate with a remote load balancer server can ignore this field.
 	DialCreds credentials.TransportCredentials
-	// CredsBundle is the credentials bundle that the Balancer can use.
+	// CredsBundle is the credentials bundle to use when communicating with a
+	// remote load balancer server. Balancer implementations which do not
+	// communicate with a remote load balancer server can ignore this field.
 	CredsBundle credentials.Bundle
-	// Dialer is the custom dialer the Balancer implementation can use to dial
-	// to a remote load balancer server. The Balancer implementations
-	// can ignore this if it doesn't need to talk to remote balancer.
+	// Dialer is the custom dialer to use when communicating with a remote load
+	// balancer server. Balancer implementations which do not communicate with a
+	// remote load balancer server can ignore this field.
 	Dialer func(context.Context, string) (net.Conn, error)
-	// ChannelzParentID is the entity parent's channelz unique identification number.
+	// Authority is the server name to use as part of the authentication
+	// handshake when communicating with a remote load balancer server. Balancer
+	// implementations which do not communicate with a remote load balancer
+	// server can ignore this field.
+	Authority string
+	// ChannelzParentID is the parent ClientConn's channelz ID.
 	ChannelzParentID int64
 	// CustomUserAgent is the custom user agent set on the parent ClientConn.
 	// The balancer should set the same custom user agent if it creates a
 	// ClientConn.
 	CustomUserAgent string
-	// Target contains the parsed address info of the dial target. It is the same resolver.Target as
-	// passed to the resolver.
-	// See the documentation for the resolver.Target type for details about what it contains.
+	// Target contains the parsed address info of the dial target. It is the
+	// same resolver.Target as passed to the resolver. See the documentation for
+	// the resolver.Target type for details about what it contains.
 	Target resolver.Target
 }
 

balancer/grpclb/grpclb_test.go

@@ -369,7 +369,7 @@ func startBackendsAndRemoteLoadBalancer(numberOfBackends int, customUserAgent st
 		beIPs = append(beIPs, beLis.Addr().(*net.TCPAddr).IP)
 		bePorts = append(bePorts, beLis.Addr().(*net.TCPAddr).Port)
 
-		beListeners = append(beListeners, newRestartableListener(beLis))
+		beListeners = append(beListeners, testutils.NewRestartableListener(beLis))
 	}
 	backends := startBackends(beServerName, false, beListeners...)
 
@@ -379,7 +379,7 @@ func startBackendsAndRemoteLoadBalancer(numberOfBackends int, customUserAgent st
 		err = fmt.Errorf("failed to create the listener for the load balancer %v", err)
 		return
 	}
-	lbLis = newRestartableListener(lbLis)
+	lbLis = testutils.NewRestartableListener(lbLis)
 	lbCreds := &serverNameCheckCreds{
 		sn: lbServerName,
 	}
@@ -846,8 +846,8 @@ func (s) TestFallback(t *testing.T) {
 	}
 
 	// Close backend and remote balancer connections, should use fallback.
-	tss.beListeners[0].(*restartableListener).stopPreviousConns()
-	tss.lbListener.(*restartableListener).stopPreviousConns()
+	tss.beListeners[0].(*testutils.RestartableListener).Stop()
+	tss.lbListener.(*testutils.RestartableListener).Stop()
 
 	var fallbackUsed bool
 	for i := 0; i < 2000; i++ {
@@ -871,8 +871,8 @@ func (s) TestFallback(t *testing.T) {
 	}
 
 	// Restart backend and remote balancer, should not use fallback backend.
-	tss.beListeners[0].(*restartableListener).restart()
-	tss.lbListener.(*restartableListener).restart()
+	tss.beListeners[0].(*testutils.RestartableListener).Restart()
+	tss.lbListener.(*testutils.RestartableListener).Restart()
 	tss.ls.sls <- sl
 
 	var backendUsed2 bool

balancer/rls/internal/adaptive/adaptive_test.go

@@ -156,7 +156,7 @@ func TestShouldThrottleOptions(t *testing.T) {
 	for _, test := range testcases {
 		t.Run(test.desc, func(t *testing.T) {
 			m.SetNanos(0)
-			th := newWithArgs(time.Duration(time.Nanosecond), 1, test.ratioForAccepts, test.requestsPadding)
+			th := newWithArgs(time.Nanosecond, 1, test.ratioForAccepts, test.requestsPadding)
 			for i, response := range responses {
 				if response != E {
 					th.RegisterBackendResponse(response == T)

balancer/rls/internal/client.go

@@ -23,7 +23,8 @@ import (
 	"time"
 
 	"google.golang.org/grpc"
-	rlspb "google.golang.org/grpc/balancer/rls/internal/proto/grpc_lookup_v1"
+	rlsgrpc "google.golang.org/grpc/internal/proto/grpc_lookup_v1"
+	rlspb "google.golang.org/grpc/internal/proto/grpc_lookup_v1"
 )
 
 // For gRPC services using RLS, the value of target_type in the
@@ -43,7 +44,7 @@ const grpcTargetType = "grpc"
 // throttling and asks this client to make an RPC call only after checking with
 // the throttler.
 type rlsClient struct {
-	stub rlspb.RouteLookupServiceClient
+	stub rlsgrpc.RouteLookupServiceClient
 	// origDialTarget is the original dial target of the user and sent in each
 	// RouteLookup RPC made to the RLS server.
 	origDialTarget string
@@ -54,7 +55,7 @@ type rlsClient struct {
 
 func newRLSClient(cc *grpc.ClientConn, dialTarget string, rpcTimeout time.Duration) *rlsClient {
 	return &rlsClient{
-		stub:           rlspb.NewRouteLookupServiceClient(cc),
+		stub:           rlsgrpc.NewRouteLookupServiceClient(cc),
 		origDialTarget: dialTarget,
 		rpcTimeout:     rpcTimeout,
 	}
@@ -64,7 +65,7 @@ type lookupCallback func(targets []string, headerData string, err error)
 
 // lookup starts a RouteLookup RPC in a separate goroutine and returns the
 // results (and error, if any) in the provided callback.
-func (c *rlsClient) lookup(path string, keyMap map[string]string, cb lookupCallback) {
+func (c *rlsClient) lookup(keyMap map[string]string, cb lookupCallback) {
 	go func() {
 		ctx, cancel := context.WithTimeout(context.Background(), c.rpcTimeout)
 		resp, err := c.stub.RouteLookup(ctx, &rlspb.RouteLookupRequest{

balancer/rls/internal/client_test.go

@@ -28,9 +28,9 @@ import (
 	"github.com/golang/protobuf/proto"
 	"github.com/google/go-cmp/cmp"
 	"google.golang.org/grpc"
-	rlspb "google.golang.org/grpc/balancer/rls/internal/proto/grpc_lookup_v1"
 	"google.golang.org/grpc/balancer/rls/internal/testutils/fakeserver"
 	"google.golang.org/grpc/codes"
+	rlspb "google.golang.org/grpc/internal/proto/grpc_lookup_v1"
 	"google.golang.org/grpc/internal/testutils"
 	"google.golang.org/grpc/status"
 )
@@ -71,7 +71,7 @@ func (s) TestLookupFailure(t *testing.T) {
 	rlsClient := newRLSClient(cc, defaultDialTarget, defaultRPCTimeout)
 
 	errCh := testutils.NewChannel()
-	rlsClient.lookup("", nil, func(targets []string, headerData string, err error) {
+	rlsClient.lookup(nil, func(targets []string, headerData string, err error) {
 		if err == nil {
 			errCh.Send(errors.New("rlsClient.lookup() succeeded, should have failed"))
 			return
@@ -101,7 +101,7 @@ func (s) TestLookupDeadlineExceeded(t *testing.T) {
 	rlsClient := newRLSClient(cc, defaultDialTarget, 100*time.Millisecond)
 
 	errCh := testutils.NewChannel()
-	rlsClient.lookup("", nil, func(_ []string, _ string, err error) {
+	rlsClient.lookup(nil, func(_ []string, _ string, err error) {
 		if st, ok := status.FromError(err); !ok || st.Code() != codes.DeadlineExceeded {
 			errCh.Send(fmt.Errorf("rlsClient.lookup() returned error: %v, want %v", err, codes.DeadlineExceeded))
 			return
@@ -121,10 +121,7 @@ func (s) TestLookupSuccess(t *testing.T) {
 	server, cc, cleanup := setup(t)
 	defer cleanup()
 
-	const (
-		rlsReqPath     = "/service/method"
-		wantHeaderData = "headerData"
-	)
+	const wantHeaderData = "headerData"
 
 	rlsReqKeyMap := map[string]string{
 		"k1": "v1",
@@ -141,7 +138,7 @@ func (s) TestLookupSuccess(t *testing.T) {
 	rlsClient := newRLSClient(cc, defaultDialTarget, defaultRPCTimeout)
 
 	errCh := testutils.NewChannel()
-	rlsClient.lookup(rlsReqPath, rlsReqKeyMap, func(targets []string, hd string, err error) {
+	rlsClient.lookup(rlsReqKeyMap, func(targets []string, hd string, err error) {
 		if err != nil {
 			errCh.Send(fmt.Errorf("rlsClient.Lookup() failed: %v", err))
 			return

balancer/rls/internal/config.go

@@ -28,10 +28,9 @@ import (
 	"github.com/golang/protobuf/jsonpb"
 	"github.com/golang/protobuf/ptypes"
 	durationpb "github.com/golang/protobuf/ptypes/duration"
-
 	"google.golang.org/grpc/balancer"
 	"google.golang.org/grpc/balancer/rls/internal/keys"
-	rlspb "google.golang.org/grpc/balancer/rls/internal/proto/grpc_lookup_v1"
+	rlspb "google.golang.org/grpc/internal/proto/grpc_lookup_v1"
 	"google.golang.org/grpc/resolver"
 	"google.golang.org/grpc/serviceconfig"
 )