325 lines
13 KiB
Go
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
|
|
}
|