127 lines
4 KiB
Go
127 lines
4 KiB
Go
package rpc
|
||
|
||
import (
|
||
"crypto/rand"
|
||
"encoding/binary"
|
||
"hash/fnv"
|
||
"sync"
|
||
"sync/atomic"
|
||
|
||
"telesrv/internal/domain"
|
||
)
|
||
|
||
// callbackRegistry 是 bot callback query 的进程内挂起表：messages.getBotCallbackAnswer
|
||
// 注册一个 (query_id → chan)，把 updateBotCallbackQuery 推给 bot 后阻塞等待；bot 经
|
||
// messages.setBotCallbackAnswer 用同一 query_id 解挂。单实例可行；多实例需共享通道
|
||
// （getBotCallbackAnswer 与 setBotCallbackAnswer 落不同实例则等不到 → 超时），记架构 todo。
|
||
type callbackRegistry struct {
|
||
mu sync.Mutex
|
||
pending map[int64]*pendingCallback
|
||
}
|
||
|
||
type pendingCallback struct {
|
||
ch chan domain.BotCallbackAnswer
|
||
done chan struct{} // deregister 时关闭：唤醒超时退出的等待者，消除「答案投递到已离开 select 的 ch」竞态
|
||
botUserID int64
|
||
userID int64
|
||
}
|
||
|
||
func newCallbackRegistry() *callbackRegistry {
|
||
return &callbackRegistry{pending: make(map[int64]*pendingCallback)}
|
||
}
|
||
|
||
// register 登记一次挂起的 callback，返回全局唯一 query_id 与接收通道。调用方必须
|
||
// defer deregister(queryID)，无论是否收到答案（超时三件套之一，防 goroutine/表泄漏）。
|
||
func (c *callbackRegistry) register(botUserID, userID int64) (int64, *pendingCallback) {
|
||
p := &pendingCallback{
|
||
ch: make(chan domain.BotCallbackAnswer, 1),
|
||
done: make(chan struct{}),
|
||
botUserID: botUserID,
|
||
userID: userID,
|
||
}
|
||
c.mu.Lock()
|
||
defer c.mu.Unlock()
|
||
var queryID int64
|
||
for {
|
||
queryID = randomNonZeroInt64()
|
||
if _, exists := c.pending[queryID]; !exists {
|
||
break
|
||
}
|
||
}
|
||
c.pending[queryID] = p
|
||
return queryID, p
|
||
}
|
||
|
||
// deregister 移除挂起条目并关闭 done（超时/解挂后必调，幂等）。关闭 done 让仍在
|
||
// select 的等待者立即醒来，避免 resolve 把答案投递到一个等待者已离开的 ch（TOCTOU）。
|
||
func (c *callbackRegistry) deregister(queryID int64) {
|
||
c.mu.Lock()
|
||
if p, ok := c.pending[queryID]; ok {
|
||
delete(c.pending, queryID)
|
||
close(p.done)
|
||
}
|
||
c.mu.Unlock()
|
||
}
|
||
|
||
// size 返回当前挂起条目数（测试用：断言超时/解挂后归零、无泄漏）。
|
||
func (c *callbackRegistry) size() int {
|
||
c.mu.Lock()
|
||
defer c.mu.Unlock()
|
||
return len(c.pending)
|
||
}
|
||
|
||
// resolve 把 bot 的答案投递给等待者。鉴权：仅该 query 的属主 bot 可解挂（callerBotID
|
||
// 必须等于注册时的 botUserID，I6）。返回是否成功投递（query 未注册/已超时/非属主 → false）。
|
||
func (c *callbackRegistry) resolve(callerBotID, queryID int64, ans domain.BotCallbackAnswer) bool {
|
||
c.mu.Lock()
|
||
p, ok := c.pending[queryID]
|
||
if !ok || p.botUserID != callerBotID {
|
||
c.mu.Unlock()
|
||
return false
|
||
}
|
||
delete(c.pending, queryID)
|
||
c.mu.Unlock()
|
||
// ch 有 1 容量缓冲，非阻塞投递；等待者已超时退出时缓冲被 GC，不阻塞。
|
||
select {
|
||
case p.ch <- ans:
|
||
default:
|
||
}
|
||
return true
|
||
}
|
||
|
||
// randomNonZeroInt64 取密码学随机非零 int64。register 在持锁下调用，故此处禁止
|
||
// 无限重试——熵源异常时退化为单调序列兜底（query_id 只需进程内唯一，register 的
|
||
// 撞键复核会再保证唯一性），绝不卡住整个 registry。
|
||
func randomNonZeroInt64() int64 {
|
||
var buf [8]byte
|
||
for i := 0; i < 8; i++ {
|
||
if _, err := rand.Read(buf[:]); err != nil {
|
||
break
|
||
}
|
||
if v := int64(binary.LittleEndian.Uint64(buf[:])); v != 0 {
|
||
return v
|
||
}
|
||
}
|
||
if v := callbackFallbackSeq.Add(1); v != 0 {
|
||
return v
|
||
}
|
||
return 1
|
||
}
|
||
|
||
// callbackFallbackSeq 是熵源失败时的单调兜底序列（极罕见路径）。
|
||
var callbackFallbackSeq atomic.Int64
|
||
|
||
// chatInstanceFor 为 (bot,user) 私聊派生稳定的 chat_instance（同一对话多次 callback
|
||
// 间恒定，I8）。当前用确定性 hash 派生（持久化记 todo）。
|
||
func chatInstanceFor(botUserID, userID int64) int64 {
|
||
h := fnv.New64a()
|
||
var buf [16]byte
|
||
binary.LittleEndian.PutUint64(buf[0:8], uint64(botUserID))
|
||
binary.LittleEndian.PutUint64(buf[8:16], uint64(userID))
|
||
_, _ = h.Write(buf[:])
|
||
v := int64(h.Sum64())
|
||
if v == 0 {
|
||
v = 1
|
||
}
|
||
return v
|
||
}
|