Files
go-sms-V2/internal/service/send/submit/submit.go
T

494 lines
19 KiB
Go

package submit
import (
"context"
"crypto/rand"
"fmt"
"math/big"
"strings"
"time"
"go-sms/internal/model/entity"
"go-sms/internal/pkg/errors"
"go-sms/internal/service/balance"
"go-sms/internal/service/interceptor"
"go-sms/internal/util"
"gorm.io/gorm"
)
// TaskRouter 审核分流接口(audit.ReviewService 实现;依赖倒置避免 send→audit 包依赖)。
// nil 时不分流,任务停留待审(由 48h 超时扫描兜底)。
type TaskRouter interface {
Route(ctx context.Context, taskID int64) (*entity.MessageTask, *entity.AuditRecord, error)
}
// SubmitService 发送提交服务(Day 43 修复循环起步,Day 48 升级全流程状态机)。
// 链路:校验→预扣→落库→拦截(退费)→审核分流(拒绝退费)→Kafka 事件;
// 路由与下发移交 submit 消费者(同步链路 MySQL 禁令,技术方案 10.4.3)。
type SubmitService struct {
db *gorm.DB
sf *util.Snowflake
rt TaskRouter
chain *interceptor.Chain // Day 48:受理期拦截(nil=跳过,兼容测试)
sink EventSink // Day 48:sms-submit 统一出口(nil=不投)
bal balance.Store // Day 54 R1:资金预扣/退款(mysql 行锁|redis Lua)
}
// NewSubmitService 构造(rt 可 nil:single-test/未装配审核时分流跳过;
// opts 按 Day48 链路注入拦截链/事件出口,Day54 R1 注入资金 Store)。
func NewSubmitService(db *gorm.DB, sf *util.Snowflake, rt TaskRouter, opts ...SubmitOption) *SubmitService {
s := &SubmitService{db: db, sf: sf, rt: rt}
for _, opt := range opts {
opt(s)
}
if s.bal == nil { // 未注入退化为 MySQL 原路径(既有测试/降级装配零破坏)
s.bal = balance.NewMySQLStore(db)
}
return s
}
// SubmitResult 提交结果(任务+分流后审核态+预估)。
type SubmitResult struct {
Task *entity.MessageTask
Record *entity.AuditRecord // 自动档留痕(其余 nil)
Estimate *Estimate
}
// Submit 受理发送任务(Day 48 全流程状态机):
// ①Validate ②余额快检 ③holdFee 原子预扣(不足→ISC:007;扣后失败环节全对冲)
// ④事务{task+明细(拦截号直接终态 5)}(失败→Refund 全额)
// ⑤拦截费即时退(RefundTask blockedFee) ⑥Route 审核(拒绝→退剩余)
// ⑦EmitSubmit(有存活号才投;0 号存活=全拦终态)。
// taskNo 幂等:请求带则用(uk 冲突→ISC:400),缺省生成 T+时间戳+随机。
func (s *SubmitService) Submit(ctx context.Context, req *SubmitReq, tpl *entity.TemplateSMS,
content string, clientIP string) (*SubmitResult, error) {
est, err := req.Validate(tpl)
if err != nil {
return nil, err
}
// 定时时刻(Validate 已保证 type3 非空;格式与 reschedule 同口径)。
var scheduleAt *time.Time
if req.SendType == SendTypeTimer {
at, perr := time.ParseInLocation("2006-01-02 15:04", req.SendAt, time.Local)
if perr != nil {
return nil, errors.InvalidParam.WithMsg("send_at 格式须为 YYYY-MM-DD HH:mm")
}
if !at.After(time.Now()) {
return nil, errors.InvalidParam.WithMsg("定时时刻须在未来")
}
scheduleAt = &at
}
// ②余额只读快检(快速失败体验;并发竞态由 ③原子预扣兜底精确拒绝)。
var acct entity.AccountUser
if err := s.db.WithContext(ctx).Select("id", "balance").
First(&acct, req.AccountID).Error; err != nil {
return nil, errors.NotFound.WithMsg("账号不存在")
}
if acct.Balance < int64(est.TotalFee) {
return nil, errors.Arrears.WithMsg(
fmt.Sprintf("余额不足:当前 %d 条,本次需 %d 条", acct.Balance, est.TotalFee))
}
// Day 49:video 须账号已开通(AccountConfig 业务行,openapi 鉴权同口径);
// 未开通拒绝发生在预扣前,无需退款对冲。
if req.Business == BusinessVideo {
var n int64
if err := s.db.WithContext(ctx).Model(&entity.AccountConfig{}).
Where("account_id = ? AND business = ?", req.AccountID, BusinessVideo).
Count(&n).Error; err != nil {
return nil, err
}
if n == 0 {
return nil, errors.Forbidden.WithMsg("账号未开通视频短信业务")
}
}
// 幂等任务号。
taskNo := strings.TrimSpace(req.TaskNo)
if taskNo == "" {
taskNo = genTaskNo()
}
// ③原子预扣(WHERE balance>=fee;Day48 状态机起点——此后失败环节必有退款)。
if err := s.holdFee(ctx, req.AccountID, int64(est.TotalFee), taskNo); err != nil {
return nil, err
}
task := entity.MessageTask{
TaskNo: taskNo, AccountID: req.AccountID,
SendType: req.SendType, Content: content, Sign: req.Sign,
MobileCount: est.ValidCount, FeeTotal: float64(est.TotalFee),
AuditStatus: 0, Status: 0, ScheduleAt: scheduleAt, SubmitIP: clientIP,
CallData: util.Truncate(req.CallData, 64), // Day 46:回执回传数据(截断防溢出)
Business: req.Business, // Day 49:sms/video(Validate 已规范化)
Source: NormalizeTaskSource(req.Source), // Day 60:受理来源(WEB=4/CMPP=2/SMPP=3/API=1)
}
// ⑤拦截预判定(内存;落库时拦截号直接终态 5,存活号才进下发域)。
mobiles := validMobiles(req)
blocks := make([]*interceptor.Block, len(mobiles))
blockedFee, passCount := 0, 0
// Day51 R3:请求级快照——白名单/黑名单批量 IN+策略/签名跨号复用(100 号 400 查→≤3 查)。
sc := s.chain.NewScope(ctx, req.AccountID, mobiles)
for i, m := range mobiles {
if b := s.intercept(ctx, taskNo, req.AccountID, req.SendType, m, content, sc); b != nil {
blocks[i] = b
blockedFee += est.Segments
continue
}
passCount++
}
details := make([]entity.MessageDetail, 0, est.ValidCount)
for i, m := range mobiles {
d := entity.MessageDetail{
TaskID: 0, AccountID: req.AccountID,
Mobile: m, Content: content, Status: 0, Fee: float64(est.Segments),
ExtCode: util.Truncate(req.Extend, 32), // Day 46:扩展码透传
CallData: util.Truncate(req.CallData, 64),
Business: req.Business, Source: NormalizeTaskSource(req.Source), // Day66:明细单表化冗余
}
if blocks[i] != nil { // 拦截号:受理期即终态(ISC 码 16 字符截断)
d.Status = 5
d.ErrorCode = util.Truncate(blocks[i].Code, 16)
}
d.ID = s.sf.NextID() // 雪花主键(嵌入结构体,赋值式填入)
details = append(details, d)
}
err = s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
if err := tx.Create(&task).Error; err != nil {
msg := strings.ToUpper(err.Error())
if strings.Contains(msg, "DUPLICATE") || strings.Contains(msg, "1062") || // MySQL
strings.Contains(msg, "UNIQUE CONSTRAINT") { // SQLite
return errors.InvalidParam.WithMsg("任务号已存在: " + taskNo)
}
return err
}
return nil // Day52 R2:入口事务仅落 task(同步链路零明细写,方案 10.4.3)
})
if err != nil {
// ④落库失败:预扣全额对冲(状态机不变量——受理失败余额零损)。
_ = s.refund(ctx, req.AccountID, int64(est.TotalFee), taskNo, "落库失败退回")
return nil, err
}
for i := range details { // 事件/降级路径共用:TaskID 事务后回填(消费侧落库亦用)
details[i].TaskID = task.ID
}
// ⑤拦截号费用即时退(预扣按全额,被拦号未消费;RefundTask 幂等由一次性调用保证)。
if blockedFee > 0 {
_ = s.refund(ctx, req.AccountID, int64(blockedFee), taskNo, "拦截号码退费")
}
// Day52 R2:明细随 sms-submit 投递(全拦/定时亦投——拦截记录与定时明细同为对账事实源;
// 消费侧 claim 不认领全拦终态 2/待审 audit=0/定时域 send_type=3,仅落明细即返回)。
s.emitOrFallback(ctx, &task, details)
// 全拦:任务直接终态(事件已投,拦截明细由消费侧落库;计数=fail)。
if passCount == 0 {
_ = s.db.WithContext(ctx).Model(&entity.MessageTask{}).
Where("id = ? AND status = ?", task.ID, 0).
Updates(map[string]any{
"status": TaskStDone, "fail_count": len(mobiles), "finished_at": time.Now(),
}).Error
task.Status = TaskStDone
task.FailCount = len(mobiles)
return &SubmitResult{Task: &task, Estimate: est}, nil
}
// 审核分流(事务外;三模式落定。失败不回滚受理——任务停留待审,48h Scanner 兜底)。
var rec *entity.AuditRecord
if s.rt != nil {
t2, r2, rerr := s.rt.Route(ctx, task.ID)
if rerr != nil {
return nil, fmt.Errorf("任务已受理(任务号 %s)但审核分流失败: %w", taskNo, rerr)
}
task, rec = *t2, r2
// ⑥审核拒绝:存活号费用全退(拦截费 ⑤ 已退;幂等由 Route 原子翻转保证只进一次)。
if task.AuditStatus == 2 {
_ = s.refund(ctx, req.AccountID,
int64(est.TotalFee)-int64(blockedFee), taskNo, "审核拒绝退费")
}
}
return &SubmitResult{Task: &task, Record: rec, Estimate: est}, nil
}
// NextMsgID 预生成雪花 MsgID(入向长短信聚合组ID;与 DetailID 同源空间,
// 供接入层首片分配、N 片 Resp 复用、合并受理时注入为首条 DetailID)。
func (s *SubmitService) NextMsgID() int64 { return s.sf.NextID() }
// FastResult 快路径受理结果(P0-1)。
type FastResult struct {
MsgID int64 // =首条 DetailID 雪花(CMPP Submit_Resp 与 Deliver msg_id 同口径)
TaskNo string // 幂等任务号(对账/退费键)
}
// SubmitFast P0-1(Day 63)接入快路径:CMPP 高并发压测 80 并发封顶 ~45/s
// (fsync 调优后),根因=同步链 5-8 次 DB 往返。快路径只做四件事:
// ①Validate(内存) ②holdFee 原子预扣(Redis Lua ~1ms;欠费快速失败+防透支)
// ③DetailID 雪花预生成 ④EmitSubmit(Deferred 事件,task.ID=0);
// 拦截判定/任务落库/退费/审核分流全部移消费侧 handleDeferred 补全——
// 平台=中间削峰缓存,受理速率与下发速率解耦(上下游流速不对齐是常态)。
// 零 DB 读写;sink 未装配或投递失败→全额退费+返回错误(客户端重试,不丢)。
func (s *SubmitService) SubmitFast(ctx context.Context, req *SubmitReq,
content string, clientIP string) (*FastResult, error) {
est, err := req.Validate(nil)
if err != nil {
return nil, err
}
// 定时校验(与 Submit 同口径;CMPP 无定时,HTTP 走老路径,防御性保留)。
var scheduleAt *time.Time
if req.SendType == SendTypeTimer {
at, perr := time.ParseInLocation("2006-01-02 15:04", req.SendAt, time.Local)
if perr != nil {
return nil, errors.InvalidParam.WithMsg("send_at 格式须为 YYYY-MM-DD HH:mm")
}
if !at.After(time.Now()) {
return nil, errors.InvalidParam.WithMsg("定时时刻须在未来")
}
scheduleAt = &at
}
taskNo := strings.TrimSpace(req.TaskNo)
if taskNo == "" {
taskNo = genTaskNo()
}
// 原子预扣(Redis 优先;不足→ISC:007 同步拒绝——欠费是受理侧唯一同步拒绝语义)。
tHold := time.Now()
holdErr := s.holdFee(ctx, req.AccountID, int64(est.TotalFee), taskNo)
holdCost := time.Since(tHold)
if holdErr != nil {
return nil, holdErr
}
task := entity.MessageTask{ // ID=0:自增主键由消费侧 handleDeferred 生成。
TaskNo: taskNo, AccountID: req.AccountID,
SendType: req.SendType, Content: content, Sign: req.Sign,
MobileCount: est.ValidCount, FeeTotal: float64(est.TotalFee),
AuditStatus: 0, Status: 0, ScheduleAt: scheduleAt, SubmitIP: clientIP,
CallData: util.Truncate(req.CallData, 64),
Business: req.Business, Source: NormalizeTaskSource(req.Source),
}
mobiles := validMobiles(req)
details := make([]entity.MessageDetail, 0, len(mobiles))
for i, m := range mobiles {
d := entity.MessageDetail{
AccountID: req.AccountID, Mobile: m, Content: content,
Status: 0, Fee: float64(est.Segments), // 未拦截判定:消费侧 Check 后终态化
ExtCode: util.Truncate(req.Extend, 32), CallData: util.Truncate(req.CallData, 64),
Business: req.Business, Source: NormalizeTaskSource(req.Source), // Day66:明细单表化冗余
}
d.ID = s.sf.NextID()
if i == 0 && req.PresetMsgID != 0 { // 长短信聚合组ID 注入:Resp/Deliver/明细三口径同 ID
d.ID = req.PresetMsgID
}
details = append(details, d)
}
if len(details) == 0 { // 合格号为 0:预扣按 0 条(Validate 已拒空号列表,防御)。
return &FastResult{MsgID: 0, TaskNo: taskNo}, nil
}
// 投递(Deferred 事件);快路径无 DB 降级路径——失败退全款+拒绝(客户端重试)。
tEmit := time.Now()
var emitErr error
if s.sink == nil {
emitErr = errors.InternalError.WithMsg("事件出口未装配")
} else {
emitErr = s.sink.EmitSubmit(ctx, &task, details)
}
if emitCost := time.Since(tEmit); emitCost > 80*time.Millisecond {
WarnSubmitFastSlow(emitCost, holdCost) // P0-1 诊断(临时)
}
if emitErr != nil {
_ = s.refund(ctx, req.AccountID, int64(est.TotalFee), taskNo, "快路径投递失败退回")
return nil, emitErr
}
return &FastResult{MsgID: details[0].ID, TaskNo: taskNo}, nil
}
// emitOrFallback 投递明细事件(Day52 R2);sink 未装配或投递失败降级同步落明细
// (明细=对账事实源,零丢失红线;任务下发由 ReclaimScanner/Timer 扫描兜底认领)。
func (s *SubmitService) emitOrFallback(ctx context.Context, task *entity.MessageTask,
details []entity.MessageDetail) {
if len(details) == 0 {
return
}
if s.sink != nil {
if err := s.sink.EmitSubmit(ctx, task, details); err == nil {
return
}
// Kafka 故障窗口:降级回同步落库旧路径(性能让位于正确性)。
}
_ = s.db.WithContext(ctx).CreateInBatches(details, 500).Error
}
// validMobiles 归一去重后的合格号码(与 Validate 同规则,供明细落库)。
func validMobiles(r *SubmitReq) []string {
seen := make(map[string]struct{}, len(r.Mobiles))
out := make([]string, 0, len(r.Mobiles))
for _, m := range r.Mobiles {
n := util.NormalizeMobile(m)
if !util.IsValidMainlandMobile(n) {
continue
}
if _, dup := seen[n]; !dup {
seen[n] = struct{}{}
out = append(out, n)
}
}
return out
}
// genTaskNo 生成任务号 T+yyyyMMddHHmmss+6 位随机(≤32 字符)。
// Day50 压测修复:4 位随机在 ~17 req/s 下 5min 即碰撞 3 次(实测);
// 50 req/s(5000TPS 批量)时扩至 6 位,碰撞由任务号唯一索引+code:5 幂等兜底。
func genTaskNo() string {
n, _ := rand.Int(rand.Reader, big.NewInt(1000000))
return fmt.Sprintf("T%s%06d", time.Now().Format("20060102150405"), n.Int64())
}
// PersonalItem 个性短信条目(逐号独立内容;Day 46 sendMessageOne)。
type PersonalItem struct {
Mobile string
Content string
}
// MaxPersonalItems 单次个性短信条目上限(协议文档 sendMessageOne 上限 1000)。
const MaxPersonalItems = 1000
// SubmitPersonal 个性短信受理(Day 46 外部 API sendMessageOne):
// 单 task(SendType=2)+逐 detail 独立内容;费用=逐条 segments 累计;
// 余额校验/事务落库/审核分流与 Submit 同口径。号码去重取首条内容。
// source Day 60:受理来源打标(0→API 归一)。
func (s *SubmitService) SubmitPersonal(ctx context.Context, accountID int64,
items []PersonalItem, scheduleAt *time.Time, extend, callData, clientIP string,
source int8) (*SubmitResult, error) {
if len(items) == 0 {
return nil, errors.InvalidParam.WithMsg("个性短信条目为空")
}
if len(items) > MaxPersonalItems {
return nil, errors.InvalidParam.WithMsg(fmt.Sprintf("条目 %d 超单次上限 %d", len(items), MaxPersonalItems))
}
seen := make(map[string]struct{}, len(items))
merged := make([]PersonalItem, 0, len(items))
totalFee := 0
for _, it := range items {
n := util.NormalizeMobile(it.Mobile)
if !util.IsValidMainlandMobile(n) {
return nil, errors.InvalidParam.WithMsg("非法手机号: " + it.Mobile)
}
if it.Content == "" {
return nil, errors.InvalidParam.WithMsg("内容为空: " + n)
}
if rc := len([]rune(it.Content)); rc > MaxTextLen {
return nil, errors.InvalidParam.WithMsg(fmt.Sprintf("内容 %d 字超上限 %d: %s", rc, MaxTextLen, n))
}
if _, dup := seen[n]; dup {
continue
}
seen[n] = struct{}{}
_, seg := util.SmsLength(it.Content)
if seg == 0 {
seg = 1
}
totalFee += seg
merged = append(merged, PersonalItem{Mobile: n, Content: it.Content})
}
if len(merged) == 0 {
return nil, errors.InvalidParam.WithMsg("无有效条目")
}
// 余额只读快检 + 原子预扣(Day48 与 Submit 同口径)。
var acct entity.AccountUser
if err := s.db.WithContext(ctx).Select("id", "balance").
First(&acct, accountID).Error; err != nil {
return nil, errors.NotFound.WithMsg("账号不存在")
}
if acct.Balance < int64(totalFee) {
return nil, errors.Arrears.WithMsg(
fmt.Sprintf("余额不足:当前 %d 条,本次需 %d 条", acct.Balance, totalFee))
}
taskNo := genTaskNo()
if err := s.holdFee(ctx, accountID, int64(totalFee), taskNo); err != nil {
return nil, err
}
task := entity.MessageTask{
TaskNo: taskNo, AccountID: accountID,
SendType: SendTypePersonal, Content: merged[0].Content,
MobileCount: len(merged), FeeTotal: float64(totalFee),
AuditStatus: 0, Status: 0, ScheduleAt: scheduleAt, SubmitIP: clientIP,
CallData: util.Truncate(callData, 64),
Source: NormalizeTaskSource(source), // Day 60:受理来源
}
// 逐号拦截(独立内容;命中号受理期终态 5+计费退)。
// Day51 R3:请求级快照同 Submit(个性批量同受益)。
blocks := make([]*interceptor.Block, len(merged))
blockedFee, passCount := 0, 0
pm := make([]string, len(merged))
for i, it := range merged {
pm[i] = it.Mobile
}
sc := s.chain.NewScope(ctx, accountID, pm)
for i, it := range merged {
if b := s.intercept(ctx, taskNo, accountID, SendTypePersonal, it.Mobile, it.Content, sc); b != nil {
blocks[i] = b
if _, seg := util.SmsLength(it.Content); seg > 0 {
blockedFee += seg
} else {
blockedFee++
}
continue
}
passCount++
}
details := make([]entity.MessageDetail, 0, len(merged))
for i, it := range merged {
_, seg := util.SmsLength(it.Content)
if seg == 0 {
seg = 1
}
d := entity.MessageDetail{
AccountID: accountID, Mobile: it.Mobile, Content: it.Content,
Status: 0, Fee: float64(seg),
ExtCode: util.Truncate(extend, 32),
CallData: util.Truncate(callData, 64),
Business: task.Business, Source: task.Source, // Day66:明细单表化冗余(个性发 task 已 Normalize)
}
if blocks[i] != nil {
d.Status = 5
d.ErrorCode = util.Truncate(blocks[i].Code, 16)
}
d.ID = s.sf.NextID()
details = append(details, d)
}
err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
if err := tx.Create(&task).Error; err != nil {
return err
}
return nil // Day52 R2:入口事务仅落 task(明细移消费侧批量落库)
})
if err != nil {
_ = s.refund(ctx, accountID, int64(totalFee), taskNo, "落库失败退回")
return nil, err
}
for i := range details { // Day52 R2:事件/降级路径共用 TaskID 回填
details[i].TaskID = task.ID
}
if blockedFee > 0 {
_ = s.refund(ctx, accountID, int64(blockedFee), taskNo, "拦截号码退费")
}
// Day52 R2:明细随事件投递(全拦/定时亦投;消费侧 claim 域外仅落明细)。
s.emitOrFallback(ctx, &task, details)
if passCount == 0 {
_ = s.db.WithContext(ctx).Model(&entity.MessageTask{}).
Where("id = ? AND status = ?", task.ID, 0).
Updates(map[string]any{
"status": TaskStDone, "fail_count": len(merged), "finished_at": time.Now(),
}).Error
task.Status = TaskStDone
task.FailCount = len(merged)
return &SubmitResult{Task: &task}, nil
}
var rec *entity.AuditRecord
if s.rt != nil {
t2, r2, rerr := s.rt.Route(ctx, task.ID)
if rerr != nil {
return nil, fmt.Errorf("任务已受理(任务号 %s)但审核分流失败: %w", taskNo, rerr)
}
task, rec = *t2, r2
if task.AuditStatus == 2 { // 审核拒绝:存活号费用退(拦截费已退)
_ = s.refund(ctx, accountID,
int64(totalFee)-int64(blockedFee), taskNo, "审核拒绝退费")
}
}
est := &Estimate{ValidCount: len(merged), TotalFee: totalFee}
return &SubmitResult{Task: &task, Record: rec, Estimate: est}, nil
}