service config: default service config

clientconn.go

@@ -389,7 +389,7 @@ type ClientConn struct {
 	mu              sync.RWMutex
 	resolverWrapper *ccResolverWrapper
 	sc              ServiceConfig
-	scRaw           string
+	scRaw           *string
 	conns           map[*addrConn]struct{}
 	// Keepalive parameter can be updated if a GoAway is received.
 	mkp             keepalive.ClientParameters
@@ -438,7 +438,8 @@ func (cc *ClientConn) scWatcher() {
 			// TODO: load balance policy runtime change is ignored.
 			// We may revisit this decision in the future.
 			cc.sc = sc
-			cc.scRaw = ""
+			s := ""
+			cc.scRaw = &s
 			cc.mu.Unlock()
 		case <-cc.ctx.Done():
 			return
@@ -762,11 +763,33 @@ func (cc *ClientConn) getTransport(ctx context.Context, failfast bool, method st
 // struct ServiceConfig, and store both the struct and the JSON string in ClientConn.
 func (cc *ClientConn) handleServiceConfig(js string) error {
 	if cc.dopts.disableServiceConfig {
-		return nil
+		if cc.dopts.defaultServiceConfig == nil {
+			return nil
+		}
+		// apply default service config when there's resolver service config is disabled.
+		return cc.applyServiceConfig(cc.dopts.defaultServiceConfig, cc.dopts.defaultServiceConfigRaw)
 	}
-	if cc.scRaw == js {
+
+	return cc.applyServiceConfig(nil, js)
+}
+
+// Parse and apply the service config. If sc is passed as a non-nil pointer, which indicates we have
+// a parsed service config, we will skip the parsing. It will also skip the whole processing if
+// the new service config is the same as the old one.
+func (cc *ClientConn) applyServiceConfig(sc *ServiceConfig, js string) error {
+	if cc.scRaw != nil && *cc.scRaw == js {
 		return nil
 	}
+
+	// the config has not been parsed, so we parse it now.
+	if sc == nil {
+		scfg, err := parseServiceConfig(js)
+		if err != nil {
+			return err
+		}
+		sc = &scfg
+	}
+
 	if channelz.IsOn() {
 		channelz.AddTraceEvent(cc.channelzID, &channelz.TraceEventDesc{
 			// The special formatting of \"%s\" instead of %q is to provide nice printing of service config
@@ -775,10 +798,6 @@ func (cc *ClientConn) handleServiceConfig(js string) error {
 			Severity: channelz.CtINFO,
 		})
 	}
-	sc, err := parseServiceConfig(js)
-	if err != nil {
-		return err
-	}
 	cc.mu.Lock()
 	// Check if the ClientConn is already closed. Some fields (e.g.
 	// balancerWrapper) are set to nil when closing the ClientConn, and could
@@ -787,8 +806,8 @@ func (cc *ClientConn) handleServiceConfig(js string) error {
 		cc.mu.Unlock()
 		return nil
 	}
-	cc.scRaw = js
-	cc.sc = sc
+	cc.scRaw = &js
+	cc.sc = *sc
 
 	if sc.retryThrottling != nil {
 		newThrottler := &retryThrottler{

clientconn_test.go

@@ -1244,3 +1244,40 @@ func setMinConnectTimeout(newMin time.Duration) (cleanup func()) {
 		atomic.StoreInt64((*int64)(&mutableMinConnectTimeout), int64(mctBkp))
 	}
 }
+
+func (s) TestDefaultServiceConfigWhenResolverServiceConfigDisabled(t *testing.T) {
+	r, cleanup := manual.GenerateAndRegisterManualResolver()
+	defer cleanup()
+	addr := r.Scheme() + ":///non.existent"
+	r.InitialAddrs([]resolver.Address{{Addr: addr}})
+	js := `{
+    "methodConfig": [
+        {
+            "name": [
+                {
+                    "service": "foo",
+                    "method": "bar"
+                }
+            ],
+            "waitForReady": true
+        }
+    ]
+}`
+	cc, err := Dial(addr, WithInsecure(), WithDisableServiceConfig(), WithDefaultServiceConfig(js))
+	if err != nil {
+		t.Fatalf("Dial(%s, _) = _, %v, want _, <nil>", addr, err)
+	}
+	defer cc.Close()
+	r.NewServiceConfig("")
+	var i int
+	for i = 0; i < 10; i++ {
+		mc := cc.GetMethodConfig("/foo/bar")
+		if mc.WaitForReady != nil && *mc.WaitForReady == true {
+			break
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+	if i == 10 {
+		t.Fatal("default service config failed to be applied after 1s")
+	}
+}

dialoptions.go

@@ -55,13 +55,15 @@ type dialOptions struct {
 	// balancer, and also by WithBalancerName dial option.
 	balancerBuilder balancer.Builder
 	// This is to support grpclb.
-	resolverBuilder      resolver.Builder
-	reqHandshake         envconfig.RequireHandshakeSetting
-	channelzParentID     int64
-	disableServiceConfig bool
-	disableRetry         bool
-	disableHealthCheck   bool
-	healthCheckFunc      internal.HealthChecker
+	resolverBuilder         resolver.Builder
+	reqHandshake            envconfig.RequireHandshakeSetting
+	channelzParentID        int64
+	disableServiceConfig    bool
+	disableRetry            bool
+	disableHealthCheck      bool
+	healthCheckFunc         internal.HealthChecker
+	defaultServiceConfig    *ServiceConfig
+	defaultServiceConfigRaw string
 }
 
 // DialOption configures how we set up the connection.
@@ -446,6 +448,22 @@ func WithDisableServiceConfig() DialOption {
 	})
 }
 
+// WithDefaultServiceConfig returns a DialOption that configures the default service config, which
+// will be used in cases where:
+// 1. WithDisableServiceConfig is called.
+// 2. Resolver does not return service config or if the resolver gets and invalid config.
+func WithDefaultServiceConfig(s string) DialOption {
+	return newFuncDialOption(func(o *dialOptions) {
+		sc, err := parseServiceConfig(s)
+		if err != nil {
+			grpclog.Warningf("the provided service config is invalid, err: %v", err)
+			return
+		}
+		o.defaultServiceConfig = &sc
+		o.defaultServiceConfigRaw = s
+	})
+}
+
 // WithDisableRetry returns a DialOption that disables retries, even if the
 // service config enables them.  This does not impact transparent retries, which
 // will happen automatically if no data is written to the wire or if the RPC is

resolver_conn_wrapper.go

@@ -102,7 +102,7 @@ func (ccr *ccResolverWrapper) close() {
 	close(ccr.done)
 }
 
-// NewAddress is called by the resolver implemenetion to send addresses to gRPC.
+// NewAddress is called by the resolver implementation to send addresses to gRPC.
 func (ccr *ccResolverWrapper) NewAddress(addrs []resolver.Address) {
 	select {
 	case <-ccr.done:
@@ -116,7 +116,7 @@ func (ccr *ccResolverWrapper) NewAddress(addrs []resolver.Address) {
 	ccr.cc.handleResolvedAddrs(addrs, nil)
 }
 
-// NewServiceConfig is called by the resolver implemenetion to send service
+// NewServiceConfig is called by the resolver implementation to send service
 // configs to gRPC.
 func (ccr *ccResolverWrapper) NewServiceConfig(sc string) {
 	select {

test/channelz_test.go

@@ -1555,7 +1555,7 @@ func (s) TestCZChannelAddressResolutionChange(t *testing.T) {
                 {
                     "service": "grpc.testing.TestService",
                     "method": "EmptyCall"
-                },
+                }
             ],
             "waitForReady": false,
             "timeout": ".001s"