fix: remove all user visisble changes aside from new NewClient func

Author: bruuuuuuuce

balancer/rls/config.go

@@ -195,13 +195,13 @@ func parseRLSProto(rlsProto *rlspb.RouteLookupConfig) (*lbConfig, error) {
 	parsedTarget, err := url.Parse(lookupService)
 	if err != nil {
 		// url.Parse() fails if scheme is missing. Retry with default scheme.
-		parsedTarget, err = url.Parse(resolver.GetDefaultSchemeOrPassthrough() + ":///" + lookupService)
+		parsedTarget, err = url.Parse(resolver.GetDefaultScheme() + ":///" + lookupService)
 		if err != nil {
 			return nil, fmt.Errorf("rls: invalid target URI in lookup_service %s", lookupService)
 		}
 	}
 	if parsedTarget.Scheme == "" {
-		parsedTarget.Scheme = resolver.GetDefaultSchemeOrPassthrough()
+		parsedTarget.Scheme = resolver.GetDefaultScheme()
 	}
 	if resolver.Get(parsedTarget.Scheme) == nil {
 		return nil, fmt.Errorf("rls: unregistered scheme in lookup_service %s", lookupService)

clientconn.go

@@ -117,12 +117,11 @@ func (dcs *defaultConfigSelector) SelectConfig(rpcInfo iresolver.RPCInfo) (*ires
 	}, nil
 }
 
-// NewClient returns a new client in idle mode.
-func NewClient(target string, opts ...DialOption) (conn *ClientConn, err error) {
+func newClient(target, defaultScheme string, opts ...DialOption) (conn *ClientConn, err error) {
 	cc := &ClientConn{
 		target: target,
 		conns:  make(map[*addrConn]struct{}),
-		dopts:  defaultDialOptions(),
+		dopts:  defaultDialOptions(defaultScheme),
 		czData: new(channelzData),
 	}
 
@@ -191,6 +190,11 @@ func NewClient(target string, opts ...DialOption) (conn *ClientConn, err error)
 	return cc, nil
 }
 
+// NewClient returns a new client in idle mode.
+func NewClient(target string, opts ...DialOption) (conn *ClientConn, err error) {
+	return newClient(target, "dns", opts...)
+}
+
 // DialContext creates a client connection to the given target. By default, it's
 // a non-blocking dial (the function won't wait for connections to be
 // established, and connecting happens in the background). To make it a blocking
@@ -211,8 +215,7 @@ func DialContext(ctx context.Context, target string, opts ...DialOption) (conn *
 	// At the end of this method, we kick the channel out of idle, rather than waiting for the first rpc.
 	// The eagerConnect option is used to tell the ClientChannel that DialContext was called to make
 	// this channel, and hence tries to connect immediately.
-	opts = append(opts, WithEagerConnect())
-	cc, err := NewClient(target, opts...)
+	cc, err := newClient(target, "passthrough", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -1746,9 +1749,9 @@ func (cc *ClientConn) parseTargetAndFindResolver() error {
 	// scheme, except when a custom dialer is specified in which case, we should
 	// always use passthrough scheme. For either case, we need to respect any overridden
 	// global defaults set by the user.
-	defScheme := resolver.GetDefaultSchemeOrDNS()
-	if cc.dopts.eagerConnect {
-		defScheme = resolver.GetDefaultSchemeOrPassthrough()
+	defScheme := cc.dopts.defScheme
+	if defScheme == "" || internal.UserSetDefaultScheme {
+		defScheme = resolver.GetDefaultScheme()
 	}
 
 	channelz.Infof(logger, cc.channelzID, "fallback to scheme %q", defScheme)

clientconn_parsed_target_test.go

@@ -34,7 +34,7 @@ import (
 )
 
 func (s) TestParsedTarget_Success_WithoutCustomDialer(t *testing.T) {
-	defScheme := resolver.GetDefaultSchemeOrPassthrough()
+	defScheme := resolver.GetDefaultScheme()
 	tests := []struct {
 		target     string
 		wantParsed resolver.Target
@@ -93,7 +93,7 @@ func (s) TestParsedTarget_Failure_WithoutCustomDialer(t *testing.T) {
 }
 
 func (s) TestParsedTarget_WithCustomDialer(t *testing.T) {
-	defScheme := resolver.GetDefaultSchemeOrPassthrough()
+	defScheme := resolver.GetDefaultScheme()
 	tests := []struct {
 		target            string
 		wantParsed        resolver.Target

dialoptions.go

@@ -79,7 +79,7 @@ type dialOptions struct {
 	resolvers                   []resolver.Builder
 	idleTimeout                 time.Duration
 	recvBufferPool              SharedBufferPool
-	eagerConnect                bool
+	defScheme                   string
 }
 
 // DialOption configures how we set up the connection.
@@ -488,15 +488,6 @@ func WithUserAgent(s string) DialOption {
 	})
 }
 
-// WithEagerConnect tells the ClientConnection that the connection was created directly
-// with either Dial or DialContext, meaning that the connection is automatically put into
-// a connecting state.
-func WithEagerConnect() DialOption {
-	return newFuncDialOption(func(o *dialOptions) {
-		o.eagerConnect = true
-	})
-}
-
 // WithKeepaliveParams returns a DialOption that specifies keepalive parameters
 // for the client transport.
 func WithKeepaliveParams(kp keepalive.ClientParameters) DialOption {
@@ -641,7 +632,7 @@ func withHealthCheckFunc(f internal.HealthChecker) DialOption {
 	})
 }
 
-func defaultDialOptions() dialOptions {
+func defaultDialOptions(defScheme string) dialOptions {
 	return dialOptions{
 		copts: transport.ConnectOptions{
 			ReadBufferSize:  defaultReadBufSize,
@@ -653,6 +644,7 @@ func defaultDialOptions() dialOptions {
 		healthCheckFunc: internal.HealthCheckFunc,
 		idleTimeout:     30 * time.Minute,
 		recvBufferPool:  nopBufferPool{},
+		defScheme:       defScheme,
 	}
 }
 

internal/internal.go

@@ -197,6 +197,9 @@ var (
 
 	// FromOutgoingContextRaw returns the un-merged, intermediary contents of metadata.rawMD.
 	FromOutgoingContextRaw any // func(context.Context) (metadata.MD, [][]string, bool)
+
+	// UserSetDefaultScheme is set to true if the user has overridden the default resolver scheme.
+	UserSetDefaultScheme bool
 )
 
 // HealthChecker defines the signature of the client-side LB channel health checking function.

resolver/resolver.go

@@ -23,6 +23,7 @@ package resolver
 import (
 	"context"
 	"fmt"
+	"google.golang.org/grpc/internal"
 	"net"
 	"net/url"
 	"strings"
@@ -36,9 +37,7 @@ var (
 	// m is a map from scheme to resolver builder.
 	m = make(map[string]Builder)
 	// defaultScheme is the default scheme to use.
-	defaultScheme     = ""
-	passthroughScheme = "passthrough"
-	dnsScheme         = "dns"
+	defaultScheme = "dns"
 )
 
 // TODO(bar) install dns resolver in init(){}.
@@ -65,32 +64,19 @@ func Get(scheme string) Builder {
 }
 
 // SetDefaultScheme sets the default scheme that will be used. The default
-// default scheme is "passthrough".
+// scheme is "dns".
 //
 // NOTE: this function must only be called during initialization time (i.e. in
 // an init() function), and is not thread-safe. The scheme set last overrides
 // previously set values.
 func SetDefaultScheme(scheme string) {
+	internal.UserSetDefaultScheme = true
 	defaultScheme = scheme
 }
 
-// GetDefaultSchemeOrPassthrough gets the default scheme that will be used, if no scheme was
-// overridden, defaults to the "passthrough" scheme. This scheme is used when directly calling
-// the Dial method to create a client connection.
-func GetDefaultSchemeOrPassthrough() string {
-	if defaultScheme == "" {
-		return passthroughScheme
-	}
-	return defaultScheme
-}
-
-// GetDefaultSchemeOrDNS gets the default scheme that will be used, if no scheme was overridden,
-// defaults to the "dns" scheme. This is the default scheme when calling NewClient to generate a
-// new client connection.
-func GetDefaultSchemeOrDNS() string {
-	if defaultScheme == "" {
-		return dnsScheme
-	}
+// GetDefaultScheme gets the default scheme that will be used, if no scheme was
+// overridden, defaults to the "dns" scheme.
+func GetDefaultScheme() string {
 	return defaultScheme
 }