// 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 }