internal/delegatingresolver: avoid proxy if networktype of target address is not tcp

internal/resolver/delegatingresolver/delegatingresolver.go

@@ -28,6 +28,8 @@ import (
 
 	"google.golang.org/grpc/grpclog"
 	"google.golang.org/grpc/internal/proxyattributes"
+	"google.golang.org/grpc/internal/transport"
+	"google.golang.org/grpc/internal/transport/networktype"
 	"google.golang.org/grpc/resolver"
 	"google.golang.org/grpc/serviceconfig"
 )
@@ -44,9 +46,10 @@ var (
 //
 // It implements the [resolver.Resolver] interface.
 type delegatingResolver struct {
-	target   resolver.Target     // parsed target URI to be resolved
-	cc       resolver.ClientConn // gRPC ClientConn
-	proxyURL *url.URL            // proxy URL, derived from proxy environment and target
+	target          resolver.Target     // parsed target URI to be resolved
+	cc              resolver.ClientConn // gRPC ClientConn
+	proxyURL        *url.URL            // proxy URL, derived from proxy environment and target
+	proxyResolverCh chan struct{}       // closed once the proxy resolver has been created
 
 	mu                  sync.Mutex         // protects all the fields below
 	targetResolverState *resolver.State    // state of the target resolver
@@ -95,8 +98,9 @@ func proxyURLForTarget(address string) (*url.URL, error) {
 //     resolution is enabled using the dial option.
 func New(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOptions, targetResolverBuilder resolver.Builder, targetResolutionEnabled bool) (resolver.Resolver, error) {
 	r := &delegatingResolver{
-		target: target,
-		cc:     cc,
+		target:          target,
+		cc:              cc,
+		proxyResolverCh: make(chan struct{}),
 	}
 
 	var err error
@@ -128,6 +132,7 @@ func New(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOpti
 			Endpoints: []resolver.Endpoint{{Addresses: []resolver.Address{{Addr: target.Endpoint()}}}},
 		}
 		r.targetResolverState = &state
+		r.updateTargetResolverState(*r.targetResolverState)
 	} else {
 		wcc := &wrappingClientConn{
 			stateListener: r.updateTargetResolverState,
@@ -138,10 +143,6 @@ func New(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOpti
 		}
 	}
 
-	if r.proxyResolver, err = r.proxyURIResolver(opts); err != nil {
-		return nil, fmt.Errorf("delegating_resolver: failed to build resolver for proxy URL %q: %v", r.proxyURL, err)
-	}
-
 	if r.targetResolver == nil {
 		r.targetResolver = nopResolver{}
 	}
@@ -174,27 +175,55 @@ func (r *delegatingResolver) proxyURIResolver(opts resolver.BuildOptions) (resol
 
 func (r *delegatingResolver) ResolveNow(o resolver.ResolveNowOptions) {
 	r.childMu.Lock()
-	defer r.childMu.Unlock()
 	r.targetResolver.ResolveNow(o)
-	r.proxyResolver.ResolveNow(o)
+	r.childMu.Unlock()
+	if _, ok := <-r.proxyResolverCh; !ok {
+		r.childMu.Lock()
+		r.proxyResolver.ResolveNow(o)
+		r.childMu.Unlock()
+	}
+
 }
 
 func (r *delegatingResolver) Close() {
 	r.childMu.Lock()
 	defer r.childMu.Unlock()
 	r.targetResolver.Close()
 	r.targetResolver = nil
-
 	r.proxyResolver.Close()
 	r.proxyResolver = nil
 }
 
-// updateClientConnStateLocked creates a list of combined addresses by
-// pairing each proxy address with every target address. For each pair, it
-// generates a new [resolver.Address] using the proxy address, and adding the
-// target address as the attribute along with user info. It returns nil if
-// either resolver has not sent update even once and returns the error from
-// ClientConn update once both resolvers have sent update atleast once.
+func networkTypeFromAddr(addr resolver.Address) (string, resolver.Address) {
+	networkType, ok := networktype.Get(addr)
+	if !ok {
+		networkType, addr.Addr = transport.ParseDialTarget(addr.Addr)
+	}
+	return networkType, addr
+}
+
+func tcpAddressPresent(state *resolver.State) bool {
+	for _, addr := range state.Addresses {
+		if networkType, _ := networkTypeFromAddr(addr); networkType == "tcp" {
+			return true
+		}
+	}
+	for _, endpoint := range state.Endpoints {
+		for _, addr := range endpoint.Addresses {
+			if networktype, _ := networkTypeFromAddr(addr); networktype == "tcp" {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// updateClientConnStateLocked creates a list of combined addresses by pairing
+// each proxy address with every target address. For each pair, it generates a
+// new [resolver.Address] using the proxy address, and adding the target address
+// as the attribute along with user info. It returns nil if either resolver has
+// not sent update even once and returns the error from ClientConn update once
+// both resolvers have sent update atleast once.
 func (r *delegatingResolver) updateClientConnStateLocked() error {
 	if r.targetResolverState == nil || r.proxyAddrs == nil {
 		return nil
@@ -217,7 +246,12 @@ func (r *delegatingResolver) updateClientConnStateLocked() error {
 		proxyAddr = resolver.Address{Addr: r.proxyURL.Host}
 	}
 	var addresses []resolver.Address
-	for _, targetAddr := range (*r.targetResolverState).Addresses {
+	for _, targetAddr := range curState.Addresses {
+		// Avoid proxy when network is not tcp.
+		if networkType, targetAddr := networkTypeFromAddr(targetAddr); networkType != "tcp" {
+			addresses = append(addresses, targetAddr)
+			continue
+		}
 		addresses = append(addresses, proxyattributes.Set(proxyAddr, proxyattributes.Options{
 			User:        r.proxyURL.User,
 			ConnectAddr: targetAddr.Addr,
@@ -232,10 +266,15 @@ func (r *delegatingResolver) updateClientConnStateLocked() error {
 	// address.The resulting list of addresses is then grouped into endpoints,
 	// covering all combinations of proxy and target endpoints.
 	var endpoints []resolver.Endpoint
-	for _, endpt := range (*r.targetResolverState).Endpoints {
+	for _, endpt := range curState.Endpoints {
 		var addrs []resolver.Address
-		for _, proxyAddr := range r.proxyAddrs {
-			for _, targetAddr := range endpt.Addresses {
+		for _, targetAddr := range endpt.Addresses {
+			// Avoid proxy when network is not tcp.
+			if networkType, targetAddr := networkTypeFromAddr(targetAddr); networkType != "tcp" {
+				addrs = append(addrs, targetAddr)
+				continue
+			}
+			for _, proxyAddr := range r.proxyAddrs {
 				addrs = append(addrs, proxyattributes.Set(proxyAddr, proxyattributes.Options{
 					User:        r.proxyURL.User,
 					ConnectAddr: targetAddr.Addr,
@@ -297,8 +336,8 @@ func (r *delegatingResolver) updateProxyResolverState(state resolver.State) erro
 // updateTargetResolverState updates the target resolver state by storing target
 // addresses, endpoints, and service config, marking the resolver as ready, and
 // triggering a state update if both resolvers are ready. If the ClientConn
-// returns a non-nil error, it calls `ResolveNow()` on the proxy resolver. It
-// is a StateListener function of wrappingClientConn passed to the target resolver.
+// returns a non-nil error, it calls `ResolveNow()` on the proxy resolver. It is
+// a StateListener function of wrappingClientConn passed to the target resolver.
 func (r *delegatingResolver) updateTargetResolverState(state resolver.State) error {
 	r.mu.Lock()
 	defer r.mu.Unlock()
@@ -307,6 +346,22 @@ func (r *delegatingResolver) updateTargetResolverState(state resolver.State) err
 		logger.Infof("Addresses received from target resolver: %v", state.Addresses)
 	}
 	r.targetResolverState = &state
+	// If no addresses returned by resolver have network type as tcp , do not
+	// wait for proxy update.
+	if !tcpAddressPresent(r.targetResolverState) {
+		return r.cc.UpdateState(*r.targetResolverState)
+	}
+
+	go func() {
+		r.childMu.Lock()
+		defer r.childMu.Unlock()
+		_, ok := r.proxyResolver.(nopResolver)
+		if r.proxyResolver == nil || ok {
+			r.proxyResolver, _ = r.proxyURIResolver(resolver.BuildOptions{})
+			close(r.proxyResolverCh)
+		}
+	}()
+
 	err := r.updateClientConnStateLocked()
 	if err != nil {
 		go func() {
@@ -335,7 +390,8 @@ func (wcc *wrappingClientConn) UpdateState(state resolver.State) error {
 	return wcc.stateListener(state)
 }
 
-// ReportError intercepts errors from the child resolvers and passes them to ClientConn.
+// ReportError intercepts errors from the child resolvers and passes them to
+// ClientConn.
 func (wcc *wrappingClientConn) ReportError(err error) {
 	wcc.parent.cc.ReportError(err)
 }