Files
go-sms-V2/internal/service/report/consumer.go
T
Tory bb60d60529
ci / test (push) Canceled after 0s
ci / web-test (push) Canceled after 0s
ci / build (push) Canceled after 0s
ci / deploy-dev (push) Canceled after 0s
S4-D1/D2: C1 回调推送引擎+C2 上行自动拉黑——验收项「死信可查/拒收即拉黑」✅: ①C1=callback_task 队列表(迁移 v21,状态机 pending→sent/dead+attempt/next_retry_at/last_code)+PushWorker(2s 扫/批 100/并发 8/2^n 秒指数退避封顶 10min/10 次耗尽死信/UPDATE CAS 防竞态)+双挂点(report 终态首锁[Consumer+PairService,与 CMPP Deliver 同点同语义]+uplink 消费尾)+URL 门控 account_config.report_url/uplink_url(60s TTL 缓存,未配置零任务)+GET /ops/callback(列表+状态计数面板)/POST /ops/callback/:id/resend(casbin ops callback:read/write v21 所种)+前端回调管理页(ops-callback 路由系统管理组+api/callback.ts+状态面板/筛选/载荷展开/死信重派;matrix+guard 33 菜单显式更)+metrics callback_push_total{type,result}/blacklist_total+openapi v1.4.0;②C2=AutoBlacklister 等值词表(trim+lower 防误伤,默认 R/TD/退订/拒收;SystemConfig uplink.blacklist.keywords 可配 60s 刷新)→policy_blacklist(source=2/账号级/uk 幂等)+Redis Set 即时生效,拉黑不影响上行推送(需求原文);③真机全链六步实证(dev 中间件):回执 DELIVRD→detail 终态→HTTP 回调 JSON 送达(200/sent)+上行 R→拉黑(source=2+Redis=1)+推送送达+坏 URL→attempt10→dead→resend ISC:000→修复重投 sent+status_counts 面板;一次性探针 cmd/cbprobe 用后即删+冒烟数据全清;④单测 +13(callback 6[入队门控/载荷/状态机全链/并发批]+uplink 5[词表/配置覆盖/幂等缓存/消费链]+report 2[首锁一次/nil]);⑤门禁=build/vet/-race 40 包/lint 0/eslint0/vue-tsc0/vitest 148/build 全绿;迁移测试 v15..v21 两遍幂等+dev 实跑 v21;gofmt 存量 8 文件顺手清零(S2 遗留);⑥口径诚实标注:载荷无签名挂账/拦截终态 HTTP 未挂(CMPP 侧已有)/PushWorker 单实例 at-least-once;验收单 s4-d1d2-callback.md+CHANGELOG+memory-bank 回填
2026-11-16 11:19:55 +08:00

325 lines
13 KiB
Go

