chore: expose NewClient method to end users

clientconn.go

@@ -117,12 +117,11 @@
 	}, 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 @@
 	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
@@ -208,7 +212,10 @@
 // https://github.com/grpc/grpc/blob/master/doc/naming.md.
 // e.g. to use dns resolver, a "dns:///" prefix should be applied to the target.
 func DialContext(ctx context.Context, target string, opts ...DialOption) (conn *ClientConn, err error) {
-	cc, err := newClient(target, opts...)
+	// 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.
+	cc, err := newClient(target, "passthrough", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -705,6 +712,7 @@
 	internal.ExitIdleModeForTesting = func(cc *ClientConn) error {
 		return cc.idlenessMgr.ExitIdleMode()
 	}
+	internal.UserSetDefaultScheme = resolver.GetDefaultScheme() != "dns"
 }
 
 func (cc *ClientConn) maybeApplyDefaultServiceConfig(addrs []resolver.Address) {
@@ -1740,8 +1748,13 @@
 	// We are here because the user's dial target did not contain a scheme or
 	// specified an unregistered scheme. We should fallback to the default
 	// scheme, except when a custom dialer is specified in which case, we should
-	// always use passthrough scheme.
-	defScheme := resolver.GetDefaultScheme()
+	// always use passthrough scheme. For either case, we need to respect any overridden
+	// global defaults set by the user.
+	defScheme := cc.dopts.defScheme
+	if defScheme == "" || internal.UserSetDefaultScheme {
+		defScheme = resolver.GetDefaultScheme()
+	}
+
 	channelz.Infof(logger, cc.channelzID, "fallback to scheme %q", defScheme)
 	canonicalTarget := defScheme + ":///" + cc.target
 

clientconn_parsed_target_test.go

@@ -34,7 +34,7 @@ import (
 )
 
 func (s) TestParsedTarget_Success_WithoutCustomDialer(t *testing.T) {
-	defScheme := resolver.GetDefaultScheme()
+	defScheme := "passthrough"
 	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.GetDefaultScheme()
+	defScheme := "passthrough"
 	tests := []struct {
 		target            string
 		wantParsed        resolver.Target

dialoptions.go

@@ -79,6 +79,7 @@ type dialOptions struct {
 	resolvers                   []resolver.Builder
 	idleTimeout                 time.Duration
 	recvBufferPool              SharedBufferPool
+	defScheme                   string
 }
 
 // DialOption configures how we set up the connection.
@@ -631,7 +632,7 @@ func withHealthCheckFunc(f internal.HealthChecker) DialOption {
 	})
 }
 
-func defaultDialOptions() dialOptions {
+func defaultDialOptions(defScheme string) dialOptions {
 	return dialOptions{
 		copts: transport.ConnectOptions{
 			ReadBufferSize:  defaultReadBufSize,
@@ -643,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

@@ -36,7 +36,7 @@ var (
 	// m is a map from scheme to resolver builder.
 	m = make(map[string]Builder)
 	// defaultScheme is the default scheme to use.
-	defaultScheme = "passthrough"
+	defaultScheme = "dns"
 )
 
 // TODO(bar) install dns resolver in init(){}.
@@ -63,7 +63,7 @@ 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
@@ -72,7 +72,8 @@ func SetDefaultScheme(scheme string) {
 	defaultScheme = scheme
 }
 
-// GetDefaultScheme gets the default scheme that will be used.
+// GetDefaultScheme gets the default scheme that will be used, if no scheme was
+// overridden, defaults to the "dns" scheme.
 func GetDefaultScheme() string {
 	return defaultScheme
 }