transport,grpc: Integrate delegating resolver and introduce dial options for target host resolution

clientconn.go

@@ -226,11 +226,11 @@ 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.
 	//
-	// WithTargetResolutionEnabled dial option in `grpc.Dial` ensures that it
+	// WithLocalDNSResolution dial option in `grpc.Dial` ensures that it
 	// preserves behavior: when default scheme passthrough is used, skip
 	// hostname resolution, when "dns" is used for resolution, perform
 	// resolution on the client.
-	opts = append([]DialOption{withDefaultScheme("passthrough"), WithTargetResolutionEnabled()}, opts...)
+	opts = append([]DialOption{withDefaultScheme("passthrough"), WithLocalDNSResolution()}, opts...)
 	cc, err := NewClient(target, opts...)
 	if err != nil {
 		return nil, err
@@ -1327,7 +1327,6 @@ func (ac *addrConn) tryAllAddrs(ctx context.Context, addrs []resolver.Address, c
 		if err == nil {
 			return nil
 		}
-
 		if firstConnErr == nil {
 			firstConnErr = err
 		}

dialoptions.go

@@ -94,7 +94,7 @@ type dialOptions struct {
 	idleTimeout                 time.Duration
 	defaultScheme               string
 	maxCallAttempts             int
-	targetResolutionEnabled     bool // Specifies if target hostnames should be resolved when proxying is enabled.
+	enableLocalDNSResolution    bool // Specifies if target hostnames should be resolved when proxying is enabled.
 	useProxy                    bool // Specifies if a server should be connected via proxy.
 }
 
@@ -383,17 +383,18 @@ func WithNoProxy() DialOption {
 	})
 }
 
-// WithTargetResolutionEnabled returns a DialOption which enables target
-// resolution on client when a proxy is used along with the the "dns" scheme.
-// This is ignored if WithNoProxy is used.
+// WithLocalDNSResolution forces local DNS name resolution even when a proxy is
+// specified in the environment.  By default, the server name is provided
+// directly to the proxy as part of the CONNECT handshake. This is ignored if
+// WithNoProxy is used.
 //
 // # Experimental
 //
 // Notice: This API is EXPERIMENTAL and may be changed or removed in a
 // later release.
-func WithTargetResolutionEnabled() DialOption {
+func WithLocalDNSResolution() DialOption {
 	return newFuncDialOption(func(o *dialOptions) {
-		o.targetResolutionEnabled = true
+		o.enableLocalDNSResolution = true
 	})
 }
 
@@ -686,12 +687,12 @@ func defaultDialOptions() dialOptions {
 			UserAgent:       grpcUA,
 			BufferPool:      mem.DefaultBufferPool(),
 		},
-		bs:                      internalbackoff.DefaultExponential,
-		idleTimeout:             30 * time.Minute,
-		defaultScheme:           "dns",
-		maxCallAttempts:         defaultMaxCallAttempts,
-		useProxy:                true,
-		targetResolutionEnabled: false,
+		bs:                       internalbackoff.DefaultExponential,
+		idleTimeout:              30 * time.Minute,
+		defaultScheme:            "dns",
+		maxCallAttempts:          defaultMaxCallAttempts,
+		useProxy:                 true,
+		enableLocalDNSResolution: false,
 	}
 }
 

internal/transport/testutils/testutils.go → internal/testutils/proxy.go

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright 2024 gRPC authors.
+ * Copyright 2023 gRPC authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,6 @@
  *
  */
 
-// Package testutils contains helpers for transport tests.
 package testutils
 
 import (
@@ -28,12 +27,8 @@
 	"net/http"
 	"testing"
 	"time"
-
-	"google.golang.org/grpc/internal/testutils"
 )
 
-const defaultTestTimeout = 10 * time.Second
-
 // ProxyServer represents a test proxy server.
 type ProxyServer struct {
 	lis       net.Listener
@@ -43,6 +38,8 @@
 	Addr      string              // Address of the proxy
 }
 
