Files
go-sms-V2/internal/service/access/longsms.go
T

318 lines
12 KiB
Go

// longsms.go 入向长短信聚合(批次 2278141/2278142 修复,决策②A/③;Day 71 挂起制):
// 客户端按 CMPP 标准将超 134B 内容拆多片提交(6B 拼接 UDH:ref/total/idx,
// 与出向 split.go 同构;UCS2 客户端片首「05 00 03 02 02 01/02」即实例字节)。
//
// 聚合语义(组键=账号|srcID|手机号|ref):
// - 每片立即回 Submit_Resp(result=0);msg_id=组ID(首片预生成雪花,N 片
// 复用——决策③),到齐合并受理时注入为首条 DetailID,回执按整条推 1 条;
// - 到齐:按序拼接全文单次受理(1 task+1 detail,content 全文无乱码,
// fee=FeeSegments=pk_total=运营商计费依据——Day 70 计费口径);
// - 未齐(挂起窗默认 72h,Day 71):不提交上家通道、不返回终态状态、不扣费;
// 挂起组持久化 longsms_pending(首片 INSERT/续片 UPDATE/到齐 DELETE),
// 进程重启 restore 回内存继续等片——窗内补齐仍可正常受理;
// - 满 72h 仍不齐:扫描器(longsms_reaper)建失败终态(task LP+组ID/detail
// id=组ID status=3 fee=0)+UNDELIV 回执给下家在线连接——「不齐不发,
// 到期失败」制(原 10s 超时退化直发语义废除,决策反转:完整性优先);
// - 挂起组 DB 双写失败:Warn 降级继续内存聚合(主功能不受 DB 故障影响,
// 极端场景重启丢组=片已回 OK 无回执,与 Day63 快路径同风险模型)。
package access
import (
"context"
"encoding/json"
"strconv"
"strings"
"sync"
"time"
"go-sms/internal/pkg/metrics"
"go-sms/internal/model/entity"
"go-sms/internal/pkg/logger"
"go-sms/internal/protocol/cmpp"
"go-sms/internal/service/openapi"
"go-sms/internal/service/send"
"go.uber.org/zap"
"gorm.io/gorm"
)
const (
// longSmsWindow 挂起窗默认值(Day 71:10s→72h,不齐不发到期失败;config
// server.cmpp.longsms_window 可配;测试直接调 grouper.window)。
longSmsWindow = 72 * time.Hour
// longSmsMaxGroup 并发挂起组上限(Day 71:4096→16384——72h 窗下超时组
// 驻留 3 天,压测超时率 32% 一天残留 ~1500 组;超限新组拒绝 SubmitRejected,
// 客户端重试;防伪造 ref 碰撞 DoS 占内存)。
longSmsMaxGroup = 16384
// longSmsIncompleteCode 挂起组到期失败错误码(size:16 内)。
longSmsIncompleteCode = "LSM:NOTCMPL"
)
// longSmsAPI 聚合器出口(*openapi.Service 天然实现;测试注入桩)。
type longSmsAPI interface {
NextMsgID() int64
SendMassFast(ctx context.Context, auth *openapi.AuthContext,
req *openapi.MassReq, clientIP string) *openapi.Resp
}
// pendingLong 一封待聚合长短信。
type pendingLong struct {
groupID uint64 // 首片预生成雪花;N 片 Resp 复用;合并后=首条 DetailID
auth *openapi.AuthContext // 首片账号快照(窗内账号变更以首片为准;restore 重建)
srcID string
mobile string
extCode string
total uint8
ref uint8 // 组键 ref(Day 71:持久化 restore 组键还原)
ucs2 bool // Day 70:首片 MsgFmt 编码快照(与 auth 快照同理,计费口径)
frags map[uint8]string // idx→剥头解码文本(CMPP 拆分按完整字符切,文本直拼安全)
}
// longSmsGrouper 长短信聚合器(并发安全;内存+longsms_pending 双写)。
type longSmsGrouper struct {
mu sync.Mutex
groups map[string]*pendingLong
window time.Duration // 挂起窗(默认 longSmsWindow;测试可调)
maxGroup int // 并发挂起组上限(默认 longSmsMaxGroup;测试可调)
db *gorm.DB // Day 71:挂起组持久化(nil=纯内存测试口径,零 DB)
}
func newLongSmsGrouper(db *gorm.DB) *longSmsGrouper {
return &longSmsGrouper{groups: make(map[string]*pendingLong),
window: longSmsWindow, maxGroup: longSmsMaxGroup, db: db}
}
// longSmsKey 组键(账号|srcID|手机号|ref;submitFragment 与 restore/reaper 共用)。
func longSmsKey(accountID int64, srcID, mobile string, ref uint8) string {
return strconv.FormatInt(accountID, 10) + "|" + srcID + "|" + mobile + "|" +
strconv.FormatUint(uint64(ref), 10)
}
// submitFragment 片提交:入组缓存(未齐回组ID 不发)/到齐合并单次受理。
// precheck(账号+通道号前缀)已由调用方 Submit 完成,cfg 为验过快照。
func (g *longSmsGrouper) submitFragment(api longSmsAPI, cfg *entity.AccountConfig,
sourceAddr, srcID, mobile, content string, udh *cmpp.UDHInfo, ucs2 bool) (uint64, byte) {
auth := &openapi.AuthContext{
AccountID: cfg.AccountID, Username: sourceAddr, Config: cfg,
Source: send.TaskSourceCMPP, // Day 60:受理来源打标(CMPP 接入)
}
ext := strings.TrimPrefix(srcID, cfg.ExtCode)
key := longSmsKey(cfg.AccountID, srcID, mobile, udh.Ref)
isNew := false
fragsJSON := "{}"
g.mu.Lock()
grp, ok := g.groups[key]
if ok && grp.total != udh.Total {
// 同组 ref 复用冲突(协议异常):本片退化直发,原组不受影响继续等齐。
g.mu.Unlock()
metrics.LongSmsDegradeTotal.WithLabelValues("ref_conflict").Inc()
logger.L().Warn("cmpp_longsms_total_conflict",
zap.String("source_addr", sourceAddr), zap.String("mobile", mobile),
zap.Uint8("ref", udh.Ref), zap.Uint8("group_total", grp.total),
zap.Uint8("frag_total", udh.Total))
return directSubmit(api, auth, mobile, ext, content, ucs2)
}
if !ok {
if len(g.groups) >= g.maxGroup {
// Day 71:超限新组拒绝(原退化直发废除——72h 挂起制下上限是 DoS
// 防线,拒绝+客户端重试优于无限挂起)。
g.mu.Unlock()
metrics.LongSmsDegradeTotal.WithLabelValues("overflow").Inc()
logger.L().Warn("cmpp_longsms_group_overflow_reject",
zap.String("source_addr", sourceAddr), zap.String("mobile", mobile),
zap.Int("groups", len(g.groups)))
return 0, cmpp.SubmitRejected
}
grp = &pendingLong{
groupID: uint64(api.NextMsgID()),
auth: auth, srcID: srcID, mobile: mobile, extCode: ext,
total: udh.Total, ref: udh.Ref, ucs2: ucs2, frags: make(map[uint8]string),
}
g.groups[key] = grp
isNew = true
}
if _, dup := grp.frags[udh.Idx]; dup {
metrics.LongSmsDupFragTotal.Inc() // 同 idx 重复片(客户端重发)覆盖,幂等
}
grp.frags[udh.Idx] = content
merged := len(grp.frags) >= int(grp.total)
if merged {
delete(g.groups, key) // 与 reaper 到期处理互斥:后到片走新组
}
fragsJSON = marshalFrags(grp.frags) // 持锁序列化(map 无并发写)
g.mu.Unlock()
// 挂起组持久化(锁外;失败 Warn 降级继续内存聚合)。
if g.db != nil {
if isNew {
g.persistInsert(grp, fragsJSON)
} else if !merged {
g.persistUpdate(grp.groupID, fragsJSON)
} else {
g.persistDelete(grp.groupID)
}
}
if !merged {
return grp.groupID, cmpp.SubmitOK // 未齐:仅受理确认,内容不发
}
// 到齐:按序拼接全文单次受理(组ID 注入=首条 DetailID;fee=全文段数=上游片数)。
var full strings.Builder
for i := uint8(1); i <= grp.total; i++ {
full.WriteString(grp.frags[i])
}
metrics.LongSmsMergedTotal.Inc()
logger.L().Info("cmpp_longsms_merged",
zap.Uint64("group_id", grp.groupID), zap.Int("frags", int(grp.total)),
zap.Int("chars", len([]rune(full.String()))), zap.String("mobile", grp.mobile))
resp := api.SendMassFast(context.Background(), grp.auth, &openapi.MassReq{
PhoneList: []string{grp.mobile},
Content: full.String(),
SignName: "", // CMPP 内容自带【签名】,与 submitDirect 同口径
ExtCode: grp.extCode,
PresetMsgID: int64(grp.groupID),
// Day 70:计费段数=客户端 pk_total=运营商计费依据(与编码无关,
// 比任何口径重算都准);ContentEncoding 同步标注(冗余兜底)。
FeeSegments: int(grp.total),
ContentEncoding: ucs2Encoding(grp.ucs2),
}, remoteIPPlaceholder)
if resp.Code != openapi.CodeOK {
logger.L().Warn("cmpp_submit_rejected",
zap.String("source_addr", grp.auth.Username), zap.Int("code", resp.Code),
zap.String("message", resp.Message), zap.Uint64("group_id", grp.groupID))
return grp.groupID, cmpp.SubmitRejected
}
return grp.groupID, cmpp.SubmitOK
}
// ---- 挂起组持久化(Day 71) ----
// marshalFrags frags map→JSON(持锁调用)。
func marshalFrags(frags map[uint8]string) string {
if len(frags) == 0 {
return "{}"
}
b, err := json.Marshal(frags)
if err != nil { // map[uint8]string 不可能失败;防御
return "{}"
}
return string(b)
}
// unmarshalFrags JSON→frags map(restore/reaper 用;坏行=空组)。
func unmarshalFrags(s string) map[uint8]string {
m := make(map[uint8]string)
if s != "" {
_ = json.Unmarshal([]byte(s), &m)
}
return m
}
// persistInsert 新组落库(expire_at=created+window)。
func (g *longSmsGrouper) persistInsert(grp *pendingLong, fragsJSON string) {
row := &entity.LongSmsPending{
GroupID: grp.groupID, AccountID: grp.auth.AccountID, Username: grp.auth.Username,
SrcID: grp.srcID, Mobile: grp.mobile, ExtCode: grp.extCode,
Ref: grp.ref, Total: grp.total, Ucs2: grp.ucs2, Frags: fragsJSON,
ExpireAt: time.Now().Add(g.window),
}
if err := g.db.Create(row).Error; err != nil {
logger.L().Warn("cmpp_longsms_persist_insert_failed",
zap.Uint64("group_id", grp.groupID), zap.Error(err))
}
}
// persistUpdate 续片全量替换(同组片串行到达,无并发写冲突)。
func (g *longSmsGrouper) persistUpdate(groupID uint64, fragsJSON string) {
if err := g.db.Model(&entity.LongSmsPending{}).Where("group_id = ?", groupID).
Update("frags", fragsJSON).Error; err != nil {
logger.L().Warn("cmpp_longsms_persist_update_failed",
zap.Uint64("group_id", groupID), zap.Error(err))
}
}
// persistDelete 到齐/终态后删行(g.db nil 安全)。
func (g *longSmsGrouper) persistDelete(groupID uint64) {
if g.db == nil {
return
}
if err := g.db.Where("group_id = ?", groupID).
Delete(&entity.LongSmsPending{}).Error; err != nil {
logger.L().Warn("cmpp_longsms_persist_delete_failed",
zap.Uint64("group_id", groupID), zap.Error(err))
}
}
// removeGroupByKey reaper 到期处理前取走内存组(与到齐路径同互斥域;
// 后到片见不到组→按新组处理,组死亡事实由 DB 行快照决定)。
func (g *longSmsGrouper) removeGroupByKey(key string) {
g.mu.Lock()
delete(g.groups, key)
g.mu.Unlock()
}
// restore 进程重启:挂起组回内存继续等片(72h 内补齐仍可正常受理)。
// auth 重建失败(账号删除/停用)的组不恢复——留 DB 行由 reaper 到期失败终态;
// 片若再来将开新组(同 ref 键,新雪花组ID)。返回恢复组数。
func (g *longSmsGrouper) restore(
loadAuth func(username string, accountID int64) *openapi.AuthContext) int {
if g.db == nil {
return 0
}
var rows []entity.LongSmsPending
if err := g.db.Where("expire_at > ?", time.Now()).Find(&rows).Error; err != nil {
logger.L().Warn("cmpp_longsms_restore_load_failed", zap.Error(err))
return 0
}
n := 0
for _, r := range rows {
auth := loadAuth(r.Username, r.AccountID)
if auth == nil || auth.Config == nil {
continue // 账号已失效:等 reaper 到期失败终态
}
key := longSmsKey(r.AccountID, r.SrcID, r.Mobile, r.Ref)
g.mu.Lock()
if _, ok := g.groups[key]; !ok { // 防重复 restore
g.groups[key] = &pendingLong{
groupID: r.GroupID, auth: auth, srcID: r.SrcID, mobile: r.Mobile,
extCode: r.ExtCode, total: r.Total, ucs2: r.Ucs2,
frags: unmarshalFrags(r.Frags),
}
n++
}
g.mu.Unlock()
}
return n
}
// ucs2Encoding bool→计费口径编码(send.ContentEncoding*,Day 70)。
func ucs2Encoding(ucs2 bool) int8 {
if ucs2 {
return send.ContentEncodingUCS2
}
return send.ContentEncodingDefault
}
// directSubmit 单片独立受理(ref 冲突异常片直发;账号已 precheck)。
// RegisteredDelivery 与 submitDirect 同口径:回执由 Day61 push 链按明细
// 驱动,受理参数不传递。返回值仅异常片直发路径用到。
func directSubmit(api longSmsAPI, auth *openapi.AuthContext,
mobile, ext, content string, ucs2 bool) (uint64, byte) {
resp := api.SendMassFast(context.Background(), auth, &openapi.MassReq{
PhoneList: []string{mobile},
Content: content,
SignName: "", // CMPP 内容自带【签名】,与 submitDirect 同口径
ExtCode: ext,
// Day 70:按提交编码分流计费口径(fee≡上游真实片数)。
ContentEncoding: ucs2Encoding(ucs2),
}, remoteIPPlaceholder)
if resp.Code != openapi.CodeOK {
logger.L().Warn("cmpp_submit_rejected",
zap.String("source_addr", auth.Username), zap.Int("code", resp.Code),
zap.String("message", resp.Message))
return 0, cmpp.SubmitRejected
}
return uint64(resp.MsgID), cmpp.SubmitOK
}