go lint

Signed-off-by: LiZhenCheng9527 <[email protected]>

Author: LiZhenCheng9527

pkg/dns/ads_handler.go

@@ -20,7 +20,6 @@ import (
 	"net"
 	"net/netip"
 	"slices"
-	"time"
 
 	clusterv3 "github.com/envoyproxy/go-control-plane/envoy/config/cluster/v3"
 	v3 "github.com/envoyproxy/go-control-plane/envoy/config/core/v3"
@@ -88,8 +87,12 @@ func (adsResolver *AdsDnsResolver) refreshAdsDns() bool {
 		return true
 	}
 	// adsResolver.DnsResolver.resolve(e)
-	addres, ttl := adsResolver.DnsResolver.resolve(e)
-	adsResolver.adsDnsResolve(e, addres, ttl)
+	addresses, err := adsResolver.DnsResolver.resolve(e)
+	if err != nil {
+		log.Errorf("failed to dns resolve: %v", err)
+		return false
+	}
+	adsResolver.adsDnsResolve(e, addresses)
 	adsResolver.adsCache.ClusterCache.Flush()
 	return true
 }
@@ -99,13 +102,7 @@ func (adsResolver *AdsDnsResolver) refreshAdsWorker() {
 	}
 }
 
-func (adsResolver *AdsDnsResolver) adsDnsResolve(domain *pendingResolveDomain, addrs []string, ttl time.Duration) {
-	if ttl > domain.refreshRate {
-		ttl = domain.refreshRate
-	}
-	if ttl == 0 {
-		ttl = DeRefreshInterval
-	}
+func (adsResolver *AdsDnsResolver) adsDnsResolve(domain *pendingResolveDomain, addrs []string) {
 	for _, c := range domain.clusters {
 		ready := overwriteDnsCluster(c, domain.domainName, addrs)
 		if ready {
@@ -115,7 +112,6 @@ func (adsResolver *AdsDnsResolver) adsDnsResolve(domain *pendingResolveDomain, a
 			}
 		}
 	}
-	return
 }
 
 func overwriteDnsCluster(cluster *clusterv3.Cluster, domain string, addrs []string) bool {

pkg/dns/dns.go

@@ -100,20 +100,26 @@ func (r *DNSResolver) removeUnwatchedDomain(domains map[string]*pendingResolveDo
 }
 
 // This functions were copied and adapted from github.com/istio/istio/pilot/pkg/model/network.go.
-func (r *DNSResolver) resolve(v *pendingResolveDomain) ([]string, time.Duration) {
+func (r *DNSResolver) resolve(v *pendingResolveDomain) ([]string, error) {
 	r.RLock()
 	entry := r.cache[v.domainName]
 	// This can happen when the domain is deleted before the refresher tick reaches
 	if entry == nil {
 		r.RUnlock()
-		return []string{}, time.Duration(0)
+		return []string{}, fmt.Errorf("cache entry for domain %s not found", v.domainName)
 	}
 	r.RUnlock()
 
 	addrs, ttl, err := r.doResolve(v.domainName, v.refreshRate)
 	if err != nil {
-		log.Errorf("dns resolve failed: %v", err)
-		return []string{}, time.Duration(0)
+		return []string{}, fmt.Errorf("dns resolve failed: %v", err)
+	}
+
+	if ttl > v.refreshRate {
+		ttl = v.refreshRate
+	}
+	if ttl == 0 {
+		ttl = DeRefreshInterval
 	}
 
 	r.RLock()
@@ -122,7 +128,7 @@ func (r *DNSResolver) resolve(v *pendingResolveDomain) ([]string, time.Duration)
 
 	// push to refresh queue
 	r.dnsRefreshQueue.AddAfter(v, ttl)
-	return addrs, ttl
+	return addrs, nil
 }
 
 // resolveDomains takes a slice of cluster

pkg/dns/dns_test.go

@@ -43,15 +43,6 @@ type fakeDNSServer struct {
 	hosts map[string]int
 }
 
-func (r *DNSResolver) GetDNSAddresses(domain string) []string {
-	r.Lock()
-	defer r.Unlock()
-	if entry, ok := r.cache[domain]; ok {
-		return entry.addresses
-	}
-	return nil
-}
-
 func TestDNS(t *testing.T) {
 	fakeDNSServer := newFakeDNSServer()
 
@@ -63,7 +54,8 @@ func TestDNS(t *testing.T) {
 	stopCh := make(chan struct{})
 	defer close(stopCh)
 	testDNSResolver.StartAdsDnsResolver(stopCh)
-	testDNSResolver.DnsResolver.resolvConfServers = []string{fakeDNSServer.Server.PacketConn.LocalAddr().String()}
+	dnsServer := fakeDNSServer.Server.PacketConn.LocalAddr().String()
+	testDNSResolver.DnsResolver.resolvConfServers = []string{dnsServer}
 
 	testCases := []struct {
 		name             string
@@ -229,16 +221,6 @@ func (s *fakeDNSServer) ServeDNS(w dns.ResponseWriter, r *dns.Msg) {
 	}
 }
 
-func (r *DNSResolver) GetAllCachedDomains() []string {
-	r.RLock()
-	defer r.RUnlock()
-	out := make([]string, 0, len(r.cache))
-	for domain := range r.cache {
-		out = append(out, domain)
-	}
-	return out
-}
-
 func (s *fakeDNSServer) setHosts(domain string, surfix int) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -251,6 +233,25 @@ func (s *fakeDNSServer) setTTL(ttl uint32) {
 	s.ttl = ttl
 }
 
+func (r *DNSResolver) GetAllCachedDomains() []string {
+	r.RLock()
+	defer r.RUnlock()
+	out := make([]string, 0, len(r.cache))
+	for domain := range r.cache {
+		out = append(out, domain)
+	}
+	return out
+}
+
+func (r *DNSResolver) GetDNSAddresses(domain string) []string {
+	r.Lock()
+	defer r.Unlock()
+	if entry, ok := r.cache[domain]; ok {
+		return entry.addresses
+	}
+	return nil
+}
+
 func TestGetPendingResolveDomain(t *testing.T) {
 	utCluster := clusterv3.Cluster{
 		Name: "testCluster",