+const defaultTestTimeout = 10 * time.Second
+
 // Stop closes the ProxyServer and its connections to client and server.
 func (p *ProxyServer) stop() {
 	p.lis.Close()
@@ -57,12 +54,12 @@
 func (p *ProxyServer) handleRequest(t *testing.T, in net.Conn, waitForServerHello bool) {
 	req, err := http.ReadRequest(bufio.NewReader(in))
 	if err != nil {
 		t.Errorf("failed to read CONNECT req: %v", err)
 		return
 	}
 	if req.Method != http.MethodConnect {
 		t.Errorf("unexpected Method %q, want %q", req.Method, http.MethodConnect)
 	}
 	p.onRequest(req)
 
 	t.Logf("Dialing to %s", req.URL.Host)
@@ -85,11 +82,11 @@
 		b := make([]byte, 50)
 		bytesRead, err := out.Read(b)
 		if err != nil {
 			t.Errorf("Got error while reading server hello: %v", err)
 			in.Close()
 			out.Close()
 			return
 		}
 		buf.Write(b[0:bytesRead])
 	}
 	p.in = in
@@ -104,10 +101,10 @@
 // stop it, and returns the proxy's listener and helper channels.
 func HTTPProxy(t *testing.T, reqCheck func(*http.Request), waitForServerHello bool) *ProxyServer {
 	t.Helper()
-	pLis, err := testutils.LocalTCPListener()
+	pLis, err := LocalTCPListener()
 	if err != nil {
 		t.Fatalf("failed to listen: %v", err)
 	}
 
 	p := &ProxyServer{
 		lis:       pLis,
@@ -128,6 +125,6 @@
 	}()
 	t.Logf("Started proxy at: %q", pLis.Addr())
 	t.Cleanup(p.stop)
-	p.Addr = fmt.Sprintf("localhost:%d", testutils.ParsePort(t, pLis.Addr().String()))
+	p.Addr = fmt.Sprintf("localhost:%d", ParsePort(t, pLis.Addr().String()))
 	return p
 }

internal/transport/http2_client.go

@@ -156,10 +156,6 @@ type http2Client struct {
 
 func dial(ctx context.Context, fn func(context.Context, string) (net.Conn, error), addr resolver.Address, grpcUA string) (net.Conn, error) {
 	address := addr.Addr
-
-	if opts, present := proxyattributes.Get(addr); present {
-		return proxyDial(ctx, addr, grpcUA, opts)
-	}
 	networkType, ok := networktype.Get(addr)
 	if fn != nil {
 		// Special handling for unix scheme with custom dialer. Back in the day,
@@ -182,6 +178,9 @@ func dial(ctx context.Context, fn func(context.Context, string) (net.Conn, error
 	if !ok {
 		networkType, address = parseDialTarget(address)
 	}
+	if opts, present := proxyattributes.Get(addr); present {
+		return proxyDial(ctx, addr, grpcUA, opts)
+	}
 	return internal.NetDialerWithTCPKeepalive().DialContext(ctx, networkType, address)
 }
 

internal/transport/proxy_ext_test.go

@@ -36,7 +36,6 @@ import (
 	"google.golang.org/grpc/internal/resolver/delegatingresolver"
 	"google.golang.org/grpc/internal/stubserver"
 	"google.golang.org/grpc/internal/testutils"
-	transporttestutils "google.golang.org/grpc/internal/transport/testutils"
 	testgrpc "google.golang.org/grpc/interop/grpc_testing"
 	"google.golang.org/grpc/resolver"
 	"google.golang.org/grpc/resolver/manual"
@@ -88,7 +87,7 @@ func (s) TestGRPCDialWithProxy(t *testing.T) {
 			t.Errorf(" Unexpected request host: %s , want = %s ", got, want)
 		}
 	}
-	pServer := transporttestutils.HTTPProxy(t, reqCheck, false)
+	pServer := testutils.HTTPProxy(t, reqCheck, false)
 
 	// Overwrite the function in the test and restore them in defer.
 	hpfe := func(req *http.Request) (*url.URL, error) {
@@ -145,7 +144,7 @@ func (s) TestGRPCDialWithDNSAndProxy(t *testing.T) {
 			t.Errorf("isIPAddr(%q) = %t, want = %t", host, got, want)
 		}
 	}
-	pServer := transporttestutils.HTTPProxy(t, reqCheck, false)
+	pServer := testutils.HTTPProxy(t, reqCheck, false)
 
 	// Overwrite the function in the test and restore them in defer.
 	hpfe := func(req *http.Request) (*url.URL, error) {
@@ -200,7 +199,7 @@ func (s) TestNewClientWithProxy(t *testing.T) {
 			t.Errorf(" Unexpected request host: %s , want = %s ", got, want)
 		}
 	}
-	pServer := transporttestutils.HTTPProxy(t, reqCheck, false)
+	pServer := testutils.HTTPProxy(t, reqCheck, false)
 
 	// Overwrite the function in the test and restore them in defer.
 	hpfe := func(req *http.Request) (*url.URL, error) {
@@ -254,7 +253,7 @@ func (s) TestNewClientWithProxyAndCustomResolver(t *testing.T) {
 			t.Errorf("isIPAddr(%q) = %t, want = %t", host, got, want)
 		}
 	}
-	pServer := transporttestutils.HTTPProxy(t, reqCheck, false)
+	pServer := testutils.HTTPProxy(t, reqCheck, false)
 
 	// Overwrite the function in the test and restore them in defer.
 	hpfe := func(req *http.Request) (*url.URL, error) {
@@ -297,7 +296,7 @@ func (s) TestNewClientWithProxyAndCustomResolver(t *testing.T) {
 }
 
 // Tests the scenario where grpc.NewClient is used with the default "dns"
-// resolver and the dial option grpc.WithTargetResolutionEnabled() is set,
+// resolver and the dial option grpc.WithLocalDNSResolution() is set,
 // enabling target resolution on the client. The test verifies that target
 // resolution happens on the client by sending resolved target URI in HTTP
 // CONNECT request, the proxy URI is resolved correctly, and the connection is
@@ -316,7 +315,7 @@ func (s) TestNewClientWithProxyAndTargetResolutionEnabled(t *testing.T) {
 			t.Errorf("isIPAddr(%q) = %t, want = %t", host, got, want)
 		}
 	}
-	pServer := transporttestutils.HTTPProxy(t, reqCheck, false)
+	pServer := testutils.HTTPProxy(t, reqCheck, false)
 
 	// Overwrite the function in the test and restore them in defer.
 	hpfe := func(req *http.Request) (*url.URL, error) {
@@ -335,7 +334,7 @@ func (s) TestNewClientWithProxyAndTargetResolutionEnabled(t *testing.T) {
 
 	ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
 	defer cancel()
-	conn, err := grpc.NewClient(unresolvedTargetURI, grpc.WithTargetResolutionEnabled(), grpc.WithTransportCredentials(insecure.NewCredentials()))
+	conn, err := grpc.NewClient(unresolvedTargetURI, grpc.WithLocalDNSResolution(), grpc.WithTransportCredentials(insecure.NewCredentials()))
 	if err != nil {
 		t.Fatalf("grpc.NewClient(%s) failed: %v", unresolvedTargetURI, err)
 	}
@@ -361,7 +360,7 @@ func (s) TestNewClientWithNoProxy(t *testing.T) {
 	backend := startBackendServer(t)
 	unresolvedTargetURI := fmt.Sprintf("localhost:%d", testutils.ParsePort(t, backend.Address))
 	reqCheck := func(_ *http.Request) { t.Error("proxy server should not have received a Connect request") }
-	pServer := transporttestutils.HTTPProxy(t, reqCheck, false)
+	pServer := testutils.HTTPProxy(t, reqCheck, false)
 
 	// Overwrite the function in the test and restore them in defer.
 	hpfe := func(req *http.Request) (*url.URL, error) {
@@ -406,7 +405,7 @@ func (s) TestNewClientWithContextDialer(t *testing.T) {
 	backend := startBackendServer(t)
 	unresolvedTargetURI := fmt.Sprintf("localhost:%d", testutils.ParsePort(t, backend.Address))
 	reqCheck := func(_ *http.Request) { t.Error("proxy server should not have received a Connect request") }
-	pServer := transporttestutils.HTTPProxy(t, reqCheck, false)
+	pServer := testutils.HTTPProxy(t, reqCheck, false)
 
 	// Overwrite the function in the test and restore them in defer.
 	hpfe := func(req *http.Request) (*url.URL, error) {
@@ -475,7 +474,7 @@ func (s) TestBasicAuthInNewClientWithProxy(t *testing.T) {
 			t.Errorf("unexpected auth %q (%q), want %q (%q)", got, gotDecoded, wantProxyAuthStr, wantDecoded)
 		}
 	}
-	pServer := transporttestutils.HTTPProxy(t, reqCheck, false)
+	pServer := testutils.HTTPProxy(t, reqCheck, false)
 
 	t.Setenv("HTTPS_PROXY", user+":"+password+"@"+pServer.Addr)
 

internal/transport/proxy_test.go

@@ -31,7 +31,6 @@ import (
 
 	"google.golang.org/grpc/internal/proxyattributes"
 	"google.golang.org/grpc/internal/testutils"
-	transporttestutils "google.golang.org/grpc/internal/transport/testutils"
 	"google.golang.org/grpc/resolver"
 )
 
@@ -54,7 +53,7 @@ func (s) TestHTTPConnectWithServerHello(t *testing.T) {
 			t.Error(err)
 		}
 	}
-	pServer := transporttestutils.HTTPProxy(t, reqCheck, true)
+	pServer := testutils.HTTPProxy(t, reqCheck, true)
 
 	msg := []byte{4, 3, 5, 2}
 	recvBuf := make([]byte, len(msg))

resolver_wrapper.go

@@ -80,14 +80,14 @@ func (ccr *ccResolverWrapper) start() error {
 		}
 		var err error
 		// The delegating resolver is used unless:
-		//   - A custom dialer is provided via WithContextDialer dialoption.
+		//   - A custom dialer is provided via WithContextDialer dialoption or
 		//   - Proxy usage is disabled through WithNoProxy dialoption.
 		// In these cases, the resolver is built based on the scheme of target,
 		// using the appropriate resolver builder.
 		if ccr.cc.dopts.copts.Dialer != nil || !ccr.cc.dopts.useProxy {
 			ccr.resolver, err = ccr.cc.resolverBuilder.Build(ccr.cc.parsedTarget, ccr, opts)
 		} else {
-			ccr.resolver, err = delegatingresolver.New(ccr.cc.parsedTarget, ccr, opts, ccr.cc.resolverBuilder, ccr.cc.dopts.targetResolutionEnabled)
+			ccr.resolver, err = delegatingresolver.New(ccr.cc.parsedTarget, ccr, opts, ccr.cc.resolverBuilder, ccr.cc.dopts.enableLocalDNSResolution)
 		}
 		errCh <- err
 	})