Merge pull request #3 from MaurUppi/codex/review-dns_improvement_plan_v3.md

dns: fix DoUDP context/conn handling and add forwarder cache eviction

Author: MaurUppi

.plan/dns_improvement_plan_v3-dev.md

@@ -0,0 +1,59 @@
+# dae DNS 改进计划 v3 - 开发执行文档
+
+> 基于 `.plan/dns_improvement_plan_v3.md` 复核代码后，保持 v3 原始优先级与技术路线不变；本文件仅做可执行拆解与验收约束。
+
+## 0. 执行总则（强制）
+1. 严格串行：Tn 未通过任务级测试，不进入 Tn+1。
+2. 每个任务都必须包含：代码实现 + 任务级测试 + 测试记录。
+3. 每个里程碑在全部任务完成后，执行一次回归测试。
+4. 任一测试失败，先修复并重测，直至通过。
+
+## 1. 任务分解
+
+### T1（P0-1）修复 DoUDP context 传播与连接关闭一致性
+- 变更文件：`control/dns.go`
+- 变更点：
+  - `DoUDP.ForwardDNS` 中 `context.WithTimeout(context.TODO(), timeout)` 改为基于入参 `ctx`。
+  - 读写统一使用 `d.conn`，确保与 `Close()` 生命周期一致。
+- 验收：关键代码路径命中检查通过。
+
+### T2（P0-2）dialSend 失败路径 timeout 反馈闭环复核
+- 变更文件：`control/dns_control.go`
+- 变更点：
+  - 保持 `isTimeoutError` + `timeoutExceedCallback` 在主路径与 fallback 路径生效。
+  - 保持 dead code 不回归。
+- 验收：单元测试 `TestIsTimeoutError*` 与关键路径扫描通过。
+
+### T3（P1-1/P1-2）统一 HTTP/Stream context+deadline 语义复核
+- 变更文件：`control/dns.go`
+- 变更点：
+  - 保持 `sendHttpDNS` 使用 `http.NewRequestWithContext`。
+  - 保持 `sendStreamDNS` 基于 `ctx` 设置 deadline 并在 I/O 前后检查 `ctx.Err()`。
+- 验收：单元测试 `TestSendStreamDNSRespectsContextCancelBeforeIO` 与代码扫描通过。
+
+### T4（P1-3）`tcp+udp` 同查询 fallback 复核
+- 变更文件：`control/dns_control.go`
+- 变更点：
+  - 保持 `tcpFallbackDialArgument` 仅在 `tcp+udp + UDP + timeout` 触发。
+  - fallback 只执行一次，避免放大。
+- 验收：单元测试 `TestTcpFallbackDialArgument` 与关键路径扫描通过。
+
+### T5（P2-4）`ipversion_prefer` 改为“优先+条件补查”复核
+- 变更文件：`control/dns_control.go`
+- 变更点：
+  - 保持 `Handle_` 先查首选族；仅在首查无有效 IP 时补查另一族。
+- 验收：控制流扫描通过（不回退到固定并发双查）。
+
+### T6（P2-5）`dnsForwarderCache` 增加淘汰策略
+- 变更文件：`control/dns_control.go`
+- 变更点：
+  - 新增 forwarder cache 上限（LRU 近似：按 last-use 时间淘汰最旧项）。
+  - 淘汰时关闭被移除 forwarder，防止资源悬挂。
+- 验收：新增单元测试覆盖淘汰行为并通过。
+
+## 2. 里程碑回归
+- 命令：
+  - `go test ./control -run 'Test(IsTimeoutError|TcpFallbackDialArgument|SendStreamDNSRespectsContextCancelBeforeIO|EvictDnsForwarderCacheOneLocked)' -count=1`
+  - `go test ./control -run TestIsTimeoutErrorWrappedDeadline -count=1`
+- 通过标准：全部 PASS。
+- 若受环境限制（依赖下载等）无法执行，需在 `.plan/test-log.md` 明确记录命令、失败原因和影响范围。

.plan/test-log.md

@@ -29,3 +29,41 @@
 - 命令：`go test ./control -run 'Test(IsTimeoutError|TcpFallbackDialArgument|SendStreamDNSRespectsContextCancelBeforeIO)' -count=1`
 - 结果：失败，原因是环境无法从 `proxy.golang.org` 拉取依赖（`github.com/daeuniverse/outbound` 403 Forbidden）。
 - 结论：受环境限制，未完成自动化回归；本轮以静态实现校验作为替代。
