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
@@ -185,6 +185,145 @@ func TestSendDedicatedBulkAttachRequestUsesBootstrapProtectionEvenAfterSteadySwi
 	}
 }

+func TestAttachDedicatedBulkSidecarStopsWhenOriginalRouteReattaches(t *testing.T) {
+	client := NewClient().(*ClientCommon)
+	UseLegacySecurityClient(client)
+	stopCtx, stopFn := context.WithCancel(context.Background())
+	defer stopFn()
+	queue := stario.NewQueueCtx(stopCtx, 4, ^uint32(0))
+	firstLeft, firstRight := net.Pipe()
+	defer firstRight.Close()
+	epoch := client.beginClientSessionEpoch()
+	client.setClientSessionRuntime(newClientSessionRuntime(firstLeft, stopCtx, stopFn, queue, epoch))
+	client.markSessionStarted()
+	defer client.markSessionStopped("test done", nil)
+
+	route := client.clientSessionRouteSnapshot()
+	bulk := newBulkHandle(stopCtx, client.getBulkRuntime(), clientFileScope(), BulkOpenRequest{
+		BulkID:          "dedicated-original-route",
+		DataID:          1,
+		Dedicated:       true,
+		DedicatedLaneID: 1,
+		AttachToken:     "attach-token",
+	}, epoch, nil, nil, 0, nil, nil, nil, nil, nil)
+	bulk.setClientSnapshotOwner(client)
+	bulk.setClientSessionRoute(route)
+	defer bulk.finalize()
+
+	client.bulkDedicatedAttachSem = make(chan struct{}, 1)
+	client.bulkDedicatedAttachSem <- struct{}{}
+	defer func() {
+		select {
+		case <-client.bulkDedicatedAttachSem:
+		default:
+		}
+	}()
+	result := make(chan error, 1)
+	go func() {
+		result <- client.attachDedicatedBulkSidecar(context.Background(), bulk)
+	}()
+
+	deadline := time.Now().Add(time.Second)
+	for time.Now().Before(deadline) {
+		client.bulkDedicatedSidecarMu.Lock()
+		lane := client.bulkDedicatedLanes[1]
+		blocked := lane != nil && lane.attachFlight != nil
+		client.bulkDedicatedSidecarMu.Unlock()
+		if blocked {
+			break
+		}
+		time.Sleep(time.Millisecond)
+	}
+	client.bulkDedicatedSidecarMu.Lock()
+	lane := client.bulkDedicatedLanes[1]
+	blocked := lane != nil && lane.attachFlight != nil
+	client.bulkDedicatedSidecarMu.Unlock()
+	if !blocked {
+		t.Fatal("dedicated attach did not reach the blocked attach slot")
+	}
+
+	secondLeft, secondRight := net.Pipe()
+	defer secondRight.Close()
+	if err := client.attachClientSessionTransport(secondLeft); err != nil {
+		t.Fatalf("attach replacement client transport: %v", err)
+	}
+	select {
+	case err := <-result:
+		if !errors.Is(err, errTransportDetached) {
+			t.Fatalf("dedicated attach error = %v, want transport detached", err)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("dedicated attach remained blocked after original route detached")
+	}
+	if sidecar := client.clientDedicatedSidecarSnapshotForLane(1); sidecar != nil {
+		t.Fatalf("stale route installed dedicated sidecar: %+v", sidecar)
+	}
+}
+
+func TestClientDedicatedSidecarRejectsLateOldRoutePublicationAndRelease(t *testing.T) {
+	client := NewClient().(*ClientCommon)
+	UseLegacySecurityClient(client)
+	stopCtx, stopFn := context.WithCancel(context.Background())
+	defer stopFn()
+	queue := stario.NewQueueCtx(stopCtx, 4, ^uint32(0))
+	firstLeft, firstRight := net.Pipe()
+	defer firstRight.Close()
+	epoch := client.beginClientSessionEpoch()
+	client.setClientSessionRuntime(newClientSessionRuntime(firstLeft, stopCtx, stopFn, queue, epoch))
+	client.markSessionStarted()
+	defer client.markSessionStopped("test done", nil)
+
+	oldRoute := client.clientSessionRouteSnapshot()
+	oldLane, err := client.reserveBulkDedicatedLaneAtRoute(oldRoute)
+	if err != nil {
+		t.Fatalf("reserve old-route lane: %v", err)
+	}
+	oldSidecarLeft, oldSidecarRight := net.Pipe()
+	defer oldSidecarRight.Close()
+	oldSidecar := newBulkDedicatedSidecar(oldSidecarLeft, oldLane)
+	if _, installed, err := client.installClientDedicatedSidecarAtRoute(oldLane, oldSidecar, oldRoute); err != nil || !installed {
+		t.Fatalf("install old-route sidecar = installed=%v err=%v, want installed", installed, err)
+	}
+
+	secondLeft, secondRight := net.Pipe()
+	defer secondRight.Close()
+	if err := client.attachClientSessionTransport(secondLeft); err != nil {
+		t.Fatalf("attach replacement client transport: %v", err)
+	}
+	newRoute := client.clientSessionRouteSnapshot()
+	lateLeft, lateRight := net.Pipe()
+	defer lateRight.Close()
+	lateSidecar := newBulkDedicatedSidecar(lateLeft, oldLane)
+	if _, installed, err := client.installClientDedicatedSidecarAtRoute(oldLane, lateSidecar, oldRoute); err == nil || installed {
+		lateSidecar.close()
+		t.Fatalf("late old-route sidecar install = installed=%v err=%v, want rejection", installed, err)
+	}
+	lateSidecar.close()
+
+	newLane, err := client.reserveBulkDedicatedLaneAtRoute(newRoute)
+	if err != nil {
+		t.Fatalf("reserve new-route lane: %v", err)
+	}
+	newSidecarLeft, newSidecarRight := net.Pipe()
+	defer newSidecarRight.Close()
+	newSidecar := newBulkDedicatedSidecar(newSidecarLeft, newLane)
+	if _, installed, err := client.installClientDedicatedSidecarAtRoute(newLane, newSidecar, newRoute); err != nil || !installed {
+		t.Fatalf("install new-route sidecar = installed=%v err=%v, want installed", installed, err)
+	}
+
+	client.releaseBulkDedicatedLaneAtRoute(newLane, oldRoute)
+	client.bulkDedicatedSidecarMu.Lock()
+	lane := client.bulkDedicatedLanes[newLane]
+	active := 0
+	if lane != nil {
+		active = lane.activeBulks
+	}
+	client.bulkDedicatedSidecarMu.Unlock()
+	if active != 1 {
+		t.Fatalf("old-route release changed new-route lane active count to %d, want 1", active)
+	}
+}
+
 func TestHandleBulkAttachSystemMessageAcceptedWritesDirectReplyBeforeDedicatedHandoff(t *testing.T) {
 	server := NewServer().(*ServerCommon)
 	UseLegacySecurityServer(server)
@@ -288,6 +427,112 @@ func TestHandleBulkAttachSystemMessageAcceptedWritesDirectReplyBeforeDedicatedHa
 	}
 }