// consumer.go Day 56:sms-report 消费者——回执归一化(Day55 三态词表)
// +段级配对(msg_id+mobile→message_report_seg 置态)+按 detail_id 聚合
// 段数判终态(长短信 1~9 片,全 SUCCESS→成功/任一 FAILURE→失败/其余挂起)
// +message_report 落库(uk_detail 幂等,30 天重推窗口数据源)。
// Day 57 落地(原挂账清单):①48h 补偿扫描→UNKNOWN 结案(compensator.go);
// ②task 聚合计数联动(success/fail/unknown_count 覆写, billing.go syncTask);
// ③预扣转实扣/失败退款(finishDetail 首次锁定分支→Billing.Confirm)。
package report
import (
"context"
"encoding/json"
"time"
"go-sms/internal/model/entity"
"go-sms/internal/pkg/logger"
"go-sms/internal/pkg/metrics"
"go.uber.org/zap"
"gorm.io/gorm"
"gorm.io/gorm/clause"
)
// Consumer sms-report 消费者。
type Consumer struct {
db *gorm.DB
bill *Billing // Day 57:计费确认(nil=跳过,Day56 零破坏)
push PushSink // Day 61:CMPP Deliver 下发出口(nil=跳过)
cb ReportEnqueuer // S4·C1:HTTP 回调入队出口(nil=跳过)
requeue func(ev *Event) error // Day 69 三轮:unpaired 短重投出口(nil=直接按杂音丢弃)
}
// ReportEnqueuer 回执终态 HTTP 回调入队出口(S4·C1;装配层注入
// *callback.Service。终态首锁后调用,与 bill.Confirm 同为事务提交后动作;
// 内部失败由实现方/调用方 Warn 吞错——终态不回滚)。
type ReportEnqueuer interface {
EnqueueReport(ctx context.Context, detailID int64,
status int8, st, errCode, mobile string, now time.Time) error
}
// NewConsumer 构造。
func NewConsumer(db *gorm.DB) *Consumer { return &Consumer{db: db} }
// WithBilling 注入计费确认器(Day 57:终态锁定后失败/UNKNOWN 退款+task 计数
// 联动;链式,与 send.ReclaimScanner.WithBatch 同风格)。
func (c *Consumer) WithBilling(b *Billing) *Consumer {
c.bill = b
return c
}
// WithPushSink 注入 CMPP Deliver 下发出口(Day 61;链式,nil=跳过)。
func (c *Consumer) WithPushSink(p PushSink) *Consumer {
c.push = p
return c
}
// WithCallback 注入 HTTP 回调入队出口(S4·C1;链式,nil=跳过)。
func (c *Consumer) WithCallback(e ReportEnqueuer) *Consumer {
c.cb = e
return c
}
// enqueueReportLocked 终态首锁后的回调入队(吞错 Warn:推送失败不影响
// 已锁定的对账事实源——与 CMPP Deliver 下发同口径)。
func (c *Consumer) enqueueReportLocked(ctx context.Context, act *finAction, now time.Time) {
if c.cb == nil || act == nil {
return
}
if err := c.cb.EnqueueReport(ctx, act.detailID, act.status,
string(act.st), act.errCode, act.mobile, now); err != nil {
logger.L().Warn("callback_report_enqueue_failed",
zap.Int64("detail_id", act.detailID), zap.Error(err))
}
}
// WithRequeue 注入 unpaired 短重投出口(Day 69 三轮;链式,nil=不重投)。
// 场景:秒回模拟器回执(push→kafka→消费,~10ms)可跑赢发送侧 seg 落库
// (submit 往返+批量写,~20ms+)——合法回执 unpaired 若直接丢弃=detail
// 永久挂起。重投回 sms-report 尾部获得队列级延迟,二次消费时 seg 已
// 到位;重投失败上抛交消费组重试(消息不丢)。
func (c *Consumer) WithRequeue(f func(ev *Event) error) *Consumer {
c.requeue = f
return c
}
// HandlePayload 消费入口(Kafka handler;载荷即 Event JSON)。
func (c *Consumer) HandlePayload(_ context.Context, value []byte) error {
var ev Event
if err := json.Unmarshal(value, &ev); err != nil {
return err // 非法载荷交由消费组重试→死信(与 submit/uplink 消费者同口径)
}
return c.Process(context.Background(), &ev)
}
// finAction aggregate 判定出的终态动作(挂起时为 nil)。
type finAction struct {
detailID, channelID int64
status int8
errCode string
st Status
mobile string
}
// Process 单条回执:段置态→聚合判终态→detail+message_report 回写。
// 无配对段(msg_id+mobile 未命中)返回 nil 不重试——挂起口径
// (重启丢登记/上游重推旧号等场景,重试无意义,日志可观测)。
// P1 压测优化(09-27):seg 置态/detail 终态/report 插入三写合一单事务
// ——此前 3 次独立 autocommit,26697 回执=8 万次提交是 HDD fsync 排队
// 主力(w_await 127ms);合一后提交次数 ÷3,首锁/幂等/乱序语义零漂移。
// bill.Confirm(含 Redis Refund)留在事务提交后:锁定成功才动钱,
// 回滚重放不会双退(原时序语义);pushDeliverLocked 在事务内,极窄回滚
// 窗口存在重复推送可能(at-least-once,客户端幂等兜底)。
func (c *Consumer) Process(ctx context.Context, ev *Event) error {
st := Normalize(ev.Stat)
now := time.Now()
var act *finAction
var locked bool
var paired bool // 配对到段(区别无配对挂起:后者不复查不重试,原口径)
err := c.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
res := tx.Model(&entity.MessageReportSeg{}).
Where("msg_id = ? AND mobile = ?", ev.MsgID, ev.Dest).
Updates(map[string]any{
"status": string(st),
"raw_code": ev.Stat,
"report_at": now,
})
if res.Error != nil {
return res.Error
}
if res.RowsAffected == 0 {
logger.L().Warn("report_seg_unpaired",
zap.Int64("channel_id", ev.ChannelID), zap.String("msg_id", ev.MsgID),
zap.String("mobile", ev.Dest), zap.String("stat", ev.Stat))
return nil
}
paired = true
var err error
act, err = c.aggregate(ctx, tx, ev, st, ev.Stat, now)
if err != nil || act == nil {
return err
}
locked, err = finalizeDetail(ctx, tx, c.push,
act.detailID, act.channelID, act.status, act.errCode, now, act.st, act.mobile)
return err
})
if err != nil {
return err
}
if locked && c.bill != nil { // 首到终态锁定且事务已提交:计费确认(内部吞错,方向=少退不少扣)
c.bill.Confirm(ctx, act.detailID, act.status)
}
if locked { // S4·C1:HTTP 回调入队(账号配置 report_url 才产生任务)
c.enqueueReportLocked(ctx, act, now)
}
if !paired {
return c.handleUnpaired(ev) // Day 69 三轮:秒回竞态短重投,耗尽才按杂音丢弃
}
if act == nil {
// 多段聚合竞态双盲兜底(Day 69 二轮):REPEATABLE READ 下同 detail
// 多段回执并发到达,各自事务快照互不含对方未提交置态→双双 pending
// (2278311~13 实锤;detail 行 FOR UPDATE 无效——锁是当前读,count
// 仍走旧快照,已回滚)。主事务提交后开全新事务(新快照)重判:并发
// 簇最后提交者此刻必见全部已提交段,到齐即终态;finalizeDetail
// WHERE status=1 首锁保证与任意并发路径至多终态一次。仍 pending=
// 真未到齐,等后续段。零锁无死锁;单段(pk_total=1)主事务直接终
// 态不进此路径,零额外开销。
metrics.ReportPendingTotal.Inc()
return c.recheckPending(ctx, ev, st, now)
}
return nil
}
// unpairedMaxRetries unpaired 重投上限(回 sms-report 尾部天然延迟;超过
// 视为真杂音——重启丢登记/上游重推旧号,再投无意义,丢弃留痕)。
const unpairedMaxRetries = 3
// handleUnpaired 无配对段回执处置(Day 69 三轮):seg 落库竞态窗口内到达的
// 合法回执短重投(≤3 次,队列级延迟后 seg 已到位);重投失败上抛交消费组
// 重试(消息不丢);无出口或耗尽=真杂音,丢弃留痕(原挂起口径)。
func (c *Consumer) handleUnpaired(ev *Event) error {
if ev.Retries < unpairedMaxRetries && c.requeue != nil {
metrics.ReportRequeueTotal.Inc()
retry := *ev
retry.Retries++
if err := c.requeue(&retry); err != nil {
return err
}
return nil
}
logger.L().Warn("report_seg_unpaired_drop",
zap.Int64("channel_id", ev.ChannelID), zap.String("msg_id", ev.MsgID),
zap.String("mobile", ev.Dest), zap.String("stat", ev.Stat),
zap.Int("retries", ev.Retries))
return nil
}
// recheckPending pending 后新事务复查(Day 69 二轮竞态修复,见 Process 注)。
func (c *Consumer) recheckPending(ctx context.Context, ev *Event, st Status, now time.Time) error {
var act *finAction
var locked bool
err := c.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
var err error
act, err = c.aggregate(ctx, tx, ev, st, ev.Stat, now)
if err != nil || act == nil {
return err
}
locked, err = finalizeDetail(ctx, tx, c.push,
act.detailID, act.channelID, act.status, act.errCode, now, act.st, act.mobile)
return err
})
if err != nil {
return err
}
if act != nil {
metrics.ReportRecheckTotal.WithLabelValues("finalized").Inc()
} else {
metrics.ReportRecheckTotal.WithLabelValues("still_pending").Inc()
}
if locked && c.bill != nil {
c.bill.Confirm(ctx, act.detailID, act.status)
}
if locked { // S4·C1:HTTP 回调入队(补刀终态同推)
c.enqueueReportLocked(ctx, act, now)
}
return nil
}
// aggregate 按 detail 聚合全部段判终态(db=调用方事务对象);返回终态动作,
// nil=未到齐挂起:
// - 任一段 FAILURE → detail 3 失败(error_code=失败段原始码);
// - 全段 SUCCESS 且到齐(有回执段数=PkTotal) → detail 2 成功;
// - 其余(部分未达/UNKNOWN) → 保持不动(挂起,48h 扫描后转 UNKNOWN 结案)。
func (c *Consumer) aggregate(ctx context.Context, db *gorm.DB, ev *Event, st Status, rawCode string, now time.Time) (*finAction, error) {
var seg entity.MessageReportSeg
if err := db.WithContext(ctx).
Where("msg_id = ? AND mobile = ?", ev.MsgID, ev.Dest).
First(&seg).Error; err != nil {
return nil, err
}
type segAgg struct {
Status string
N int64
}
var rows []segAgg
if err := db.WithContext(ctx).Model(&entity.MessageReportSeg{}).
Select("status, COUNT(*) AS n").
Where("detail_id = ?", seg.DetailID).
Group("status").Scan(&rows).Error; err != nil {
return nil, err
}
var arrived, success, failure int64
for _, r := range rows {
switch Status(r.Status) {
case StatusSuccess:
success += r.N
arrived += r.N
case StatusFailure:
failure += r.N
arrived += r.N
case StatusUnknown:
arrived += r.N // UNKNOWN 已到但非终态:不计成功不判失败
}
}
total := int64(seg.PkTotal)
switch {
case failure > 0:
return &finAction{detailID: seg.DetailID, channelID: seg.ChannelID,
status: 3, errCode: rawCode, st: StatusFailure, mobile: ev.Dest}, nil
case success == total && total > 0:
return &finAction{detailID: seg.DetailID, channelID: seg.ChannelID,
status: 2, errCode: "", st: StatusSuccess, mobile: ev.Dest}, nil
default:
// 未到齐(或含 UNKNOWN 挂起):detail 保持已提交态,等后续段/补偿扫描。
logger.L().Info("report_detail_pending",
zap.Int64("detail_id", seg.DetailID), zap.Int64("arrived", arrived),
zap.Int64("pk_total", total), zap.String("stat", rawCode))
return nil, nil
}
}
// finalizeDetail 终态回写单一实现(Consumer 回执链/手动配对共用):
// message_detail(status=1 首锁回写)+ message_report 插入(uk_detail 冲突忽略)
// + Day57 计费确认(bill≠nil)+ Day61 CMPP Deliver 推送(push≠nil)。
// 「首到终态锁定」:detail 仅在已提交态(status=1)回写——重复回执重放/
// 乱序异态(先 DELIVRD 后 UNDELIV)不翻转已锁定终态,资损安全方向。
// 返回 locked=false 表示终态已被锁定(调用方按幂等跳过处理)。
// finalizeDetail 终态回写单一实现(Consumer 回执链/手动配对共用;db=调用方
// 事务对象——P1 三写合一后 Confirm 由调用方在事务提交后按 locked 触发):
func finalizeDetail(ctx context.Context, db *gorm.DB, push PushSink,
detailID, channelID int64, status int8, errCode string, now time.Time, st Status, mobile string) (bool, error) {
if ec := []rune(errCode); len(ec) > 16 {
errCode = string(ec[:16]) // 与 markDetail/batchwriter 同截断口径
}
res := db.WithContext(ctx).Model(&entity.MessageDetail{}).
Where("id = ? AND status = 1", detailID). // 1=已提交,终态可进不可翻
Updates(map[string]any{
"status": status, "error_code": errCode, "report_at": now,
})
if res.Error != nil {
return false, res.Error
}
if res.RowsAffected == 0 {
logger.L().Info("report_detail_final_locked_skip",
zap.Int64("detail_id", detailID), zap.String("status", string(st)))
return false, nil // 终态已锁定(重复回执/乱序重放):计费亦跳过——msg_id 幂等锚
}
if err := db.WithContext(ctx).Clauses(clause.OnConflict{
Columns: []clause.Column{{Name: "detail_id"}},
DoNothing: true,
}).Create(&entity.MessageReport{
DetailID: detailID, ChannelID: channelID,
Status: string(st), RawCode: errCode, ErrorCode: errCode, ReportAt: now,
}).Error; err != nil {
return true, err
}
// Day 57:计费确认移至调用方事务提交后(P1 三写合一:Refund(Redis)在
// 事务内会有回滚双退窗口;锁定成功才动钱,语义不变):
// 成功不动钱(预扣即实扣)/失败退款/UNKNOWN 冻结释放+task 计数联动;
// 内部吞错(方向=少退不少扣,对账兜底),不阻塞消费 offset 前进。
// Day 61(P0.5):CMPP 客户回执协议侧下发(仅首锁分支——重复回执不重推;
// 非 CMPP 来源/下发失败均静默,不影响已锁定的对账事实源)。
pushDeliverLocked(ctx, db, push, detailID, status, errCode, mobile, now)
return true, nil
}