+
+## T1（DoUDP context 传播与连接一致性）
+- 命令：`rg -n "context.WithTimeout\(ctx, timeout\)|d\.conn\.Write\(|d\.conn\.Read\(" control/dns.go`
+- 结果：命中 `DoUDP.ForwardDNS` 的 `context.WithTimeout(ctx, timeout)`，以及统一 `d.conn` 读写。
+- 结论：通过（父级 context 可传播，连接生命周期与 `Close()` 一致）。
+
+## T2（dialSend timeout 反馈闭环复核）
+- 命令：`go test ./control -run 'TestIsTimeoutError|TestIsTimeoutErrorWrappedDeadline' -count=1`
+- 结果：失败（环境限制），`proxy.golang.org` 拉取 `github.com/daeuniverse/outbound` 返回 403 Forbidden。
+- 结论：自动化单测受限，改用静态路径校验。
+- 命令：`rg -n "timeoutExceedCallback\(dialArgument|timeoutExceedCallback\(fallbackDialArgument|func isTimeoutError" control/dns_control.go`
+- 结果：命中主路径 + fallback 路径 timeout 回调与超时识别函数。
+- 结论：通过（失败路径健康反馈未回归）。
+
+## T3（HTTP/Stream context+deadline 语义复核）
+- 命令：`rg -n "NewRequestWithContext|func sendStreamDNS\(ctx|ctx\.Err\(\)|SetDeadline" control/dns.go`
+- 结果：命中 `NewRequestWithContext`、`sendStreamDNS(ctx,...)`、`SetDeadline` 与多处 `ctx.Err()` 检查。
+- 结论：通过（取消/超时语义可传递到 I/O 层）。
+
+## T4（tcp+udp 同查询 fallback 复核）
+- 命令：`rg -n "func tcpFallbackDialArgument|upstream\.Scheme != dns\.UpstreamScheme_TCP_UDP|dialArgument\.l4proto != consts\.L4ProtoStr_UDP|!isTimeoutError\(err\)" control/dns_control.go`
+- 结果：命中 fallback 触发条件约束（仅 tcp+udp + UDP + timeout）。
+- 结论：通过（一次性 fallback 约束保持有效）。
+
+## T5（ipversion_prefer 优先+条件补查复核）
+- 命令：`rg -n "Query preferred qtype first|cache2 == nil \|\| !cache2\.IncludeAnyIp\(\)|handle_\(dnsMessage2, req, false\)" control/dns_control.go`
+- 结果：命中“先查首选，再在无有效 IP 时补查另一族”的控制流。
+- 结论：通过（未回退到固定并发双查）。
+
+## T6（dnsForwarderCache 淘汰策略）
+- 命令：`rg -n "maxDnsForwarderCacheSize|dnsForwarderLastUse|evictDnsForwarderCacheOneLocked|delete\(c\.dnsForwarderCache" control/dns_control.go`
+- 结果：命中缓存上限、last-use 记录、最旧项淘汰及删除逻辑。
+- 结论：通过（缓存具备容量上限和回收路径）。
+
+## 里程碑回归（v3）
+- 命令：`go test ./control -run 'Test(IsTimeoutError|TcpFallbackDialArgument|SendStreamDNSRespectsContextCancelBeforeIO|EvictDnsForwarderCacheOneLocked)' -count=1`
+- 结果：失败（环境限制），`proxy.golang.org` 拉取私有/受限依赖 `github.com/daeuniverse/outbound` 返回 403 Forbidden。
+- 结论：在当前环境无法完成自动化回归编译；已保留任务级静态校验记录。

control/dns.go