+func TestHandleBulkAttachRejectsBulkWhosePrimaryTransportReattached(t *testing.T) {
+	server := NewServer().(*ServerCommon)
+	UseLegacySecurityServer(server)
+	runtimeCtx, runtimeCancel := context.WithCancel(context.Background())
+	defer runtimeCancel()
+	server.setServerSessionRuntime(&serverSessionRuntime{
+		stopCtx: runtimeCtx,
+		stopFn:  runtimeCancel,
+		queue:   stario.NewQueueCtx(runtimeCtx, 4, ^uint32(0)),
+	})
+	server.markSessionStarted()
+	defer server.markSessionStopped("test done", nil)
+
+	attachLeft, attachRight := net.Pipe()
+	defer attachRight.Close()
+	current := server.bootstrapAcceptedLogical("dedicated-stale-primary-current", nil, attachLeft)
+	if current == nil {
+		t.Fatal("bootstrapAcceptedLogical(current) should return logical")
+	}
+	primaryLeft, primaryRight := net.Pipe()
+	defer primaryRight.Close()
+	target := server.bootstrapAcceptedLogical("dedicated-stale-primary-target", nil, primaryLeft)
+	if target == nil {
+		t.Fatal("bootstrapAcceptedLogical(target) should return logical")
+	}
+	primaryTransport := target.CurrentTransportConn()
+	if primaryTransport == nil {
+		t.Fatal("target primary transport should exist")
+	}
+
+	bulk := newBulkHandle(context.Background(), server.getBulkRuntime(), serverFileScope(target), BulkOpenRequest{
+		BulkID:      "dedicated-stale-primary",
+		DataID:      7,
+		Dedicated:   true,
+		AttachToken: "attach-token",
+	}, 0, target, primaryTransport, primaryTransport.TransportGeneration(), nil, nil, nil, nil, nil)
+	if err := server.getBulkRuntime().register(serverFileScope(target), bulk); err != nil {
+		t.Fatalf("register dedicated bulk: %v", err)
+	}
+	defer bulk.finalize()
+
+	replacementLeft, replacementRight := net.Pipe()
+	defer replacementRight.Close()
+	if err := target.attachClientConnSessionTransport(replacementLeft); err != nil {
+		t.Fatalf("reattach target primary transport: %v", err)
+	}
+	reqPayload, err := server.sequenceEn(bulkAttachRequest{
+		PeerID:      target.ID(),
+		BulkID:      bulk.ID(),
+		AttachToken: "attach-token",
+	})
+	if err != nil {
+		t.Fatalf("encode bulk attach request: %v", err)
+	}
+	message := Message{
+		NetType:       NET_SERVER,
+		LogicalConn:   current,
+		TransportConn: current.CurrentTransportConn(),
+		TransferMsg: TransferMsg{
+			ID:    91,
+			Key:   systemBulkAttachKey,
+			Value: reqPayload,
+			Type:  MSG_SYS_WAIT,
+		},
+		inboundConn: attachLeft,
+	}
+
+	replyDone := make(chan bulkAttachResponse, 1)
+	go func() {
+		_ = attachRight.SetReadDeadline(time.Now().Add(time.Second))
+		payload, readErr := readDirectSignalFramePayload(attachRight)
+		if readErr != nil {
+			replyDone <- bulkAttachResponse{Error: readErr.Error()}
+			return
+		}
+		transfer, decodeErr := decodeDirectSignalPayload(server.sequenceDe, current.msgDeSnapshot(), current.secretKeySnapshot(), payload)
+		if decodeErr != nil {
+			replyDone <- bulkAttachResponse{Error: decodeErr.Error()}
+			return
+		}
+		resp, decodeErr := decodeBulkAttachResponse(server.sequenceDe, transfer.Value)
+		if decodeErr != nil {
+			resp.Error = decodeErr.Error()
+		}
+		replyDone <- resp
+	}()
+
+	if !server.handleBulkAttachSystemMessage(message) {
+		t.Fatal("handleBulkAttachSystemMessage should consume attach message")
+	}
+	select {
+	case resp := <-replyDone:
+		if resp.Accepted || resp.Error == "" {
+			t.Fatalf("stale-primary attach response = %+v, want rejection", resp)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("timed out waiting for stale-primary attach rejection")
+	}
+	if !current.transportAttachedSnapshot() {
+		t.Fatal("rejected attach must not detach the inbound attach connection")
+	}
+	if got := bulk.dedicatedConnSnapshot(); got != nil {
+		t.Fatalf("rejected stale-primary bulk attached sidecar %v", got)
+	}
+}
+
 func TestHandleBulkAttachSystemMessageDoesNotExposeSharedSidecarBeforeReplyCompletes(t *testing.T) {
 	server := NewServer().(*ServerCommon)
 	UseLegacySecurityServer(server)