DNS resolving with timeout.

dialoptions.go

@@ -77,6 +77,7 @@ type dialOptions struct {
 	defaultServiceConfig        *ServiceConfig // defaultServiceConfig is parsed from defaultServiceConfigRawJSON.
 	defaultServiceConfigRawJSON *string
 	resolvers                   []resolver.Builder
+	resolveTimeout              time.Duration
 	idleTimeout                 time.Duration
 	recvBufferPool              SharedBufferPool
 }
@@ -694,6 +695,13 @@ func WithIdleTimeout(d time.Duration) DialOption {
 	})
 }
 
+// WithResolveTimeout returns a DialOption that configures a DNS resolving timeout.
+func WithResolveTimeout(d time.Duration) DialOption {
+	return newFuncDialOption(func(o *dialOptions) {
+		o.resolveTimeout = d
+	})
+}
+
 // WithRecvBufferPool returns a DialOption that configures the ClientConn
 // to use the provided shared buffer pool for parsing incoming messages. Depending
 // on the application's workload, this could result in reduced memory allocation.

internal/resolver/dns/dns_resolver.go

@@ -30,7 +30,7 @@ import (
 	"strings"
 	"sync"
 	"time"
-
+	
 	grpclbstate "google.golang.org/grpc/balancer/grpclb/state"
 	"google.golang.org/grpc/grpclog"
 	"google.golang.org/grpc/internal/backoff"
@@ -77,14 +77,14 @@ var newNetResolver = func(authority string) (internal.NetResolver, error) {
 	if authority == "" {
 		return net.DefaultResolver, nil
 	}
-
+	
 	host, port, err := parseTarget(authority, defaultDNSSvrPort)
 	if err != nil {
 		return nil, err
 	}
-
+	
 	authorityWithPort := net.JoinHostPort(host, port)
-
+	
 	return &net.Resolver{
 		PreferGo: true,
 		Dial:     internal.AddressDialer(authorityWithPort),
@@ -100,36 +100,43 @@ type dnsBuilder struct{}
 
 // Build creates and starts a DNS resolver that watches the name resolution of
 // the target.
-func (b *dnsBuilder) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOptions) (resolver.Resolver, error) {
+func (b *dnsBuilder) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOptions) (
+	resolver.Resolver, error,
+) {
 	host, port, err := parseTarget(target.Endpoint(), defaultPort)
 	if err != nil {
 		return nil, err
 	}
-
+	
 	// IP address.
 	if ipAddr, ok := formatIP(host); ok {
 		addr := []resolver.Address{{Addr: ipAddr + ":" + port}}
 		cc.UpdateState(resolver.State{Addresses: addr})
 		return deadResolver{}, nil
 	}
-
+	
 	// DNS address (non-IP).
 	ctx, cancel := context.WithCancel(context.Background())
 	d := &dnsResolver{
 		host:                 host,
 		port:                 port,
+		timeout:              opts.Timeout,
 		ctx:                  ctx,
 		cancel:               cancel,
 		cc:                   cc,
 		rn:                   make(chan struct{}, 1),
 		disableServiceConfig: opts.DisableServiceConfig,
 	}
-
+
+	if d.timeout == 0 {
+		d.timeout = 1 * time.Minute
+	}
+
 	d.resolver, err = internal.NewNetResolver(target.URL.Host)
 	if err != nil {
 		return nil, err
 	}
-
+	
 	d.wg.Add(1)
 	go d.watcher()
 	return d, nil
@@ -152,6 +159,7 @@ type dnsResolver struct {
 	host     string
 	port     string
 	resolver internal.NetResolver
+	timeout  time.Duration
 	ctx      context.Context
 	cancel   context.CancelFunc
 	cc       resolver.ClientConn
@@ -195,7 +203,7 @@ func (d *dnsResolver) watcher() {
 		} else {
 			err = d.cc.UpdateState(*state)
 		}
-
+		
 		var waitTime time.Duration
 		if err == nil {
 			// Success resolving, wait for the next ResolveNow. However, also wait 30
@@ -221,18 +229,18 @@ func (d *dnsResolver) watcher() {
 	}
 }
 
-func (d *dnsResolver) lookupSRV() ([]resolver.Address, error) {
+func (d *dnsResolver) lookupSRV(ctx context.Context) ([]resolver.Address, error) {
 	if !EnableSRVLookups {
 		return nil, nil
 	}
 	var newAddrs []resolver.Address
-	_, srvs, err := d.resolver.LookupSRV(d.ctx, "grpclb", "tcp", d.host)
+	_, srvs, err := d.resolver.LookupSRV(ctx, "grpclb", "tcp", d.host)
 	if err != nil {
 		err = handleDNSError(err, "SRV") // may become nil
 		return nil, err
 	}
 	for _, s := range srvs {
-		lbAddrs, err := d.resolver.LookupHost(d.ctx, s.Target)
+		lbAddrs, err := d.resolver.LookupHost(ctx, s.Target)
 		if err != nil {
 			err = handleDNSError(err, "A") // may become nil
 			if err == nil {
@@ -269,8 +277,8 @@ func handleDNSError(err error, lookupType string) error {
 	return err
 }
 
-func (d *dnsResolver) lookupTXT() *serviceconfig.ParseResult {
-	ss, err := d.resolver.LookupTXT(d.ctx, txtPrefix+d.host)
+func (d *dnsResolver) lookupTXT(ctx context.Context) *serviceconfig.ParseResult {
+	ss, err := d.resolver.LookupTXT(ctx, txtPrefix+d.host)
 	if err != nil {
 		if envconfig.TXTErrIgnore {
 			return nil
@@ -284,7 +292,7 @@ func (d *dnsResolver) lookupTXT() *serviceconfig.ParseResult {
 	for _, s := range ss {
 		res += s
 	}
-
+	
 	// TXT record must have "grpc_config=" attribute in order to be used as
 	// service config.
 	if !strings.HasPrefix(res, txtAttribute) {
@@ -297,8 +305,8 @@ func (d *dnsResolver) lookupTXT() *serviceconfig.ParseResult {
 	return d.cc.ParseServiceConfig(sc)
 }
 
-func (d *dnsResolver) lookupHost() ([]resolver.Address, error) {
-	addrs, err := d.resolver.LookupHost(d.ctx, d.host)
+func (d *dnsResolver) lookupHost(ctx context.Context) ([]resolver.Address, error) {
+	addrs, err := d.resolver.LookupHost(ctx, d.host)
 	if err != nil {
 		err = handleDNSError(err, "A")
 		return nil, err
@@ -316,18 +324,24 @@ func (d *dnsResolver) lookupHost() ([]resolver.Address, error) {
 }
 
 func (d *dnsResolver) lookup() (*resolver.State, error) {
-	srv, srvErr := d.lookupSRV()
-	addrs, hostErr := d.lookupHost()
+	ctxSRV, cancelSRV := context.WithTimeout(d.ctx, d.timeout)
+	defer cancelSRV()
+	srv, srvErr := d.lookupSRV(ctxSRV)
+	ctxHost, cancelHost := context.WithTimeout(d.ctx, d.timeout)
+	defer cancelHost()
+	addrs, hostErr := d.lookupHost(ctxHost)
 	if hostErr != nil && (srvErr != nil || len(srv) == 0) {
 		return nil, hostErr
 	}
-
+	
 	state := resolver.State{Addresses: addrs}
 	if len(srv) > 0 {
 		state = grpclbstate.Set(state, &grpclbstate.State{BalancerAddresses: srv})
 	}
 	if !d.disableServiceConfig {
-		state.ServiceConfig = d.lookupTXT()
+		ctxTXT, cancelTXT := context.WithTimeout(d.ctx, d.timeout)
+		defer cancelTXT()
+		state.ServiceConfig = d.lookupTXT(ctxTXT)
 	}
 	return &state, nil
 }