320 lines
12 KiB
Go
320 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 为验过快照;
|
|
// ext=生效校验前缀(账号 ext_code 或系统默认,Issue#3 方案B)——扩展码
|
|
// 剥离口径与直发一致(TrimPrefix(srcID, ext))。
|
|
func (g *longSmsGrouper) submitFragment(api longSmsAPI, cfg *entity.AccountConfig,
|
|
ext, 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 接入)
|
|
}
|
|
extCode := strings.TrimPrefix(srcID, ext)
|
|
key := longSmsKey(cfg.AccountID, srcID, mobile, udh.Ref)
|
|
|
|
isNew := false
|
|
var fragsJSON string
|
|
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, extCode, 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: extCode,
|
|
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
|
|
}
|