Cache local DNS persistence settings and streamline flush/load guards

Author: masterking32

internal/client/client.go

@@ -36,6 +36,9 @@ type Client struct {
 	connectionsByKey       map[string]int
 	localDNSCache          *dnsCache.Store
 	dnsResponses           *fragmentStore.Store[clientDNSFragmentKey]
+	localDNSCachePath      string
+	localDNSCachePersist   bool
+	localDNSCacheFlushTick time.Duration
 	localDNSFragTTL        time.Duration
 	localDNSCacheLoadOnce  sync.Once
 	localDNSCacheFlushOnce sync.Once
@@ -150,7 +153,12 @@ func New(cfg config.ClientConfig, log *logger.Logger, codec *security.Codec) *Cl
 			time.Duration(cfg.LocalDNSCacheTTLSeconds*float64(time.Second)),
 			time.Duration(cfg.LocalDNSPendingTimeoutSec*float64(time.Second)),
 		),
-		dnsResponses:       fragmentStore.New[clientDNSFragmentKey](32),
+		dnsResponses:         fragmentStore.New[clientDNSFragmentKey](32),
+		localDNSCachePath:    cfg.LocalDNSCachePath(),
+		localDNSCachePersist: cfg.LocalDNSCachePersist,
+		localDNSCacheFlushTick: time.Duration(
+			cfg.LocalDNSCacheFlushSec * float64(time.Second),
+		),
 		localDNSFragTTL:    time.Duration(cfg.LocalDNSFragmentTimeoutSec * float64(time.Second)),
 		streams:            make(map[uint16]*clientStream, 16),
 		streamTXWindow:     cfg.StreamTXWindow,
@@ -161,6 +169,9 @@ func New(cfg config.ClientConfig, log *logger.Logger, codec *security.Codec) *Cl
 		resolverRecheck:    make(map[string]resolverRecheckState, len(cfg.Domains)*len(cfg.Resolvers)),
 		runtimeDisabled:    make(map[string]resolverDisabledState, len(cfg.Domains)*len(cfg.Resolvers)),
 	}
+	if c.localDNSCacheFlushTick <= 0 {
+		c.localDNSCacheFlushTick = time.Minute
+	}
 	if c.localDNSFragTTL <= 0 {
 		c.localDNSFragTTL = 5 * time.Minute
 	}

internal/client/local_dns_cache_persistence.go

@@ -12,19 +12,26 @@ import (
 	"time"
 )
 
+func (c *Client) hasPersistableLocalDNSCache() bool {
+	return c != nil &&
+		c.localDNSCache != nil &&
+		c.localDNSCachePersist &&
+		c.localDNSCachePath != ""
+}
+
 func (c *Client) persistResolvedLocalDNSCacheEntry(cacheKey []byte, domain string, qType uint16, qClass uint16, rawResponse []byte, now time.Time) {
 	if c == nil || c.localDNSCache == nil {
 		return
 	}
 
 	c.localDNSCache.SetReady(cacheKey, domain, qType, qClass, rawResponse, now)
-	if c.cfg.LocalDNSCachePersist {
+	if c.hasPersistableLocalDNSCache() {
 		c.flushLocalDNSCache()
 	}
 }
 
 func (c *Client) ensureLocalDNSCacheLoaded() {
-	if c == nil {
+	if !c.hasPersistableLocalDNSCache() {
 		return
 	}
 	c.localDNSCacheLoadOnce.Do(func() {
@@ -33,7 +40,7 @@ func (c *Client) ensureLocalDNSCacheLoaded() {
 }
 
 func (c *Client) ensureLocalDNSCachePersistence(ctx context.Context) {
-	if c == nil {
+	if !c.hasPersistableLocalDNSCache() {
 		return
 	}
 	c.ensureLocalDNSCacheLoaded()
@@ -43,11 +50,11 @@ func (c *Client) ensureLocalDNSCachePersistence(ctx context.Context) {
 }
 
 func (c *Client) loadLocalDNSCache() {
-	if c == nil || !c.cfg.LocalDNSCachePersist || c.localDNSCache == nil {
+	if !c.hasPersistableLocalDNSCache() {
 		return
 	}
 
-	loaded, err := c.localDNSCache.LoadFromFile(c.cfg.LocalDNSCachePath(), c.now())
+	loaded, err := c.localDNSCache.LoadFromFile(c.localDNSCachePath, c.now())
 	if err != nil {
 		if c.log != nil {
 			c.log.Warnf("\U0001F4BE <cyan>Local DNS Cache</cyan> <magenta>|</magenta> <red>Load Failed</red> <magenta>|</magenta> <yellow>%v</yellow>", err)
@@ -60,11 +67,11 @@ func (c *Client) loadLocalDNSCache() {
 }
 
 func (c *Client) flushLocalDNSCache() {
-	if c == nil || !c.cfg.LocalDNSCachePersist || c.localDNSCache == nil {
+	if !c.hasPersistableLocalDNSCache() {
 		return
 	}
 
-	saved, err := c.localDNSCache.SaveToFile(c.cfg.LocalDNSCachePath(), c.now())
+	saved, err := c.localDNSCache.SaveToFile(c.localDNSCachePath, c.now())
 	if err != nil {
 		if c.log != nil {
 			c.log.Warnf("\U0001F4BE <cyan>Local DNS Cache</cyan> <magenta>|</magenta> <red>Flush Failed</red> <magenta>|</magenta> <yellow>%v</yellow>", err)
@@ -77,16 +84,11 @@ func (c *Client) flushLocalDNSCache() {
 }
 
 func (c *Client) runLocalDNSCacheFlushLoop(ctx context.Context) {
-	if c == nil || !c.cfg.LocalDNSCachePersist || c.localDNSCache == nil {
+	if !c.hasPersistableLocalDNSCache() {
 		return
 	}
 
-	interval := time.Duration(c.cfg.LocalDNSCacheFlushSec * float64(time.Second))
-	if interval <= 0 {
-		interval = time.Minute
-	}
-
-	ticker := time.NewTicker(interval)
+	ticker := time.NewTicker(c.localDNSCacheFlushTick)
 	defer ticker.Stop()
 	defer c.flushLocalDNSCache()