feat(chat): 重试记忆改多槽 —— 每条失败各留自己的幂等键
RetryKeyMemory 从单槽改成多槽（slots: List<RetryKeySlot>，上限 MAX_SLOTS = 8，FIFO 淘汰最旧）。 单槽只记得最近一次失败那条，而用户的重试顺序不必和失败顺序一致：他重试 A 又失败、再回头去重试 更早失败的 B 时，B 的槽早被顶掉，那次重发只能铸新键 —— 而 B 那次失败完全可能是「服务端已经收下、 客户端没看见」，于是又落成第二条消息，正是本机制要消灭的重复。 - remember：同指纹先摘掉旧的、再追加到末尾（同一条又失败一次是更新它的键，不是并列两条）， 超过上限从头部丢最旧的，且刚写进去的那条一定留得住。 - forget：按 localId 清；一条都对不上就原样返回同一个实例；同 localId 万一有多条则一并清掉。 - keyFor：命中只消费那一条、其余槽全部保留；未命中铸新键且一条槽也不清 —— 单槽时代「未命中也要 清空」在多槽下会把别的失败记录一起抹掉，这条已显式写进 KDoc 以防后人照着旧注释改回去。 - ChatViewModel：代码逻辑一个字节没动（三个调用点的签名都没变），只把提到「单槽」「下一次发送就 被消费」的 KDoc 改成与新实现一致；值比较指纹、正文不归一、晚到的 message_persisted 刻意不清键 这几条 W15 纪律原样保留。 - 测试：RetryKeyMemoryTest 由 10 条重写为 16 条。删掉「未命中即清空记忆」那两条旧断言（新语义下 不再成立），新增：两条失败各自原样重试都落回自己的键（两种重试顺序各一条）、重试 A 不抹掉 B 的槽、 同指纹重复 remember 只留一条且键是最新的、超上限 FIFO 淘汰最旧且刚写的仍在、未命中时全部槽保留、 命中消费后其余槽保留。 验证：assembleDebug 与 testDebugUnitTest 均通过（--rerun-tasks 全量重跑）：760 → 766 测试 / 0 失败 / 0 错误。
This commit is contained in:
AskaEth committed
1 parent
b579732db6
commit
d3fc0c8005
3 files changed
+231
-100
No files matched your search
@@ -6,13 +6,13 @@ data class RetryKeySlot(val fingerprint: MessageFingerprint, val localId: String
|
||||
/**
|
||||
* [RetryKeyMemory.keyFor] 的判定结果：这一次发送该用哪个幂等键，以及记忆变成什么样。
|
||||
*
|
||||
* 两半都是判定的一部分，所以一起回：记忆**无论走哪一支都要被消费掉**（见 [RetryKeyMemory.keyFor]），
|
||||
* 两半都是判定的一部分，所以一起回：**命中的那一条**会被消费掉（见 [RetryKeyMemory.keyFor]），
|
||||
* 把它放进返回值，调用方就没有「用完了忘了清」的机会。
|
||||
*/
|
||||
data class RetryKeyDecision(val localId: String, val memory: RetryKeyMemory)
|
||||
|
||||
/**
|
||||
* 「上一次没发出去的那条」的记忆——**单槽**、纯值、可单测。
|
||||
* 「没发出去的那几条」的记忆——**多槽**、纯值、可单测。
|
||||
*
|
||||
* ## 它存在的理由
|
||||
* 幂等键要想真的挡住重复，就必须在**同一条消息**的两次发送之间保持不变。而「某次失败」并不
|
||||
@@ -25,45 +25,74 @@ data class RetryKeyDecision(val localId: String, val memory: RetryKeyMemory)
|
||||
* ## 三条纪律
|
||||
* 1. **只在回滚时写**（[remember]：发送失败 / 队列满被拒 / 附件与图片上传失败 / 图片处理失败…）：
|
||||
* 被受理的那条没有任何要记的东西。
|
||||
* 2. **在下一次发送时被消费**（[keyFor]）：指纹相等 ⇒ 复用那个键；不等 ⇒ 铸新键。**不等这一支
|
||||
* 同样消费**——用户改过字就是**另一条**消息，那条旧记录再留着，只会让「下一条恰好和上一条
|
||||
* 失败的一模一样」这种巧合偷偷复用别人的键。
|
||||
* 3. **按 `localId` 清**（[forget]），不是无条件清空：两条同时在飞时，一条被受理（它的键与槽里
|
||||
* 记的那条对不上）不该把另一条刚记下的重试键抹掉。
|
||||
* 2. **在用户下一次发送时按指纹取用**（[keyFor]）：指纹相等 ⇒ 复用那个键、**且只消费那一条**；
|
||||
* 不等 ⇒ 铸新键、**一条槽也不清**（多槽下「不等也清」是错的，见 [keyFor] 的注释）。
|
||||
* 3. **按 `localId` 清**（[forget]），不是无条件清空：几条同时在飞时，一条被受理（它的键与别的槽
|
||||
* 里记的那条对不上）不该把别条刚记下的重试键抹掉。
|
||||
*
|
||||
* ## 为什么单槽够
|
||||
* 记忆只对「用户下一次按发送」有意义，而那一次只可能是**最近一次失败**的那条——回滚已经把正文 /
|
||||
* 图片 / 附件还回输入栏了，用户改的就是它。同时在飞的多条各有自己的 `localId`，与重试语义无关。
|
||||
* ## 为什么是「多槽」：单槽的边界
|
||||
* 单槽只记得**最近一次**失败那条，而用户的重试顺序不必和失败顺序一致：他重试 A（又失败），再回头
|
||||
* 去重试更早失败的 B —— B 的槽早被 A 顶掉了，那次重发只能铸新键（[keyFor] 未命中），于是
|
||||
* 「服务端其实已经收下」的那条 B 落成**第二条**消息，正是本机制要消灭的重复。多槽让每条失败各留
|
||||
* 一个槽，用户重试哪一条就落回哪一条的键，与他的操作顺序无关。
|
||||
*
|
||||
* ## 上限与淘汰：FIFO，不是 LRU
|
||||
* 一条记录只在「用户可能还要重试」的窗口里有意义：失败后正文 / 图片 / 附件都还回了输入栏，他要么
|
||||
* 马上原样重发、要么早就改了内容（那就成了另一条消息，记录永远命中不了）。窗口外留下的只是垃圾，
|
||||
* 所以给一个小上界 [MAX_SLOTS]，满了丢**最旧**的（[remember] 里 FIFO）。刻意**不**做 LRU：命中
|
||||
* 并消费是**轮询**而不是访问 —— [keyFor] 把命中的那条整个摘走，与它有多旧无关，谈「最近使用」没有
|
||||
* 意义；也正因如此，剩下的槽天然还是写入顺序。
|
||||
*
|
||||
* ## 与「绝不自动重试」不矛盾
|
||||
* 这里一个字节都不自动重发：复用键只发生在**用户自己又按了一次发送**、且内容一字不差的时候。
|
||||
* 它做的唯一一件事是把那次重发变成幂等的。
|
||||
*/
|
||||
data class RetryKeyMemory(val slot: RetryKeySlot? = null) {
|
||||
data class RetryKeyMemory(val slots: List<RetryKeySlot> = emptyList()) {
|
||||
|
||||
/** 记下「这一条没发出去」（回滚时调用）。同一时刻只需要记住一条，后写的覆盖先写的。 */
|
||||
fun remember(fingerprint: MessageFingerprint, localId: String): RetryKeyMemory =
|
||||
RetryKeyMemory(RetryKeySlot(fingerprint, localId))
|
||||
/**
|
||||
* 记下「这一条没发出去」（回滚时调用）。
|
||||
*
|
||||
* 同一个指纹**先摘掉旧的、再把新的追加到末尾**：同一条又失败一次是**更新**它的键，而不是并列
|
||||
* 两条 —— 两条同指纹时 [keyFor] 只会命中更早那条，用户的重试反而用不上刚铸的键。超过
|
||||
* [MAX_SLOTS] 就从头部丢最旧的：本函数最多让**末尾**那条变新，淘汰因此绝不会伤到刚写的这条。
|
||||
*/
|
||||
fun remember(fingerprint: MessageFingerprint, localId: String): RetryKeyMemory {
|
||||
val kept = slots.filterNot { it.fingerprint == fingerprint } + RetryKeySlot(fingerprint, localId)
|
||||
return RetryKeyMemory(if (kept.size > MAX_SLOTS) kept.takeLast(MAX_SLOTS) else kept)
|
||||
}
|
||||
|
||||
/**
|
||||
* 忘掉 [localId] 那条——受理成功 / 撞上 `duplicate` / 气泡被收编时调用。
|
||||
*
|
||||
* 键对不上就**原样返回同一个实例**（不清）：槽里记的可能是另一条刚回滚的消息，顺手清掉它
|
||||
* 会让那条的重试退回「铸新键」。
|
||||
* 一条都对不上就**原样返回同一个实例**（一条也不清）：槽里躺的多半是别的刚回滚的消息，顺手清掉
|
||||
* 它们会让那几条的重试退回「铸新键」。同一个 `localId` 万一有多条（[remember] 保证不会有），
|
||||
* 一并清掉：留着一条键已被服务端受理过的记录，只会让将来的某次重发被当成重复吞掉。
|
||||
*/
|
||||
fun forget(localId: String): RetryKeyMemory =
|
||||
if (slot?.localId == localId) RetryKeyMemory() else this
|
||||
fun forget(localId: String): RetryKeyMemory {
|
||||
val kept = slots.filterNot { it.localId == localId }
|
||||
return if (kept.size == slots.size) this else RetryKeyMemory(kept)
|
||||
}
|
||||
|
||||
/**
|
||||
* 这一次发送该用哪个幂等键：内容与记下的那条一致 ⇒ **复用**它的键；否则铸一个新的
|
||||
* （[mint] 由调用方给，测试才能喂确定性的键，也才能断言「该不该铸」）。
|
||||
* 这一次发送该用哪个幂等键：内容与某条记录一致 ⇒ **复用**它的键，并**只消费那一条**（其余槽
|
||||
* 原样保留 —— 它们对应的是别的失败消息，正等着被各自的重试捡起来）；一条都对不上 ⇒ 铸一个新的
|
||||
* （[mint] 由调用方给，测试才能喂确定性的键，也才能断言「该不该铸」），**且一条槽也不清**。
|
||||
*
|
||||
* 无论走哪一支，返回的 [RetryKeyDecision.memory] 都是空的——消费掉记录是本函数的定义的一部分
|
||||
* （见类注释第 2 条），而不是调用方的义务。
|
||||
* 最后这半句是与单槽时代最本质的差别，**别照着旧注释改回去**：那时记忆只有一条，「未命中就清空」
|
||||
* 与「保留」是同一件事；多槽下清空会把用户**别的**失败记录一并抹掉（他重试 A 时铸了新键，接着去
|
||||
* 重试 B，B 的槽已经没了 ⇒ 那次重发退化成非幂等）。未命中只说明「这次的正文没有任何失败记录对得
|
||||
* 上」，不是「记忆都作废了」。
|
||||
*/
|
||||
fun keyFor(fingerprint: MessageFingerprint, mint: () -> String): RetryKeyDecision =
|
||||
when (val remembered = slot?.takeIf { it.fingerprint == fingerprint }) {
|
||||
null -> RetryKeyDecision(mint(), RetryKeyMemory())
|
||||
else -> RetryKeyDecision(remembered.localId, RetryKeyMemory())
|
||||
}
|
||||
fun keyFor(fingerprint: MessageFingerprint, mint: () -> String): RetryKeyDecision {
|
||||
val hitIndex = slots.indexOfFirst { it.fingerprint == fingerprint }
|
||||
if (hitIndex < 0) return RetryKeyDecision(mint(), this)
|
||||
|
||||
val consumed = RetryKeyMemory(slots.filterIndexed { index, _ -> index != hitIndex })
|
||||
return RetryKeyDecision(slots[hitIndex].localId, consumed)
|
||||
}
|
||||
|
||||
companion object {
|
||||
/** 同时保留的失败记录条数上限；淘汰策略见类注释「上限与淘汰」。 */
|
||||
const val MAX_SLOTS = 8
|
||||
}
|
||||
}
|
||||
@@ -58,7 +58,7 @@ private const val DEVICE_ID = "voiceassist:cyrene:v1"
|
||||
* [localId] 同时是**上行幂等键** `clientMsgId`（契约 v0.56 §3.13）：同一会话内服务端只承认
|
||||
* 第一个非空值，重复到达回 `chat_duplicate`（WS）或 `{duplicate:true,messageId}`（REST）而
|
||||
* **不再落库、不再起回合**。所以**同一条内容**的手动重试可以**复用**同一个 id：回滚时按
|
||||
* [MessageFingerprint] 把它记进 [ChatViewModel] 的单槽记忆，下一次发送指纹相等就接着用——
|
||||
* [MessageFingerprint] 把它记进 [ChatViewModel] 的失败记忆，下一次发送指纹相等就接着用——
|
||||
* 「服务端其实已经收下、客户端判成失败」那种失败（队列满 / 超时 / 回执丢失）因此不会在
|
||||
* 重试时落成第二条消息。指纹**不相等**（用户改过字 / 换了图 / 动了附件）则铸新键：
|
||||
* 那是**另一条**消息，绝不能顶替。它必须足够唯一：服务端的判重窗口是**整个会话历史**
|
||||
@@ -436,14 +436,15 @@ class ChatViewModel(
|
||||
private var streamParser: StreamingContentParser? = null
|
||||
|
||||
/**
|
||||
* 「上一次没发出去的那条」的记忆：**回滚**时按内容指纹记下它用的幂等键，**下一次发送**
|
||||
* 指纹相等就复用那个键（见 [RetryKeyMemory]）。
|
||||
* 「没发出去的那几条」的记忆（**多槽**，见 [RetryKeyMemory]）：**回滚**时按内容指纹记下那条用的
|
||||
* 幂等键，**下一次发送**指纹相等就复用那个键。复用时**只消费命中的那一条**，别的失败记录原样
|
||||
* 留着 —— 用户重试的顺序不必和失败顺序一致，抹掉它们就等于让那几条的重发退回「铸新键」。
|
||||
*
|
||||
* 这就是「手动重试同一个键 = 幂等」的落地处：**没有任何自动重试**，键的复用只在用户自己
|
||||
* 又按了一次发送、且内容一字不差时发生（[emitAndDeliver] 是唯一的消费者）。所有回滚路径都
|
||||
* 汇到 [rollback]，所以只有那一个写入口。
|
||||
*
|
||||
* 受理那一半由 [onAck] / [alignDuplicate] / [onQueueFull] 按 `localId` 清（正常那一路其实在
|
||||
* 受理那一半由 [onAck] / [alignDuplicate] / [onQueueFull] 按 `localId` 清（命中那一条其实在
|
||||
* 发送时就已经被消费掉了，那几步是兜底）。但**落库消息到达时（[onPersisted] / [reconcilePending]）
|
||||
* 刻意不清**：一条晚到的 `message_persisted` 恰恰是「服务端其实收下了、客户端当时判成失败」
|
||||
* 的证据，这时候把键留着，用户接下来的重试才会被判重而不是落成第二条消息 —— 那正是本机制
|
||||
@@ -606,11 +607,11 @@ class ChatViewModel(
|
||||
) {
|
||||
if (text.isEmpty() && imageUri == null && documents.isEmpty()) return
|
||||
|
||||
// `localId` 即幂等键。它与「上一次没发出去的那条」内容一致时**复用当时的键**：
|
||||
// `localId` 即幂等键。它与「某条没发出去的记录」内容一致时**复用当时的键**：
|
||||
// 那次失败可能是「服务端已经收下、客户端判成失败」（队列满 / 超时 / 回执丢失），
|
||||
// 复用键会让服务端判重并回 `chat_duplicate` / `{duplicate:true}`，而不是落成第二条消息。
|
||||
// 内容不同（改过字 / 换图 / 动了附件）则铸新键——用户的编辑是一条**新**消息。
|
||||
// 记忆无论走哪一支都在这里被消费掉，绝不会被下一次发送再捡起来。
|
||||
// 消费只发生在命中那一支：命中的那条记录在这里被摘走，别的失败记录原样留着（见 [RetryKeyMemory]）。
|
||||
val decision = retryKey.keyFor(MessageFingerprint.of(text, imageUri, documents)) {
|
||||
"local-${UUID.randomUUID()}"
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user