cancerai/toolbox
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

beta v0.2 dualcheck

Browse Source
This commit is contained in:
cancerai committed 2026-08-30 21:25:22 +08:00
1 parent c137299016
commit 1ec68bacf5
14 files changed
+1591 -359
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

server/internal/response/response.go
+29
View File
@@ -118,3 +118,32 @@ func WSResubmitChanged(allow bool) WebSocketMessage {
Data: map[string]bool{"allow": allow},
}
}
// WSIgnoreWsChanged 发起方切换了"忽略首尾空白"开关
func WSIgnoreWsChanged(ignore bool) WebSocketMessage {
return WebSocketMessage{
Type: "ignore_ws_changed",
Data: map[string]bool{"ignore": ignore},
}
}
// WSParticipantRenamed 参与者修改了昵称（old → new）
func WSParticipantRenamed(oldNick, newNick string) WebSocketMessage {
return WebSocketMessage{
Type: "participant_nickname_changed",
Data: map[string]string{
"old_nickname": oldNick,
"new_nickname": newNick,
},
}
}
// WSNicknameAutoChanged 服务端因昵称冲突自动改名后通知该客户端
func WSNicknameAutoChanged(nick string) WebSocketMessage {
return WebSocketMessage{
Type: "nickname_auto_changed",
Data: map[string]string{
"nickname": nick,
},
}
}
server/internal/store/redis_session_store.go
+249 -23
View File
@@ -9,23 +9,34 @@ import (
"time"
"github.com/redis/go-redis/v9"
"cancerai.top/toolbox-server/internal/pkg/hash"
)
// 包级错误，业务层可以 errors.Is 检查
var (
ErrSessionNotFound = errors.New("session not found or expired")
ErrDuplicateJoin = errors.New("nickname already joined this session")
ErrDuplicateSubmit = errors.New("this nickname has already submitted")
ErrSessionNotFound = errors.New("session not found or expired")
ErrDuplicateJoin = errors.New("nickname already joined this session")
ErrDuplicateSubmit = errors.New("this nickname has already submitted")
ErrNicknameConflict = errors.New("nickname conflict (exists or matches initiator)")
ErrOldNotFound = errors.New("old nickname not found in session")
)
const (
redisKeyPrefix = "dualcheck:session:"
fieldCreatedAt = "created_at"
fieldInitHash = "initiator_hash"
fieldInitText = "initiator_text" // 发起方原始文本（trim 前）
fieldInitNick = "initiator_nickname"
fieldInitBrowser = "initiator_browser_id"
fieldAllowResub = "allow_resubmit"
// participant:{nick} 存该参与者的哈希值；participant:{nick}:match 存 "1"/"0"
fieldIgnoreWs = "ignore_ws"
// participant:{nick} 存该参与者的哈希值；participant:{nick}:text 存原始文本；participant:{nick}:match 存 "1"/"0"
// participant:{nick}:browser_id 存该参与者的 browserId
partFieldPrefix = "participant:"
partTextSuffix = ":text"
partMatchSuffix = ":match"
partBrowserSuffix = ":browser_id"
)
// ── 五个 Lua 脚本 ──
@@ -37,17 +48,22 @@ if redis.call("EXISTS", key) ~= 0 then
return 0
end
redis.call("HSET", key, "created_at", ARGV[1])
redis.call("HSET", key, "initiator_nickname", ARGV[2])
redis.call("HSET", key, "initiator_browser_id", ARGV[3])
redis.call("HSET", key, "allow_resubmit", "0")
redis.call("EXPIRE", key, ARGV[2])
redis.call("HSET", key, "ignore_ws", "0")
redis.call("EXPIRE", key, ARGV[4])
return 1
`)
// joinParticipantLuaScript 登记参与者昵称（空哈希占位，表示已加入未提交）
// KEYS[1] = session key
// ARGV[1] = nickname
// ARGV[2] = browserId
var joinParticipantLuaScript = redis.NewScript(`
local key = KEYS[1]
local nick = ARGV[1]
local bid = ARGV[2] or ""
local exists = redis.call("EXISTS", key)
if exists == 0 then
return redis.error_reply("SESSION_NOT_FOUND")
@@ -58,20 +74,25 @@ if redis.call("HEXISTS", key, field) == 1 then
return 1
end
redis.call("HSET", key, field, "")
if bid ~= "" then
redis.call("HSET", key, field .. ":browser_id", bid)
end
return 1
`)
// submitParticipantLuaScript 参与者提交自己的哈希
// 原子完成：检查 → 写入 → 与 initiator_hash 比对（若发起方已提交）
// 原子完成：检查 → 写入哈希+原始文本 → 与 initiator_hash 比对（若发起方已提交）
// 若已提交但 allow_resubmit=1 则覆盖（重算 match）
// KEYS[1] = session key
// ARGV[1] = nickname
// ARGV[2] = hash hex
// ARGV[2] = hash hex（已按当前 ignore_ws 规则 trim + hash）
// ARGV[3] = 原始文本（trim 前）
// 返回 {initiatorSubmitted (0/1), match ("1"/"0"/"")}
var submitParticipantLuaScript = redis.NewScript(`
local key = KEYS[1]
local nick = ARGV[1]
local hash_val = ARGV[2]
local orig_text = ARGV[3]
if redis.call("EXISTS", key) == 0 then
return redis.error_reply("SESSION_NOT_FOUND")
@@ -90,8 +111,9 @@ if existing ~= "" then
end
end
-- 写入（覆盖）哈希
-- 写入（覆盖）哈希 + 原始文本
redis.call("HSET", key, field, hash_val)
redis.call("HSET", key, field .. ":text", orig_text)
-- 清除旧的 match 字段，稍后按需重算
redis.call("HDEL", key, field .. ":match")
@@ -106,14 +128,16 @@ end
`)
// submitInitiatorLuaScript 发起方提交标准答案
// 写入 initiator_hash 后，遍历所有已提交的 participant，批量计算 match
// 写入 initiator_hash + initiator_text 后，遍历所有已提交的 participant，批量计算 match
// KEYS[1] = session key
// ARGV[1] = nickname
// ARGV[2] = initiator hash
// ARGV[2] = initiator hash（已按当前 ignore_ws 规则 trim + hash）
// ARGV[3] = 原始文本（trim 前）
var submitInitiatorLuaScript = redis.NewScript(`
local key = KEYS[1]
local nick = ARGV[1]
local init_hash = ARGV[2]
local orig_text = ARGV[3]
if redis.call("EXISTS", key) == 0 then
return redis.error_reply("SESSION_NOT_FOUND")
@@ -125,6 +149,7 @@ if redis.call("HEXISTS", key, "initiator_hash") == 1 then
end
redis.call("HSET", key, "initiator_hash", init_hash)
redis.call("HSET", key, "initiator_text", orig_text)
redis.call("HSET", key, "initiator_nickname", nick)
-- 遍历所有 participant:{nick} 且哈希非空的，计算 match
@@ -134,6 +159,7 @@ for i = 1, #all, 2 do
local val = all[i + 1]
if string.sub(field, 1, #("participant:")) == "participant:"
and not string.find(field, ":match$")
and not string.find(field, ":text$")
and val ~= "" then
local match = (val == init_hash) and "1" or "0"
redis.call("HSET", key, field .. ":match", match)
@@ -142,6 +168,71 @@ end
return 1
`)
// renameParticipantLuaScript 原子重命名参与者
// 检查：session 存在、old 存在、new 不与 initiator_nickname/已有 participant 冲突
// （但如果 oldNick 的 browserId 和冲突方相同，视为同一个人，跳过冲突）
// 迁移 participant:{old}、participant:{old}:text、participant:{old}:match、participant:{old}:browser_id → new
// KEYS[1] = session key
// ARGV[1] = old nickname
// ARGV[2] = new nickname
// ARGV[3] = old participant's browserId
var renameParticipantLuaScript = redis.NewScript(`
local key = KEYS[1]
local oldNick = ARGV[1]
local newNick = ARGV[2]
local oldBid = ARGV[3] or ""
if redis.call("EXISTS", key) == 0 then
return redis.error_reply("SESSION_NOT_FOUND")
end
-- oldNick 必须存在
local oldField = "participant:" .. oldNick
if redis.call("HEXISTS", key, oldField) == 0 then
return redis.error_reply("OLD_NOT_FOUND")
end
-- newNick 不能等于发起方昵称（除非是同一个浏览器）
local initNick = redis.call("HGET", key, "initiator_nickname")
local initBid = redis.call("HGET", key, "initiator_browser_id") or ""
if initNick and initNick == newNick then
if oldBid == "" or initBid ~= oldBid then
return redis.error_reply("NICKNAME_CONFLICT")
end
end
-- newNick 不能已被其他 participant 占用（除非是同一个浏览器）
local newField = "participant:" .. newNick
if redis.call("HEXISTS", key, newField) == 1 then
local newBid = redis.call("HGET", key, newField .. ":browser_id") or ""
if oldBid == "" or newBid ~= oldBid then
return redis.error_reply("NICKNAME_CONFLICT")
end
end
-- 迁移四个 field
local hashVal = redis.call("HGET", key, oldField)
local textVal = redis.call("HGET", key, oldField .. ":text")
local matchVal = redis.call("HGET", key, oldField .. ":match")
local bidVal = redis.call("HGET", key, oldField .. ":browser_id")
redis.call("HSET", key, newField, hashVal)
if textVal ~= false then
redis.call("HSET", key, newField .. ":text", textVal)
end
if matchVal ~= false then
redis.call("HSET", key, newField .. ":match", matchVal)
end
if bidVal ~= false then
redis.call("HSET", key, newField .. ":browser_id", bidVal)
end
redis.call("HDEL", key, oldField)
redis.call("HDEL", key, oldField .. ":text")
redis.call("HDEL", key, oldField .. ":match")
redis.call("HDEL", key, oldField .. ":browser_id")
return 1
`)
// ── RedisSessionStore 实现 ──
type RedisSessionStore struct {
@@ -158,14 +249,15 @@ func key(sessionID string) string {
}
// Create 原子创建会话 Hash key
func (s *RedisSessionStore) Create(ctx context.Context, sessionID string, ttl time.Duration) error {
func (s *RedisSessionStore) Create(ctx context.Context, sessionID, initiatorNickname, initiatorBrowserID string, ttl time.Duration) error {
if ttl <= 0 {
ttl = s.ttl
}
now := time.Now().Unix()
ttlSeconds := int64(ttl.Seconds())
result, err := createLuaScript.Run(ctx, s.rdb, []string{key(sessionID)}, now, ttlSeconds).Int64()
result, err := createLuaScript.Run(ctx, s.rdb, []string{key(sessionID)},
now, initiatorNickname, initiatorBrowserID, ttlSeconds).Int64()
if err != nil {
return fmt.Errorf("redis create session: %w", err)
}
@@ -176,8 +268,8 @@ func (s *RedisSessionStore) Create(ctx context.Context, sessionID string, ttl ti
}
// JoinParticipant 登记参与者（空哈希占位）
func (s *RedisSessionStore) JoinParticipant(ctx context.Context, sessionID, nickname string) error {
_, err := joinParticipantLuaScript.Run(ctx, s.rdb, []string{key(sessionID)}, nickname).Int64()
func (s *RedisSessionStore) JoinParticipant(ctx context.Context, sessionID, nickname, browserID string) error {
_, err := joinParticipantLuaScript.Run(ctx, s.rdb, []string{key(sessionID)}, nickname, browserID).Int64()
if err != nil {
msg := err.Error()
if strings.Contains(msg, "SESSION_NOT_FOUND") {
@@ -188,9 +280,9 @@ func (s *RedisSessionStore) JoinParticipant(ctx context.Context, sessionID, nick
return nil
}
// SubmitParticipant 参与者提交自己的文本哈希
func (s *RedisSessionStore) SubmitParticipant(ctx context.Context, sessionID, nickname, hashHex string) (bool, *bool, error) {
result, err := submitParticipantLuaScript.Run(ctx, s.rdb, []string{key(sessionID)}, nickname, hashHex).Result()
// SubmitParticipant 参与者提交自己的文本哈希（同时存原始文本）
func (s *RedisSessionStore) SubmitParticipant(ctx context.Context, sessionID, nickname, hashHex, originalText string) (bool, *bool, error) {
result, err := submitParticipantLuaScript.Run(ctx, s.rdb, []string{key(sessionID)}, nickname, hashHex, originalText).Result()
if err != nil {
msg := err.Error()
switch {
@@ -200,10 +292,10 @@ func (s *RedisSessionStore) SubmitParticipant(ctx context.Context, sessionID, ni
return false, nil, ErrDuplicateSubmit
case strings.Contains(msg, "NICKNAME_NOT_JOINED"):
// 参与者没走 join 直接 submit，自动补登记
if err := s.JoinParticipant(ctx, sessionID, nickname); err != nil {
if err := s.JoinParticipant(ctx, sessionID, nickname, ""); err != nil {
return false, nil, err
}
return s.SubmitParticipant(ctx, sessionID, nickname, hashHex)
return s.SubmitParticipant(ctx, sessionID, nickname, hashHex, originalText)
default:
return false, nil, fmt.Errorf("redis submit participant: %w", err)
}
@@ -219,9 +311,9 @@ func (s *RedisSessionStore) SubmitParticipant(ctx context.Context, sessionID, ni
return initSubmitted, match, nil
}
// SubmitInitiator 发起方提交标准答案哈希
func (s *RedisSessionStore) SubmitInitiator(ctx context.Context, sessionID, nickname, hashHex string) error {
_, err := submitInitiatorLuaScript.Run(ctx, s.rdb, []string{key(sessionID)}, nickname, hashHex).Int64()
// SubmitInitiator 发起方提交标准答案哈希（同时存原始文本）
func (s *RedisSessionStore) SubmitInitiator(ctx context.Context, sessionID, nickname, hashHex, originalText string) error {
_, err := submitInitiatorLuaScript.Run(ctx, s.rdb, []string{key(sessionID)}, nickname, hashHex, originalText).Int64()
if err != nil {
if strings.Contains(err.Error(), "SESSION_NOT_FOUND") {
return ErrSessionNotFound
@@ -248,6 +340,134 @@ func (s *RedisSessionStore) SetResubmit(ctx context.Context, sessionID string, a
return s.rdb.HSet(ctx, key, fieldAllowResub, val).Err()
}
func (s *RedisSessionStore) SetIgnoreWs(ctx context.Context, sessionID string, ignore bool) error {
key := key(sessionID)
exists, err := s.rdb.Exists(ctx, key).Result()
if err != nil {
return fmt.Errorf("redis exists: %w", err)
}
if exists == 0 {
return ErrSessionNotFound
}
val := "0"
if ignore {
val = "1"
}
return s.rdb.HSet(ctx, key, fieldIgnoreWs, val).Err()
}
func (s *RedisSessionStore) GetIgnoreWs(ctx context.Context, sessionID string) (bool, error) {
v, err := s.rdb.HGet(ctx, key(sessionID), fieldIgnoreWs).Result()
if err != nil {
if err == redis.Nil {
return false, nil
}
return false, fmt.Errorf("redis hget ignore_ws: %w", err)
}
return v == "1", nil
}
// RecalcMatches 按新的 ignoreWs 规则重新 trim + hash 所有已提交文本并重算 match
func (s *RedisSessionStore) RecalcMatches(ctx context.Context, sessionID string, ignoreWs bool) error {
k := key(sessionID)
all, err := s.rdb.HGetAll(ctx, k).Result()
if err != nil {
return fmt.Errorf("redis hgetall: %w", err)
}
if len(all) == 0 {
return ErrSessionNotFound
}
// 读发起方原始文本
initText := all[fieldInitText]
if initText == "" {
return nil // 发起方还没提交，不需要重算
}
initProcessed := initText
if ignoreWs {
initProcessed = strings.TrimSpace(initText)
}
initHash := hash.SHA256(initProcessed)
pipe := s.rdb.TxPipeline()
pipe.HSet(ctx, k, fieldInitHash, initHash)
// 遍历所有已提交参与者，重算 hash + match
for field, val := range all {
if !strings.HasPrefix(field, partFieldPrefix) {
continue
}
if strings.HasSuffix(field, partMatchSuffix) || strings.HasSuffix(field, partTextSuffix) {
continue
}
if val == "" {
continue
}
textField := field + partTextSuffix
origText := all[textField]
if origText == "" {
continue // 旧数据（没存过原始文本），跳过
}
processed := origText
if ignoreWs {
processed = strings.TrimSpace(origText)
}
newHash := hash.SHA256(processed)
match := "0"
if newHash == initHash {
match = "1"
}
pipe.HSet(ctx, k, field, newHash)
pipe.HSet(ctx, k, field+partMatchSuffix, match)
}
_, err = pipe.Exec(ctx)
if err != nil {
return fmt.Errorf("redis recalc pipeline: %w", err)
}
return nil
}
// UpdateParticipantNickname 原子重命名参与者
func (s *RedisSessionStore) UpdateParticipantNickname(ctx context.Context, sessionID, oldNick, newNick, oldBrowserID string) error {
_, err := renameParticipantLuaScript.Run(ctx, s.rdb, []string{key(sessionID)}, oldNick, newNick, oldBrowserID).Int64()
if err != nil {
msg := err.Error()
switch {
case strings.Contains(msg, "SESSION_NOT_FOUND"):
return ErrSessionNotFound
case strings.Contains(msg, "OLD_NOT_FOUND"):
return ErrOldNotFound
case strings.Contains(msg, "NICKNAME_CONFLICT"):
return ErrNicknameConflict
default:
return fmt.Errorf("redis rename participant: %w", err)
}
}
return nil
}
// RemoveParticipant 参与者离开时从 Redis 删除其所有字段
func (s *RedisSessionStore) RemoveParticipant(ctx context.Context, sessionID, nickname string) error {
k := key(sessionID)
exists, err := s.rdb.Exists(ctx, k).Result()
if err != nil {
return fmt.Errorf("redis exists: %w", err)
}
if exists == 0 {
return ErrSessionNotFound
}
pipe := s.rdb.TxPipeline()
pipe.HDel(ctx, k, partFieldPrefix+nickname)
pipe.HDel(ctx, k, partFieldPrefix+nickname+partTextSuffix)
pipe.HDel(ctx, k, partFieldPrefix+nickname+partMatchSuffix)
_, err = pipe.Exec(ctx)
if err != nil {
return fmt.Errorf("redis remove participant: %w", err)
}
return nil
}
// Get 获取会话当前状态全量快照
func (s *RedisSessionStore) Get(ctx context.Context, sessionID string) (*SessionSnapshot, error) {
exists, err := s.rdb.Exists(ctx, key(sessionID)).Result()
@@ -272,8 +492,10 @@ func (s *RedisSessionStore) Get(ctx context.Context, sessionID string) (*Session
SessionID: sessionID,
InitiatorHash: hash[fieldInitHash],
InitiatorNickname: hash[fieldInitNick],
InitiatorBrowserID: hash[fieldInitBrowser],
InitiatorSubmitted: hash[fieldInitHash] != "",
AllowResubmit: hash[fieldAllowResub] == "1",
IgnoreWs: hash[fieldIgnoreWs] == "1",
ExpiresAt: time.Now().Add(ttl),
}
@@ -281,7 +503,10 @@ func (s *RedisSessionStore) Get(ctx context.Context, sessionID string) (*Session
var nicks []string
partMap := map[string]string{} // nick → hash
for k, v := range hash {
if strings.HasPrefix(k, partFieldPrefix) && !strings.HasSuffix(k, ":match") {
if strings.HasPrefix(k, partFieldPrefix) &&
!strings.HasSuffix(k, partMatchSuffix) &&
!strings.HasSuffix(k, partTextSuffix) &&
!strings.HasSuffix(k, partBrowserSuffix) {
nick := strings.TrimPrefix(k, partFieldPrefix)
nicks = append(nicks, nick)
partMap[nick] = v
@@ -294,6 +519,7 @@ func (s *RedisSessionStore) Get(ctx context.Context, sessionID string) (*Session
h := partMap[nick]
p := ParticipantInfo{
Nickname: nick,
BrowserID: hash[partFieldPrefix+nick+partBrowserSuffix],
Submitted: h != "",
}
if h != "" && initiatorHash != "" {
server/internal/store/session_store.go
+28 -8
View File
@@ -17,6 +17,7 @@ type Session struct {
// ParticipantInfo 参与者在全量快照中的状态
type ParticipantInfo struct {
Nickname string `json:"nickname"`
BrowserID string `json:"browser_id,omitempty"`
Submitted bool `json:"submitted"`
Match *bool `json:"match,omitempty"`
}
@@ -26,33 +27,52 @@ type SessionSnapshot struct {
SessionID string `json:"session_id"`
InitiatorHash string `json:"-"` // 发起方标准答案哈希，不对外暴露
InitiatorNickname string `json:"initiator_nickname"`
InitiatorBrowserID string `json:"initiator_browser_id,omitempty"`
InitiatorSubmitted bool `json:"initiator_submitted"`
AllowResubmit bool `json:"allow_resubmit"`
IgnoreWs bool `json:"ignore_ws"` // 是否忽略首尾空白
Participants []ParticipantInfo `json:"participants"`
ExpiresAt time.Time `json:"expires_at"`
}
// SessionStore 会话存储接口
type SessionStore interface {
// Create 原子创建会话（SET NX EX）
Create(ctx context.Context, id string, ttl time.Duration) error
// Create 原子创建会话（SET NX EX），同时记录发起方昵称和 browserId
Create(ctx context.Context, id, initiatorNickname, initiatorBrowserID string, ttl time.Duration) error
// SubmitInitiator 发起方提交标准答案（initiator_hash + initiator_nickname）
// SubmitInitiator 发起方提交标准答案（initiator_hash + initiator_nickname + 原始文本）
// 同时立即为所有已提交的参与者计算 match
SubmitInitiator(ctx context.Context, sessionID, nickname, hashHex string) error
SubmitInitiator(ctx context.Context, sessionID, nickname, hashHex, originalText string) error
// SubmitParticipant 参与者提交自己的文本（按 nickname 唯一标识）
// SubmitParticipant 参与者提交自己的文本（按 nickname 唯一标识，同时存原始文本）
// 返回：initiatorSubmitted（发起方是否已提交，是则 match 已算出）、match
SubmitParticipant(ctx context.Context, sessionID, nickname, hashHex string) (
SubmitParticipant(ctx context.Context, sessionID, nickname, hashHex, originalText string) (
initiatorSubmitted bool, match *bool, err error)
// JoinParticipant 参与者加入会话（只登记昵称，不提交文本）
// 用于 WS 连接时实时广播 joined 事件
JoinParticipant(ctx context.Context, sessionID, nickname string) error
// browserId 用于识别"同一个人"，避免跨 tab 昵称冲突
JoinParticipant(ctx context.Context, sessionID, nickname, browserID string) error
// SetResubmit 设置是否允许参与者重复提交
SetResubmit(ctx context.Context, sessionID string, allow bool) error
// SetIgnoreWs 设置比对时是否忽略首尾空白（1=忽略，0=不忽略）
SetIgnoreWs(ctx context.Context, sessionID string, ignore bool) error
// GetIgnoreWs 获取当前会话的 ignore_ws 设置
GetIgnoreWs(ctx context.Context, sessionID string) (bool, error)
// RecalcMatches 按新的 ignoreWs 规则重新 trim + hash 所有已提交文本并重算 match
RecalcMatches(ctx context.Context, sessionID string, ignoreWs bool) error
// UpdateParticipantNickname 原子重命名参与者：将 participant:{old} → participant:{new}
// oldBrowserID 用于判断是否与冲突方是同一个浏览器（跳过冲突）
// 返回业务错误：ErrSessionNotFound / ErrNicknameConflict
UpdateParticipantNickname(ctx context.Context, sessionID, oldNick, newNick, oldBrowserID string) error
// RemoveParticipant 参与者离开时从 Redis 删除其所有字段（hash/text/match）
RemoveParticipant(ctx context.Context, sessionID, nickname string) error
// Get 获取会话当前状态全量快照
Get(ctx context.Context, sessionID string) (*SessionSnapshot, error)
server/internal/tools/dual_check/handler.go
+84 -37
View File
@@ -3,6 +3,7 @@ package dual_check
import (
"errors"
"net/http"
"strings"
"unicode/utf8"
pkgws "cancerai.top/toolbox-server/internal/pkg/websocket"
@@ -38,7 +39,11 @@ func (h *Handler) Create(c *gin.Context) {
response.BadRequest(c, ErrMessage(ErrCodeInvalidParam))
return
}
resp, err := h.service.CreateSession(c.Request.Context(), req.Nickname)
if err := validateNickname(req.Nickname); err != nil {
response.BadRequest(c, err.Error())
return
}
resp, err := h.service.CreateSession(c.Request.Context(), req.Nickname, req.BrowserID)
if err != nil {
var be *BusinessError
if errors.As(err, &be) {
@@ -64,6 +69,10 @@ func (h *Handler) Submit(c *gin.Context) {
response.BadRequest(c, ErrMessage(ErrCodeInvalidParam))
return
}
if err := validateNickname(req.Nickname); err != nil {
response.BadRequest(c, err.Error())
return
}
if utf8.RuneCountInString(req.Text) > h.maxLen {
response.BadRequest(c, "text too long")
return
@@ -82,37 +91,33 @@ func (h *Handler) Submit(c *gin.Context) {
return
}
// 广播事件到房间内所有连接（包括发起方和其他参与者）
// 广播事件到房间内所有连接
switch req.Role {
case "initiator":
// 发起方刚提交：触发全量快照推送（所有参与者都需要更新）
sess, _ := h.service.GetSession(c.Request.Context(), req.SessionID)
if sess != nil {
h.hub.Broadcast(req.SessionID, response.WSFullState(sess))
}
case "participant":
// 参与者刚提交：推送 participant_submitted 事件
// 发起方需要更新该参与者的提交状态 + 可能的 match 结果
h.hub.Broadcast(req.SessionID, response.WSParticipantSubmitted(req.Nickname, resp))
}
response.Success(c, resp)
}
// Join POST /api/v1/dual-check/join — 参与者加入（登记昵称）
// Join POST /api/v1/dual-check/join
func (h *Handler) Join(c *gin.Context) {
var req JoinRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, ErrMessage(ErrCodeInvalidParam))
return
}
sessionID := c.Param("session_id")
if sessionID == "" {
response.BadRequest(c, "session_id is required")
if err := validateNickname(req.Nickname); err != nil {
response.BadRequest(c, err.Error())
return
}
sess, err := h.service.JoinParticipant(c.Request.Context(), sessionID, req.Nickname)
sess, actualNick, err := h.service.JoinParticipant(c.Request.Context(), req.SessionID, req.Nickname, req.BrowserID)
if err != nil {
var be *BusinessError
if errors.As(err, &be) {
@@ -124,16 +129,27 @@ func (h *Handler) Join(c *gin.Context) {
return
}
// 广播 participant_joined 事件
h.hub.Broadcast(sessionID, response.WSParticipantJoined(req.Nickname))
h.hub.Broadcast(req.SessionID, response.WSParticipantJoined(actualNick))
if actualNick != req.Nickname {
response.Success(c, gin.H{
"session": sess,
"actual_nickname": actualNick,
"renamed": true,
})
return
}
response.Success(c, sess)
}
// GetSession GET /api/v1/dual-check/session/:session_id
// GetSession POST /api/v1/dual-check/session
func (h *Handler) GetSession(c *gin.Context) {
sessionID := c.Param("session_id")
sess, err := h.service.GetSession(c.Request.Context(), sessionID)
var req SessionRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, ErrMessage(ErrCodeInvalidParam))
return
}
sess, err := h.service.GetSession(c.Request.Context(), req.SessionID)
if err != nil {
var be *BusinessError
if errors.As(err, &be) && be.Code == ErrCodeSessionNotFound {
@@ -146,11 +162,14 @@ func (h *Handler) GetSession(c *gin.Context) {
response.Success(c, sess)
}
// CheckSession GET /api/v1/dual-check/check/:session_id
// 前端加入前预校验
// CheckSession POST /api/v1/dual-check/check
func (h *Handler) CheckSession(c *gin.Context) {
sessionID := c.Param("session_id")
info, err := h.service.CheckSession(c.Request.Context(), sessionID)
var req SessionRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, ErrMessage(ErrCodeInvalidParam))
return
}
info, err := h.service.CheckSession(c.Request.Context(), req.SessionID)
if err != nil {
response.InternalError(c, "check session failed")
return
@@ -162,21 +181,15 @@ func (h *Handler) CheckSession(c *gin.Context) {
response.Success(c, info)
}
// SetResubmit POST /api/v1/dual-check/session/:session_id/resubmit
// 发起方切换"允许参与者重新提交"开关
// SetResubmit POST /api/v1/dual-check/resubmit
func (h *Handler) SetResubmit(c *gin.Context) {
sessionID := c.Param("session_id")
if sessionID == "" {
response.BadRequest(c, "session_id is required")
return
}
var req SetResubmitRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, ErrMessage(ErrCodeInvalidParam))
return
}
sess, err := h.service.SetResubmit(c.Request.Context(), sessionID, req.Allow)
sess, err := h.service.SetResubmit(c.Request.Context(), req.SessionID, req.Allow)
if err != nil {
var be *BusinessError
if errors.As(err, &be) {
@@ -188,26 +201,49 @@ func (h *Handler) SetResubmit(c *gin.Context) {
return
}
// 广播开关变化给所有参与者
h.hub.Broadcast(sessionID, response.WSResubmitChanged(req.Allow))
h.hub.Broadcast(req.SessionID, response.WSResubmitChanged(req.Allow))
response.Success(c, sess)
}
// EndSession POST /api/v1/dual-check/session/:session_id/end
// 发起方主动结束会话：先广播 session_ended，再 Delete Redis key
// SetIgnoreWs POST /api/v1/dual-check/ignore-ws
func (h *Handler) SetIgnoreWs(c *gin.Context) {
var req SetIgnoreWsRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, ErrMessage(ErrCodeInvalidParam))
return
}
sess, err := h.service.SetIgnoreWs(c.Request.Context(), req.SessionID, req.Ignore)
if err != nil {
var be *BusinessError
if errors.As(err, &be) {
response.Fail(c, be.Code, be.Error())
return
}
h.logger.Error("set ignore_ws error", zap.Error(err))
response.InternalError(c, "set ignore_ws failed")
return
}
h.hub.Broadcast(req.SessionID, response.WSIgnoreWsChanged(req.Ignore))
response.Success(c, sess)
}
// EndSession POST /api/v1/dual-check/end
func (h *Handler) EndSession(c *gin.Context) {
sessionID := c.Param("session_id")
if sessionID == "" {
response.BadRequest(c, "session_id is required")
var req SessionRequest
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, ErrMessage(ErrCodeInvalidParam))
return
}
// 先广播，让所有参与方 UI 都弹提示
h.hub.Broadcast(sessionID, response.WSSessionEnded())
h.hub.Broadcast(req.SessionID, response.WSSessionEnded())
// 再删除数据
if err := h.service.EndSession(c.Request.Context(), sessionID); err != nil {
if err := h.service.EndSession(c.Request.Context(), req.SessionID); err != nil {
h.logger.Error("end session error", zap.Error(err))
response.InternalError(c, "end session failed")
return
@@ -216,5 +252,16 @@ func (h *Handler) EndSession(c *gin.Context) {
response.Success(c, gin.H{"ended": true})
}
// 占位，避免 http.StatusOK 未使用
// validateNickname 统一的昵称校验：字符数 1-32（按 Unicode rune）
func validateNickname(n string) error {
n = strings.TrimSpace(n)
if utf8.RuneCountInString(n) == 0 {
return errors.New("nickname is required")
}
if utf8.RuneCountInString(n) > 32 {
return errors.New("nickname must be 1-32 characters")
}
return nil
}
var _ = http.StatusOK
server/internal/tools/dual_check/model.go
+21 -4
View File
@@ -8,7 +8,8 @@ import "time"
// ── 创建会话 ──
type CreateRequest struct {
Nickname string `json:"nickname" binding:"required,min=1,max=32"`
Nickname string `json:"nickname" binding:"required,min=1"`
BrowserID string `json:"browser_id"`
}
// CreateResponse 创建成功
@@ -23,7 +24,7 @@ type CreateResponse struct {
type SubmitRequest struct {
SessionID string `json:"session_id" binding:"required,min=8,max=64"`
Nickname string `json:"nickname" binding:"required,min=1,max=32"`
Nickname string `json:"nickname" binding:"required,min=1"`
Role string `json:"role" binding:"required,oneof=initiator participant"`
Text string `json:"text" binding:"required"`
}
@@ -38,7 +39,9 @@ type SubmitResponse struct {
// ── 参与者加入 ──
type JoinRequest struct {
Nickname string `json:"nickname" binding:"required,min=1,max=32"`
SessionID string `json:"session_id" binding:"required,min=8,max=64"`
Nickname string `json:"nickname" binding:"required,min=1"`
BrowserID string `json:"browser_id"`
}
// JoinResponse 返回当前会话全量状态，供参与者初始化 UI
@@ -50,12 +53,18 @@ type JoinResponse struct {
// ── 会话全量状态（发起方拉取 / 发起方 WS 初始化） ──
// SessionRequest 统一的 session_id 请求体
type SessionRequest struct {
SessionID string `json:"session_id" binding:"required,min=8,max=64"`
}
// SessionResponse 发起方看到的会话状态（完整参与者列表）
type SessionResponse struct {
SessionID string `json:"session_id"`
InitiatorNickname string `json:"initiator_nickname"`
InitiatorReady bool `json:"initiator_ready"`
AllowResubmit bool `json:"allow_resubmit"`
IgnoreWs bool `json:"ignore_ws"`
Participants []ParticipantResp `json:"participants"`
TTLSeconds int64 `json:"ttl_seconds"`
}
@@ -74,6 +83,7 @@ type CheckResponse struct {
Exists bool `json:"exists"`
InitiatorReady bool `json:"initiator_ready"`
AllowResubmit bool `json:"allow_resubmit"`
IgnoreWs bool `json:"ignore_ws"`
ParticipantCount int `json:"participant_count"`
TTLSeconds int64 `json:"ttl_seconds"`
}
@@ -82,5 +92,12 @@ type CheckResponse struct {
// SetResubmitRequest 发起方切换"允许参与者重新提交"开关
type SetResubmitRequest struct {
Allow bool `json:"allow"`
SessionID string `json:"session_id" binding:"required,min=8,max=64"`
Allow bool `json:"allow"`
}
// SetIgnoreWsRequest 发起方切换"忽略首尾空白"开关
type SetIgnoreWsRequest struct {
SessionID string `json:"session_id" binding:"required,min=8,max=64"`
Ignore bool `json:"ignore"`
}
server/internal/tools/dual_check/routes.go
+9 -8
View File
@@ -25,14 +25,15 @@ func Register(
h := NewHandler(svc, hub, logger, maxTextLen)
ws := NewWSHandler(svc, hub, logger)
// REST API
group.POST("/create", h.Create) // 发起方创建会话
group.POST("/submit", h.Submit) // 发起方或参与者提交文本
group.POST("/session/:session_id/join", h.Join) // 参与者加入（登记昵称）
group.POST("/session/:session_id/resubmit", h.SetResubmit) // 发起方切换"允许重提交"开关
group.POST("/session/:session_id/end", h.EndSession) // 发起方主动结束会话
group.GET("/session/:session_id", h.GetSession) // 拉全量状态
group.GET("/check/:session_id", h.CheckSession) // 加入前预校验
// REST API — 所有 session_id 走 POST body
group.POST("/create", h.Create) // 发起方创建会话
group.POST("/submit", h.Submit) // 发起方或参与者提交文本
group.POST("/join", h.Join) // 参与者加入（登记昵称）
group.POST("/resubmit", h.SetResubmit) // 发起方切换"允许重提交"开关
group.POST("/ignore-ws", h.SetIgnoreWs) // 发起方切换"忽略首尾空白"开关
group.POST("/end", h.EndSession) // 发起方主动结束会话
group.POST("/session", h.GetSession) // 拉全量状态
group.POST("/check", h.CheckSession) // 加入前预校验
// WebSocket 实时推送（带 role + nickname 查询参数）
group.GET("/ws", ws.Handle)
server/internal/tools/dual_check/service.go
+223 -29
View File
@@ -2,9 +2,13 @@ package dual_check
import (
"context"
"crypto/rand"
"errors"
"fmt"
"math/big"
"strings"
"time"
"unicode/utf8"
"cancerai.top/toolbox-server/internal/pkg/hash"
"cancerai.top/toolbox-server/internal/pkg/sessionid"
@@ -32,13 +36,13 @@ func NewService(s store.SessionStore, logger *zap.Logger, ttl time.Duration) *Se
// ── Create ──
func (s *Service) CreateSession(ctx context.Context, nickname string) (*CreateResponse, error) {
func (s *Service) CreateSession(ctx context.Context, nickname, browserID string) (*CreateResponse, error) {
var sid string
var err error
for i := 0; i < 3; i++ {
sid, err = sessionid.Generate()
if err == nil {
err = s.store.Create(ctx, sid, s.ttl)
err = s.store.Create(ctx, sid, nickname, browserID, s.ttl)
if err == nil {
break
}
@@ -59,28 +63,43 @@ func (s *Service) CreateSession(ctx context.Context, nickname string) (*CreateRe
SessionID: sid,
Nickname: nickname,
ExpiresAt: expiresAt,
TTL: int(s.ttl.Seconds()),
// -1 表示"由发起方在线决定生命周期"，Redis TTL 只是兜底
TTL: -1,
}, nil
}
// ── Submit（发起方 or 参与方） ──
func (s *Service) Submit(ctx context.Context, req *SubmitRequest) (*SubmitResponse, error) {
hashHex := hash.SHA256(req.Text)
// 读 ignore_ws 设置，如果开启则 trim 首尾空白再 hash
ignoreWs, err := s.store.GetIgnoreWs(ctx, req.SessionID)
if err != nil {
if !errors.Is(err, store.ErrSessionNotFound) {
s.logger.Warn("GetIgnoreWs failed, defaulting to false", zap.Error(err))
}
ignoreWs = false
}
originalText := req.Text // 保存原始文本（trim 前），用于未来切换 ignore_ws 时重算
text := req.Text
if ignoreWs {
text = strings.TrimSpace(text)
}
hashHex := hash.SHA256(text)
req.Text = "" // 显式释放明文引用
switch req.Role {
case "initiator":
return s.submitInitiator(ctx, req.SessionID, req.Nickname, hashHex)
return s.submitInitiator(ctx, req.SessionID, req.Nickname, hashHex, originalText)
case "participant":
return s.submitParticipant(ctx, req.SessionID, req.Nickname, hashHex)
return s.submitParticipant(ctx, req.SessionID, req.Nickname, hashHex, originalText)
default:
return nil, &BusinessError{Code: ErrCodeInvalidRole}
}
}
func (s *Service) submitInitiator(ctx context.Context, sessionID, nickname, hashHex string) (*SubmitResponse, error) {
if err := s.store.SubmitInitiator(ctx, sessionID, nickname, hashHex); err != nil {
func (s *Service) submitInitiator(ctx context.Context, sessionID, nickname, hashHex, originalText string) (*SubmitResponse, error) {
if err := s.store.SubmitInitiator(ctx, sessionID, nickname, hashHex, originalText); err != nil {
if errors.Is(err, store.ErrSessionNotFound) {
return nil, ErrSessionNotFound
}
@@ -95,8 +114,8 @@ func (s *Service) submitInitiator(ctx context.Context, sessionID, nickname, hash
return &SubmitResponse{Submitted: true, InitiatorReady: true}, nil
}
func (s *Service) submitParticipant(ctx context.Context, sessionID, nickname, hashHex string) (*SubmitResponse, error) {
initReady, match, err := s.store.SubmitParticipant(ctx, sessionID, nickname, hashHex)
func (s *Service) submitParticipant(ctx context.Context, sessionID, nickname, hashHex, originalText string) (*SubmitResponse, error) {
initReady, match, err := s.store.SubmitParticipant(ctx, sessionID, nickname, hashHex, originalText)
if err != nil {
switch {
case errors.Is(err, store.ErrSessionNotFound):
@@ -126,28 +145,111 @@ func (s *Service) submitParticipant(ctx context.Context, sessionID, nickname, ha
// ── Join ──
func (s *Service) JoinParticipant(ctx context.Context, sessionID, nickname string) (*SessionResponse, error) {
// 检查昵称是否等于发起方昵称（不允许用发起方的昵称作为参与者）
// JoinParticipant 参与者加入会话，自动解决昵称冲突
// 返回 (sess, actualNick, err) — actualNick 是实际登记的昵称（可能是自动改名后的）
func (s *Service) JoinParticipant(ctx context.Context, sessionID, nickname, participantBrowserID string) (*SessionResponse, string, error) {
snap, err := s.store.Get(ctx, sessionID)
if err != nil {
if errors.Is(err, store.ErrSessionNotFound) {
return nil, ErrSessionNotFound
return nil, "", ErrSessionNotFound
}
return nil, err
}
if snap.InitiatorNickname != "" && snap.InitiatorNickname == nickname {
return nil, &BusinessError{Code: ErrCodeNicknameExists}
return nil, "", err
}
if err := s.store.JoinParticipant(ctx, sessionID, nickname); err != nil {
actualNick := nickname
// 检查冲突：发起方昵称 或 已有参与者昵称
// 但如果"冲突方"的 browserId 和参与者相同（同一个浏览器的不同 tab），视为同一个人不冲突
if isNicknameTaken(snap, nickname, participantBrowserID) {
actualNick = generateSafeNickname(nickname, snap, 5, participantBrowserID)
s.logger.Info("nickname auto-renamed on join",
zap.String("session_id", truncateSessionID(sessionID)),
zap.String("original", nickname),
zap.String("actual", actualNick),
zap.String("browser_id", participantBrowserID))
}
if err := s.store.JoinParticipant(ctx, sessionID, actualNick, participantBrowserID); err != nil {
if errors.Is(err, store.ErrSessionNotFound) {
return nil, ErrSessionNotFound
return nil, "", ErrSessionNotFound
}
return nil, err
return nil, "", err
}
// 返回加入后的最新状态
return s.GetSession(ctx, sessionID)
sess, err := s.GetSession(ctx, sessionID)
return sess, actualNick, err
}
// isNicknameTaken 检查昵称是否被发起方或已有参与者占用
// participantBrowserID：正在加入的人的 browserId——如果"冲突方"的 browserId 和他相同，视为同一个人，不冲突
func isNicknameTaken(snap *store.SessionSnapshot, nickname, participantBrowserID string) bool {
if snap.InitiatorNickname != "" && snap.InitiatorNickname == nickname {
// 发起方和参与者是同一个浏览器 → 同一个人 → 不冲突
if snap.InitiatorBrowserID != "" && snap.InitiatorBrowserID == participantBrowserID {
return false
}
return true
}
for _, p := range snap.Participants {
if p.Nickname == nickname {
// 已有参与者和新参与者是同一个浏览器 → 同一个人 → 不冲突
if p.BrowserID != "" && p.BrowserID == participantBrowserID {
return false
}
return true
}
}
return false
}
// generateSafeNickname 生成不冲突的新昵称：原名-XXX（XXX 是 3 位随机数字）
// 如果原名太长，截断后再加 -XXX，保证总长不超过 32 字符
func generateSafeNickname(original string, snap *store.SessionSnapshot, maxRetries int, participantBrowserID string) string {
const suffixLen = 4 // "-" + 3 digits
const maxRunes = 32
// 算 base（加上 suffix 后不超过 32 runes）
origRunes := utf8.RuneCountInString(original)
var base string
if origRunes+suffixLen <= maxRunes {
base = original
} else {
// 截断到 maxRunes - suffixLen 个 rune
runes := []rune(original)
base = string(runes[:maxRunes-suffixLen])
}
for i := 0; i < maxRetries; i++ {
suffix := randomDigits(3)
candidate := base + "-" + suffix
if !isNicknameTaken(snap, candidate, participantBrowserID) {
return candidate
}
}
// 极端情况还冲突，再多加一位
for i := 0; i < maxRetries; i++ {
suffix := randomDigits(4)
candidate := base + "-" + suffix
if !isNicknameTaken(snap, candidate, participantBrowserID) {
return candidate
}
}
return base + "-" + randomDigits(3) // 兜底
}
// randomDigits 返回 n 位随机数字字符串（crypto/rand 安全）
func randomDigits(n int) string {
const digits = "0123456789"
b := make([]byte, n)
for i := 0; i < n; i++ {
idx, err := rand.Int(rand.Reader, big.NewInt(10))
if err != nil {
// 兜底用伪随机
b[i] = digits[time.Now().UnixNano()%10]
} else {
b[i] = digits[idx.Int64()]
}
}
return string(b)
}
// ── GetSession 返回全量状态 ──
@@ -160,7 +262,6 @@ func (s *Service) GetSession(ctx context.Context, sessionID string) (*SessionRes
}
return nil, err
}
ttl := time.Until(snap.ExpiresAt)
parts := make([]ParticipantResp, 0, len(snap.Participants))
for _, p := range snap.Participants {
parts = append(parts, ParticipantResp{
@@ -175,8 +276,10 @@ func (s *Service) GetSession(ctx context.Context, sessionID string) (*SessionRes
InitiatorNickname: snap.InitiatorNickname,
InitiatorReady: snap.InitiatorSubmitted,
AllowResubmit: snap.AllowResubmit,
IgnoreWs: snap.IgnoreWs,
Participants: parts,
TTLSeconds: int64(ttl.Seconds()),
// -1 表示会话由发起方在线决定生命周期
TTLSeconds: -1,
}, nil
}
@@ -190,16 +293,14 @@ func (s *Service) CheckSession(ctx context.Context, sessionID string) (*CheckRes
}
return nil, err
}
ttl := time.Until(snap.ExpiresAt)
if ttl < 0 {
return &CheckResponse{Exists: false}, nil
}
return &CheckResponse{
Exists: true,
InitiatorReady: snap.InitiatorSubmitted,
AllowResubmit: snap.AllowResubmit,
IgnoreWs: snap.IgnoreWs,
ParticipantCount: len(snap.Participants),
TTLSeconds: int64(ttl.Seconds()),
// -1 表示会话由发起方在线决定生命周期
TTLSeconds: -1,
}, nil
}
@@ -221,6 +322,80 @@ func (s *Service) SetResubmit(ctx context.Context, sessionID string, allow bool)
return s.GetSession(ctx, sessionID)
}
func (s *Service) SetIgnoreWs(ctx context.Context, sessionID string, ignore bool) (*SessionResponse, error) {
if err := s.store.SetIgnoreWs(ctx, sessionID, ignore); err != nil {
if errors.Is(err, store.ErrSessionNotFound) {
return nil, ErrSessionNotFound
}
s.logger.Error("set ignore_ws failed", zap.Error(err),
zap.String("session_id", truncateSessionID(sessionID)))
return nil, fmt.Errorf("set ignore_ws: %w", err)
}
// 切换后按新规则重新计算所有已提交的 match
if err := s.store.RecalcMatches(ctx, sessionID, ignore); err != nil {
s.logger.Warn("recalc matches failed (non-fatal)", zap.Error(err),
zap.String("session_id", truncateSessionID(sessionID)))
}
s.logger.Info("ignore_ws changed",
zap.String("session_id", truncateSessionID(sessionID)),
zap.Bool("ignore", ignore),
)
return s.GetSession(ctx, sessionID)
}
// ── UpdateParticipantNickname 参与者修改自己的昵称 ──
func (s *Service) UpdateParticipantNickname(ctx context.Context, sessionID, oldNick, newNick string) error {
if oldNick == newNick {
return nil // 无变化
}
// 先查会话，拿到 oldNick 的 browserId（用于判断是否和冲突方是同一个浏览器）
snap, err := s.store.Get(ctx, sessionID)
if err != nil {
if errors.Is(err, store.ErrSessionNotFound) {
return ErrSessionNotFound
}
return err
}
// 找 oldNick 的 browserId
var oldBrowserID string
for _, p := range snap.Participants {
if p.Nickname == oldNick {
oldBrowserID = p.BrowserID
break
}
}
// 发起方昵称冲突检测（同浏览器跳过）
if snap.InitiatorNickname == newNick {
if snap.InitiatorBrowserID == "" || snap.InitiatorBrowserID != oldBrowserID {
return &BusinessError{Code: ErrCodeNicknameExists, Message: "该昵称已被发起方使用"}
}
}
err = s.store.UpdateParticipantNickname(ctx, sessionID, oldNick, newNick, oldBrowserID)
if err != nil {
switch {
case errors.Is(err, store.ErrSessionNotFound):
return ErrSessionNotFound
case errors.Is(err, store.ErrOldNotFound):
return &BusinessError{Code: ErrCodeNotInSession}
case errors.Is(err, store.ErrNicknameConflict):
return &BusinessError{Code: ErrCodeNicknameExists, Message: "该昵称已被其他参与者使用"}
default:
s.logger.Error("update participant nickname failed", zap.Error(err),
zap.String("session_id", truncateSessionID(sessionID)))
return fmt.Errorf("update nickname: %w", err)
}
}
s.logger.Info("participant renamed",
zap.String("session_id", truncateSessionID(sessionID)),
zap.String("old", oldNick),
zap.String("new", newNick),
)
return nil
}
// ── EndSession 发起方结束会话（删除 Redis key，WS 广播由 handler 完成） ──
func (s *Service) EndSession(ctx context.Context, sessionID string) error {
@@ -235,6 +410,25 @@ func (s *Service) EndSession(ctx context.Context, sessionID string) error {
return nil
}
// ── RemoveParticipant 参与者主动离开（从 Redis 删除其字段） ──
func (s *Service) RemoveParticipant(ctx context.Context, sessionID, nickname string) error {
err := s.store.RemoveParticipant(ctx, sessionID, nickname)
if err != nil {
if errors.Is(err, store.ErrSessionNotFound) {
return ErrSessionNotFound
}
s.logger.Warn("remove participant failed", zap.Error(err),
zap.String("session_id", truncateSessionID(sessionID)),
zap.String("nickname", nickname))
return err
}
s.logger.Info("participant removed",
zap.String("session_id", truncateSessionID(sessionID)),
zap.String("nickname", nickname))
return nil
}
func truncateSessionID(id string) string {
if len(id) > 8 {
return id[:8] + "..."
server/internal/tools/dual_check/ws_handler.go
+102 -11
View File
@@ -3,8 +3,11 @@ package dual_check
import (
"context"
"encoding/json"
"errors"
"fmt"
"net/http"
"strings"
"unicode/utf8"
pkgws "cancerai.top/toolbox-server/internal/pkg/websocket"
"cancerai.top/toolbox-server/internal/response"
@@ -35,6 +38,7 @@ func (h *WSHandler) Handle(c *gin.Context) {
sessionID := c.Query("session_id")
role := c.Query("role")
nickname := c.Query("nickname")
browserID := c.Query("browser_id")
if sessionID == "" {
c.JSON(http.StatusBadRequest, gin.H{"code": 4000, "message": "session_id required"})
@@ -44,7 +48,7 @@ func (h *WSHandler) Handle(c *gin.Context) {
c.JSON(http.StatusBadRequest, gin.H{"code": 1004, "message": "role must be initiator or participant"})
return
}
if nickname == "" || len(nickname) > 32 {
if nickname == "" || utf8.RuneCountInString(nickname) > 32 {
c.JSON(http.StatusBadRequest, gin.H{"code": 4000, "message": "nickname required (1-32)"})
return
}
@@ -71,11 +75,27 @@ func (h *WSHandler) Handle(c *gin.Context) {
}
h.hub.Register(wsConn)
// 参与者首次连接：自动登记昵称（幂等）
// 参与者首次连接：自动登记昵称（冲突时自动改名）
actualNick := nickname
if role == "participant" {
_, _ = h.service.JoinParticipant(c.Request.Context(), sessionID, nickname)
// 广播 participant_joined 给房间其他人
h.hub.Broadcast(sessionID, response.WSParticipantJoined(nickname))
_, actual, err := h.service.JoinParticipant(c.Request.Context(), sessionID, nickname, browserID)
if err == nil {
actualNick = actual
if actualNick != nickname {
// 自动改名：通知客户端 + 用 actualNick 广播
wsConn.Send <- marshalMsg(response.WSNicknameAutoChanged(actualNick))
h.logger.Info("ws participant auto-renamed",
zap.String("session_id", truncateSessionID(sessionID)),
zap.String("original", nickname),
zap.String("actual", actualNick))
}
h.hub.Broadcast(sessionID, response.WSParticipantJoined(actualNick))
} else {
h.logger.Warn("ws JoinParticipant failed",
zap.String("session_id", truncateSessionID(sessionID)),
zap.String("nickname", nickname),
zap.Error(err))
}
}
// 推一个 init 消息给新连接者，带上当前全量快照让它自己初始化 UI
@@ -91,10 +111,13 @@ func (h *WSHandler) Handle(c *gin.Context) {
go pkgws.WritePump(wsConn)
// ReadPump 里的 Unregister 会触发 participant_left 广播
go h.readLoop(wsConn, nickname)
go h.readLoop(wsConn, actualNick)
}
func (h *WSHandler) readLoop(c *pkgws.Conn, nickname string) {
func (h *WSHandler) readLoop(c *pkgws.Conn, initialNickname string) {
// currentNick 是可变的，rename 成功后更新，保证 defer 中的 participant_left 广播用最新昵称
currentNick := initialNickname
defer func() {
c.WS.Close() // 先关，让 WritePump 也能退
if c.Role == "initiator" {
@@ -107,19 +130,87 @@ func (h *WSHandler) readLoop(c *pkgws.Conn, nickname string) {
} else {
h.logger.Info("initiator disconnected, session ended",
zap.String("session_id", truncateSessionID(c.SessionID)),
zap.String("nickname", nickname))
zap.String("nickname", currentNick))
}
} else {
// 参与者断开：广播 participant_left
h.hub.Broadcast(c.SessionID, response.WSParticipantLeft(nickname))
// 参与者断开：先从 Redis 删除字段，再广播 participant_left
if err := h.service.RemoveParticipant(context.Background(), c.SessionID, currentNick); err != nil {
h.logger.Warn("participant RemoveParticipant err",
zap.String("session_id", truncateSessionID(c.SessionID)),
zap.String("nickname", currentNick),
zap.Error(err))
}
h.logger.Info("participant disconnected",
zap.String("session_id", truncateSessionID(c.SessionID)),
zap.String("nickname", currentNick))
h.hub.Broadcast(c.SessionID, response.WSParticipantLeft(currentNick))
}
c.Hub.Unregister(c) // 最后从房间移除
}()
c.WS.SetPongHandler(func(string) error { return nil })
for {
if _, _, err := c.WS.ReadMessage(); err != nil {
_, raw, err := c.WS.ReadMessage()
if err != nil {
return
}
// 解析客户端发来的消息
var msg struct {
Type string `json:"type"`
Data json.RawMessage `json:"data,omitempty"`
}
if err := json.Unmarshal(raw, &msg); err != nil {
continue // 不是合法 JSON，忽略
}
switch msg.Type {
case "rename":
// 只有参与者允许改昵称
if c.Role != "participant" {
h.sendError(c, "rename not allowed for role "+c.Role)
continue
}
var data struct {
NewNickname string `json:"new_nickname"`
}
if err := json.Unmarshal(msg.Data, &data); err != nil || strings.TrimSpace(data.NewNickname) == "" || utf8.RuneCountInString(data.NewNickname) > 32 {
h.sendError(c, "invalid new_nickname")
continue
}
newNick := strings.TrimSpace(data.NewNickname)
if newNick == currentNick {
continue // 无变化
}
err := h.service.UpdateParticipantNickname(context.Background(), c.SessionID, currentNick, newNick)
if err != nil {
var be *BusinessError
if errors.As(err, &be) {
h.sendError(c, be.Error()) // 优先用自定义 Message，否则回退到 ErrMessage(code)
} else {
h.sendError(c, "rename failed: "+err.Error())
}
continue
}
// 成功：更新本地昵称 + 广播给房间其他人
oldNick := currentNick
currentNick = newNick
h.hub.Broadcast(c.SessionID, response.WSParticipantRenamed(oldNick, newNick))
h.logger.Info("ws rename success",
zap.String("session_id", truncateSessionID(c.SessionID)),
zap.String("old", oldNick),
zap.String("new", newNick),
)
}
}
}
// sendError 通过 WS 给客户端发送一个 error 消息
func (h *WSHandler) sendError(c *pkgws.Conn, errMsg string) {
msg := response.WebSocketMessage{Type: "error", Error: errMsg}
select {
case c.Send <- marshalMsg(msg):
default:
}
}