feat(notify): 重构通信内核并补齐 stream/bulk/record/transfer 能力

- 引入 LogicalConn/TransportConn 分层，ClientConn 保留兼容适配层 - 新增 Stream、Bulk、RecordStream 三条数据面能力及对应控制路径 - 完成 transfer/file 传输内核与状态快照、诊断能力 - 补齐 reconnect、inbound dispatcher、modern psk 等基础模块 - 增加大规模回归、并发与基准测试覆盖 - 更新依赖库
2026-04-15 15:24:36 +08:00
parent d14d13c393
commit 09d972c7b7
216 changed files with 51374 additions and 1715 deletions
@@ -0,0 +1,241 @@
+package notify
+
+import (
+	"errors"
+	"sync"
+	"time"
+)
+
+var (
+	errSignalAckCanceled = errors.New("signal ack canceled")
+	errSignalAckTimeout  = errors.New("signal ack timeout")
+)
+
+const signalAckShardCount = 64
+
+type signalAckMapKey struct {
+	scope    string
+	signalID uint64
+}
+
+type signalAckShard struct {
+	mu   sync.Mutex
+	wait map[signalAckMapKey]*signalAckWait
+}
+
+type signalAckWait struct {
+	key       signalAckMapKey
+	scope     string
+	pool      *signalAckPool
+	reply     chan error
+	closeOnce sync.Once
+}
+
+type signalAckPool struct {
+	shards [signalAckShardCount]signalAckShard
+}
+
+func newSignalAckPool() *signalAckPool {
+	pool := &signalAckPool{}
+	for i := range pool.shards {
+		pool.shards[i].wait = make(map[signalAckMapKey]*signalAckWait)
+	}
+	return pool
+}
+
+func signalAckScopeHash(scope string) uint64 {
+	var hash uint64 = 1469598103934665603
+	for i := 0; i < len(scope); i++ {
+		hash ^= uint64(scope[i])
+		hash *= 1099511628211
+	}
+	return hash
+}
+
+func (p *signalAckPool) shard(scope string, signalID uint64) *signalAckShard {
+	if p == nil {
+		return nil
+	}
+	index := int((signalID ^ signalAckScopeHash(scope)) % signalAckShardCount)
+	return &p.shards[index]
+}
+
+func (p *signalAckPool) prepare(scope string, signalID uint64) *signalAckWait {
+	scope = normalizeFileScope(scope)
+	wait := &signalAckWait{
+		key: signalAckMapKey{
+			scope:    scope,
+			signalID: signalID,
+		},
+		scope: scope,
+		pool:  p,
+		reply: make(chan error, 1),
+	}
+	if shard := p.shard(scope, signalID); shard != nil {
+		shard.mu.Lock()
+		shard.wait[wait.key] = wait
+		shard.mu.Unlock()
+	}
+	return wait
+}
+
+func (p *signalAckPool) deliver(scope string, signalID uint64) bool {
+	return p.deliverAny([]string{scope}, signalID)
+}
+
+func (p *signalAckPool) deliverAny(scopes []string, signalID uint64) bool {
+	if p == nil {
+		return false
+	}
+	for _, scope := range scopes {
+		normalized := normalizeFileScope(scope)
+		shard := p.shard(normalized, signalID)
+		if shard == nil {
+			continue
+		}
+		key := signalAckMapKey{
+			scope:    normalized,
+			signalID: signalID,
+		}
+		shard.mu.Lock()
+		wait := shard.wait[key]
+		if wait != nil {
+			delete(shard.wait, key)
+		}
+		shard.mu.Unlock()
+		if wait == nil {
+			continue
+		}
+		wait.ack()
+		return true
+	}
+	return false
+}
+
+func (w *signalAckWait) ack() {
+	if w == nil {
+		return
+	}
+	w.closeOnce.Do(func() {
+		select {
+		case w.reply <- nil:
+		default:
+		}
+		close(w.reply)
+	})
+}
+
+func (w *signalAckWait) cancel() {
+	if w == nil {
+		return
+	}
+	if w.pool != nil {
+		shard := w.pool.shard(w.key.scope, w.key.signalID)
+		if shard != nil {
+			shard.mu.Lock()
+			delete(shard.wait, w.key)
+			shard.mu.Unlock()
+		}
+	}
+	w.closeReply()
+}
+
+func (w *signalAckWait) closeReply() {
+	if w == nil {
+		return
+	}
+	w.closeOnce.Do(func() {
+		close(w.reply)
+	})
+}
+
+func (p *signalAckPool) waitPrepared(wait *signalAckWait, timeout time.Duration) error {
+	if timeout <= 0 {
+		timeout = defaultSignalAckTimeout
+	}
+	timer := time.NewTimer(timeout)
+	defer timer.Stop()
+	select {
+	case err, ok := <-wait.reply:
+		if !ok {
+			return errSignalAckCanceled
+		}
+		return err
+	case <-timer.C:
+		wait.cancel()
+		return errSignalAckTimeout
+	}
+}
+
+func (p *signalAckPool) closeAll() {
+	if p == nil {
+		return
+	}
+	for i := range p.shards {
+		shard := &p.shards[i]
+		shard.mu.Lock()
+		waits := make([]*signalAckWait, 0, len(shard.wait))
+		for key, wait := range shard.wait {
+			delete(shard.wait, key)
+			if wait != nil {
+				waits = append(waits, wait)
+			}
+		}
+		shard.mu.Unlock()
+		for _, wait := range waits {
+			wait.closeReply()
+		}
+	}
+}
+
+func (p *signalAckPool) closeScope(scope string) {
+	if p == nil {
+		return
+	}
+	scope = normalizeFileScope(scope)
+	for i := range p.shards {
+		shard := &p.shards[i]
+		shard.mu.Lock()
+		waits := make([]*signalAckWait, 0)
+		for key, wait := range shard.wait {
+			if wait != nil && wait.scope == scope {
+				delete(shard.wait, key)
+				waits = append(waits, wait)
+			}
+		}
+		shard.mu.Unlock()
+		for _, wait := range waits {
+			wait.closeReply()
+		}
+	}
+}
+
+func (p *signalAckPool) closeScopeFamily(scope string) {
+	if p == nil {
+		return
+	}
+	base := normalizeFileScope(scope)
+	for i := range p.shards {
+		shard := &p.shards[i]
+		shard.mu.Lock()
+		waits := make([]*signalAckWait, 0)
+		for key, wait := range shard.wait {
+			if wait != nil && scopeBelongsToServerFileScope(wait.scope, base) {
+				delete(shard.wait, key)
+				waits = append(waits, wait)
+			}
+		}
+		shard.mu.Unlock()
+		for _, wait := range waits {
+			wait.closeReply()
+		}
+	}
+}
+
+func (c *ClientCommon) getSignalAckPool() *signalAckPool {
+	return c.getLogicalSessionState().signalAckWaits
+}
+
+func (s *ServerCommon) getSignalAckPool() *signalAckPool {
+	return s.getLogicalSessionState().signalAckWaits
+}