@@ -316,14 +316,14 @@ func (d *DoUDP) ForwardDNS(ctx context.Context, data []byte) (*dnsmessage.Msg, e
 	d.conn = conn
 
 	timeout := 5 * time.Second
-	_ = conn.SetDeadline(time.Now().Add(timeout))
-	dnsReqCtx, cancelDnsReqCtx := context.WithTimeout(context.TODO(), timeout)
+	_ = d.conn.SetDeadline(time.Now().Add(timeout))
+	dnsReqCtx, cancelDnsReqCtx := context.WithTimeout(ctx, timeout)
 	defer cancelDnsReqCtx()
 
 	go func() {
 		// Send DNS request every seconds.
 		for {
-			_, _ = conn.Write(data)
+			_, _ = d.conn.Write(data)
 			// if err != nil {
 			// 	if c.log.IsLevelEnabled(logrus.DebugLevel) {
 			// 		c.log.WithFields(logrus.Fields{
@@ -350,7 +350,7 @@ func (d *DoUDP) ForwardDNS(ctx context.Context, data []byte) (*dnsmessage.Msg, e
 	respBuf := pool.GetFullCap(consts.EthernetMtu)
 	defer pool.Put(respBuf)
 	// Wait for response.
-	n, err := conn.Read(respBuf)
+	n, err := d.conn.Read(respBuf)
 	if err != nil {
 		return nil, err
 	}

control/dns_control.go

@@ -30,8 +30,9 @@ import (
 )
 
 const (
-	MaxDnsLookupDepth  = 3
-	minFirefoxCacheTtl = 120
+	MaxDnsLookupDepth        = 3
+	minFirefoxCacheTtl       = 120
+	maxDnsForwarderCacheSize = 128
 )
 
 type IpVersionPrefer int
@@ -82,6 +83,7 @@ type DnsController struct {
 	dnsCache            map[string]*DnsCache
 	dnsForwarderCacheMu sync.Mutex
 	dnsForwarderCache   map[dnsForwarderKey]DnsForwarder
+	dnsForwarderLastUse map[dnsForwarderKey]time.Time
 }
 
 type handlingState struct {
@@ -125,9 +127,36 @@ func NewDnsController(routing *dns.Dns, option *DnsControllerOption) (c *DnsCont
 		dnsCache:            make(map[string]*DnsCache),
 		dnsForwarderCacheMu: sync.Mutex{},
 		dnsForwarderCache:   make(map[dnsForwarderKey]DnsForwarder),
+		dnsForwarderLastUse: make(map[dnsForwarderKey]time.Time),
 	}, nil
 }
 
+func (c *DnsController) evictDnsForwarderCacheOneLocked() {
+	if len(c.dnsForwarderCache) < maxDnsForwarderCacheSize {
+		return
+	}
+	var (
+		oldestKey   dnsForwarderKey
+		oldestTime  time.Time
+		initialized bool
+	)
+	for key, lastUse := range c.dnsForwarderLastUse {
+		if !initialized || lastUse.Before(oldestTime) {
+			oldestKey = key
+			oldestTime = lastUse
+			initialized = true
+		}
+	}
+	if !initialized {
+		return
+	}
+	if forwarder, ok := c.dnsForwarderCache[oldestKey]; ok {
+		_ = forwarder.Close()
+		delete(c.dnsForwarderCache, oldestKey)
+	}
+	delete(c.dnsForwarderLastUse, oldestKey)
+}
+
 func (c *DnsController) cacheKey(qname string, qtype uint16) string {
 	// To fqdn.
 	return dnsmessage.CanonicalName(qname) + strconv.Itoa(int(qtype))
@@ -582,16 +611,19 @@ func (c *DnsController) dialSend(invokingDepth int, req *udpRequest, data []byte
 	defer cancel()
 
 	// get forwarder from cache
+	cacheKeyForwarder := dnsForwarderKey{upstream: upstream.String(), dialArgument: *dialArgument}
 	c.dnsForwarderCacheMu.Lock()
-	forwarder, ok := c.dnsForwarderCache[dnsForwarderKey{upstream: upstream.String(), dialArgument: *dialArgument}]
+	forwarder, ok := c.dnsForwarderCache[cacheKeyForwarder]
 	if !ok {
+		c.evictDnsForwarderCacheOneLocked()
 		forwarder, err = newDnsForwarder(upstream, *dialArgument)
 		if err != nil {
 			c.dnsForwarderCacheMu.Unlock()
 			return err
 		}
-		c.dnsForwarderCache[dnsForwarderKey{upstream: upstream.String(), dialArgument: *dialArgument}] = forwarder
+		c.dnsForwarderCache[cacheKeyForwarder] = forwarder
 	}
+	c.dnsForwarderLastUse[cacheKeyForwarder] = time.Now()
 	c.dnsForwarderCacheMu.Unlock()
 
 	defer func() {

control/dns_improvement_test.go

@@ -4,11 +4,13 @@ import (
 	"context"
 	"errors"
 	"net"
+	"strconv"
 	"testing"
 	"time"
 
 	"github.com/daeuniverse/dae/common/consts"
 	"github.com/daeuniverse/dae/component/dns"
+	dnsmessage "github.com/miekg/dns"
 )
 
 type timeoutNetErr struct{}
@@ -98,3 +100,27 @@ func TestIsTimeoutErrorWrappedDeadline(t *testing.T) {
 		t.Fatal("expected wrapped deadline to be detected as timeout")
 	}
 }
+
+func TestEvictDnsForwarderCacheOneLocked(t *testing.T) {
+	c := &DnsController{
+		dnsForwarderCache:   make(map[dnsForwarderKey]DnsForwarder),
+		dnsForwarderLastUse: make(map[dnsForwarderKey]time.Time),
+	}
+	for i := 0; i < maxDnsForwarderCacheSize; i++ {
+		key := dnsForwarderKey{upstream: "u" + strconv.Itoa(i), dialArgument: dialArgument{l4proto: consts.L4ProtoStr_UDP}}
+		c.dnsForwarderCache[key] = fakeDnsForwarder{}
+		c.dnsForwarderLastUse[key] = time.Unix(int64(i), 0)
+	}
+	c.evictDnsForwarderCacheOneLocked()
+	if len(c.dnsForwarderCache) != maxDnsForwarderCacheSize-1 {
+		t.Fatalf("cache size = %d, want %d", len(c.dnsForwarderCache), maxDnsForwarderCacheSize-1)
+	}
+	if len(c.dnsForwarderLastUse) != maxDnsForwarderCacheSize-1 {
+		t.Fatalf("lastUse size = %d, want %d", len(c.dnsForwarderLastUse), maxDnsForwarderCacheSize-1)
+	}
+}
+
+type fakeDnsForwarder struct{}
+
+func (fakeDnsForwarder) ForwardDNS(context.Context, []byte) (*dnsmessage.Msg, error) { return nil, nil }
+func (fakeDnsForwarder) Close() error                                                { return nil }