fix(notify): 修复传输生命周期竞态，完善背压与协议边界

- 完善 stream/bulk DataID 分配、预留和双向命名空间，修复并发打开及 dedicated/shared 回退时的 ID 冲突 - 将收发、回复、恢复任务和 sidecar 绑定原始会话与物理连接，防止重连后的旧消息误操作新连接 - 加强 close/reset 身份校验及实例移除检查，修复 dedicated attach 失败、通道引用和资源回收竞态 - 收紧批量发送器停止准入，确保在途入队完成后统一清理请求、缓冲区和等待者 - 修复 record 满队列死锁、取消时序号消耗及关闭竞态，确保关闭有界并返回真实错误 - 增加协商式 record 逻辑半关闭，保留反向 ACK；通过 reset 传递 RecordFailure，避免背压掩盖原始失败原因 - 补齐帧长度、批次数量、序号溢出和未确认窗口校验，提前拒绝超限数据并按字节预算拆批 - 为入站分发增加全局及单连接的条数、字节预算和阻塞背压，关闭时唤醒等待者，消除正常断连日志噪音 - 完善 bulk 窗口释放失败处理与传输诊断，补充并发、重连、背压、协议边界及真实 TCP 回归覆盖
2026-09-23 15:33:17 +08:00
parent 0826e17063
commit 1f2e74acca
79 changed files with 9190 additions and 1013 deletions
@@ -439,6 +439,127 @@ func TestStreamBatchSenderCarriesContextDeadlineIntoPhysicalWrite(t *testing.T)
 	}
 }

+func TestBatchSenderQueueWaitTimeoutDoesNotPoisonSender(t *testing.T) {
+	tests := []struct {
+		name string
+		new  func(*transportBinding) batchSenderTestSender
+	}{
+		{
+			name: "bulk",
+			new: func(binding *transportBinding) batchSenderTestSender {
+				sender := newTestBulkBatchSender(binding)
+				return batchSenderTestAdapter{
+					submitFn: func(ctx context.Context) error {
+						return sender.submitData(ctx, 1, 1, bulkFastPathVersionV1, []byte("bulk"))
+					},
+					errFn:  sender.errSnapshot,
+					stopFn: sender.stop,
+				}
+			},
+		},
+		{
+			name: "stream",
+			new: func(binding *transportBinding) batchSenderTestSender {
+				sender := newTestStreamBatchSender(binding, nil)
+				return batchSenderTestAdapter{
+					submitFn: func(ctx context.Context) error {
+						return sender.submitData(ctx, 1, 1, streamFastPathVersionV1, []byte("stream"))
+					},
+					errFn:  sender.errSnapshot,
+					stopFn: sender.stop,
+				}
+			},
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			binding := newTransportBinding(&serializedWriteTestConn{}, stario.NewQueue())
+			sender := tc.new(binding)
+			if err := binding.lockConnWriteContext(context.Background()); err != nil {
+				t.Fatalf("lock shared write gate: %v", err)
+			}
+			defer binding.unlockConnWrite()
+			ctx, cancel := context.WithTimeout(context.Background(), 25*time.Millisecond)
+			defer cancel()
+			err := sender.submit(ctx)
+			if !isBatchSenderQueueWaitError(err) || !isTimeoutLikeError(err) {
+				t.Fatalf("queue wait error=%v, want classified timeout", err)
+			}
+			if got := sender.errSnapshot(); got != nil {
+				t.Fatalf("caller queue timeout poisoned healthy sender: %v", got)
+			}
+			sender.stop()
+		})
+	}
+}
+
+type batchSenderTestSender interface {
+	submit(context.Context) error
+	errSnapshot() error
+	stop()
+}
+
+type batchSenderTestAdapter struct {
+	submitFn func(context.Context) error
+	errFn    func() error
+	stopFn   func()
+}
+
+func (a batchSenderTestAdapter) submit(ctx context.Context) error { return a.submitFn(ctx) }
+func (a batchSenderTestAdapter) errSnapshot() error               { return a.errFn() }
+func (a batchSenderTestAdapter) stop()                            { a.stopFn() }
+
+func TestBatchSenderFailBatchCompletesEveryRequest(t *testing.T) {
+	tests := []struct {
+		name string
+		bulk bool
+	}{
+		{name: "bulk", bulk: true},
+		{name: "stream", bulk: false},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			var released atomic.Int32
+			if tc.bulk {
+				sender := &bulkBatchSender{}
+				sender.queued.Store(2)
+				requests := []bulkBatchRequest{
+					{done: make(chan error, 1), release: func() { released.Add(1) }},
+					{done: make(chan error, 1), release: func() { released.Add(1) }},
+				}
+				sender.failBatch(requests, errTransportDetached)
+				for i, req := range requests {
+					if err := <-req.done; !errors.Is(err, errTransportDetached) {
+						t.Fatalf("request %d error=%v, want transport detached", i, err)
+					}
+				}
+				if got := sender.queued.Load(); got != 0 {
+					t.Fatalf("queued=%d after local batch failure, want 0", got)
+				}
+			} else {
+				sender := &streamBatchSender{}
+				sender.queued.Store(2)
+				requests := []streamBatchRequest{
+					{done: make(chan error, 1)},
+					{done: make(chan error, 1)},
+				}
+				sender.failBatch(requests, errTransportDetached)
+				for i, req := range requests {
+					if err := <-req.done; !errors.Is(err, errTransportDetached) {
+						t.Fatalf("request %d error=%v, want transport detached", i, err)
+					}
+				}
+				if got := sender.queued.Load(); got != 0 {
+					t.Fatalf("queued=%d after local batch failure, want 0", got)
+				}
+			}
+			if tc.bulk && released.Load() != 2 {
+				t.Fatalf("bulk payload releases=%d, want 2", released.Load())
+			}
+		})
+	}
+}
+
 func TestTransportBindingStopWithCloseInterruptsPhysicalWrite(t *testing.T) {
 	left, right := net.Pipe()
 	defer right.Close()
@@ -889,6 +1010,30 @@ func TestControlBatchSenderCancelsQueuedRequestWithoutStoppingSender(t *testing.
 	}
 }

+func TestControlBatchWaitContextIsIndependentOfRequestCancellation(t *testing.T) {
+	sender := &controlBatchSender{stopCtx: context.Background()}
+	firstCtx, cancelFirst := context.WithCancel(context.Background())
+	secondCtx, cancelSecond := context.WithCancel(context.Background())
+	waitCtx, cleanup := sender.controlBatchWaitContext([]controlBatchRequest{
+		{ctx: firstCtx},
+		{ctx: secondCtx},
+	})
+	defer cleanup()
+	cancelFirst()
+	select {
+	case <-waitCtx.Done():
+		t.Fatal("one canceled request canceled the physical batch wait")
+	case <-time.After(20 * time.Millisecond):
+	}
+	cancelSecond()
+	select {
+	case <-waitCtx.Done():
+	case <-time.After(time.Second):
+		t.Fatal("physical batch wait did not cancel after all requests canceled")
+	}
+	cleanup()
+}
+
 func TestControlBatchSenderCancelsWhileWaitingForSharedWriteLock(t *testing.T) {
 	binding := newTransportBinding(&serializedWriteTestConn{}, stario.NewQueue())
 	sender := newControlBatchSender(binding)