From 11ee6f4f05063aaf70a145c73d5754ccf13ffb3b Mon Sep 17 00:00:00 2001 From: Tory Date: Fri, 13 Nov 2026 16:54:41 +0800 Subject: [PATCH] =?UTF-8?q?S1-B=20D4.1:=20B=20=E5=B1=82=E6=90=AC=E8=BF=90?= =?UTF-8?q?=20report=2014=20=E6=96=87=E4=BB=B6(P1=20=E7=AD=89=E4=BB=B7;UNK?= =?UTF-8?q?NOWN=2072h/compensator/C3=20=E9=87=8D=E6=8E=A8=E8=AF=AD?= =?UTF-8?q?=E4=B9=89=E5=85=A8=E7=95=99;C1=20=E5=BC=95=E6=93=8E=20S4=20?= =?UTF-8?q?=E4=BA=8B;47.5%=20=E7=A6=BB=E7=BA=BF=E5=8F=A3=E5=BE=84=20-race?= =?UTF-8?q?=20=E7=BB=BF)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- internal/service/report/billing.go | 116 +++++ internal/service/report/billing_test.go | 163 +++++++ internal/service/report/compensator.go | 122 +++++ internal/service/report/compensator_test.go | 150 +++++++ internal/service/report/consumer.go | 290 ++++++++++++ internal/service/report/consumer_test.go | 443 +++++++++++++++++++ internal/service/report/deliver_push.go | 138 ++++++ internal/service/report/deliver_push_test.go | 48 ++ internal/service/report/errorcode.go | 136 ++++++ internal/service/report/errorcode_test.go | 84 ++++ internal/service/report/normalize.go | 45 ++ internal/service/report/normalize_test.go | 37 ++ internal/service/report/pair.go | 380 ++++++++++++++++ internal/service/report/sink.go | 62 +++ 14 files changed, 2214 insertions(+) create mode 100644 internal/service/report/billing.go create mode 100644 internal/service/report/billing_test.go create mode 100644 internal/service/report/compensator.go create mode 100644 internal/service/report/compensator_test.go create mode 100644 internal/service/report/consumer.go create mode 100644 internal/service/report/consumer_test.go create mode 100644 internal/service/report/deliver_push.go create mode 100644 internal/service/report/deliver_push_test.go create mode 100644 internal/service/report/errorcode.go create mode 100644 internal/service/report/errorcode_test.go create mode 100644 internal/service/report/normalize.go create mode 100644 internal/service/report/normalize_test.go create mode 100644 internal/service/report/pair.go create mode 100644 internal/service/report/sink.go diff --git a/internal/service/report/billing.go b/internal/service/report/billing.go new file mode 100644 index 00000000..309697ab --- /dev/null +++ b/internal/service/report/billing.go @@ -0,0 +1,116 @@ +// billing.go Day 57:计费确认(实施计划 5.3/A-5.2~A-5.4,基于 Day54 R1 预扣口径)。 +// R1 语义=提交即实扣(Hold=Redis DECRBY/MySQL 行锁,提交链资金已出): +// +// 成功(2) → 无资金动作(「预扣=实扣」半边,零差额验收); +// 失败(3) → Refund(fee)(A-5.3 预扣金额退回,余额恢复); +// 未知(4) → Refund(fee)(A-5.4 冻结释放;UNKNOWN 回执/48h 补偿扫描同口径)。 +// +// msg_id 幂等锚=detail「首到终态锁定」(consumer.finishDetail WHERE status=1 +// RowsAffected=1 分支才调本Confirm)——重复回执/乱序重放走不到此处, +// 每条明细资金动作至多一次;本函数自身不承诺幂等(裸调两次=两次退款)。 +// task 联动:回执终态覆写三计数(COUNT BY status 聚合覆写,幂等防双计—— +// 下发侧 done 的 success=sent 是提交口径中间态,回执口径为最终事实)+ +// 无在途兜底完成(拦截 5 不入三计数,FE intercepted_count 单列口径)。 +package report + +import ( + "context" + "strconv" + "time" + + "go-sms/internal/model/entity" + "go-sms/internal/pkg/logger" + "go-sms/internal/service/balance" + + "go.uber.org/zap" + "gorm.io/gorm" +) + +// Billing 计费确认器(bal=nil 跳过资金动作,计数联动仍生效——测试/未装配)。 +type Billing struct { + db *gorm.DB + bal balance.Store +} + +// NewBilling 构造。 +func NewBilling(db *gorm.DB, bal balance.Store) *Billing { + return &Billing{db: db, bal: bal} +} + +// Confirm detail 首次终态锁定后的资金动作+task 计数联动。 +// 失败不向上抛:终态已锁定,Kafka 重试重放走不到计费分支,抛错只会无谓 +// 重试→死信;两级 Store(Redis→MySQL 回退)均失败的窗口记 Error 日志, +// 资损方向=少退不少扣(平台安全),对账差额告警+人工补偿兜底(R1 评审口径)。 +func (b *Billing) Confirm(ctx context.Context, detailID int64, status int8) { + var d entity.MessageDetail + if err := b.db.WithContext(ctx).First(&d, detailID).Error; err != nil { + logger.L().Error("billing_detail_load_failed", + zap.Int64("detail_id", detailID), zap.Error(err)) + return + } + if (status == 3 || status == 4) && b.bal != nil { + fee := int64(d.Fee) // R1 整型条数口径(Fee=segments),零舍入 + reason := "回执失败退款" + if status == 4 { + reason = "UNKNOWN冻结释放" + } + refID := strconv.FormatInt(detailID, 10) // 审计可追溯(幂等锚在终态锁定) + if err := b.bal.Refund(ctx, d.AccountID, fee, refID, reason); err != nil { + logger.L().Error("billing_refund_failed", + zap.Int64("detail_id", detailID), zap.Int64("account_id", d.AccountID), + zap.Int64("fee", fee), zap.Int8("status", status), + zap.String("ref_id", refID), + zap.String("direction", "少退不少扣,对账兜底"), zap.Error(err)) + } + } + b.syncTask(ctx, d.TaskID) +} + +// syncTask 回执终态计数覆写+无在途兜底完成(聚合覆写天然防重放双计)。 +func (b *Billing) syncTask(ctx context.Context, taskID int64) { + type stAgg struct { + Status int8 + N int64 + } + var rows []stAgg + if err := b.db.WithContext(ctx).Model(&entity.MessageDetail{}). + Select("status, COUNT(*) AS n"). + Where("task_id = ?", taskID). + Group("status").Scan(&rows).Error; err != nil { + logger.L().Error("billing_task_agg_failed", zap.Int64("task_id", taskID), zap.Error(err)) + return + } + var s, f, u, inflight int64 + for _, r := range rows { + switch r.Status { + case 2: + s += r.N + case 3: + f += r.N + case 4: + u += r.N + case 0, 1: // 待发/已提交=在途(审核拒绝任务停留 0,由审核域终态,不受此处完成) + inflight += r.N + } + } + if err := b.db.WithContext(ctx).Model(&entity.MessageTask{}). + Where("id = ?", taskID). + Updates(map[string]any{ + "success_count": s, "fail_count": f, "unknown_count": u, + }).Error; err != nil { + logger.L().Error("billing_task_counters_failed", zap.Int64("task_id", taskID), zap.Error(err)) + return + } + if inflight == 0 { + // 无在途兜底完成:下发侧 done(status 1→2)为准,此处仅补写缺口; + // WHERE 含 status IN (0,1) 幂等(已 done 的任务不再翻写)。 + res := b.db.WithContext(ctx).Model(&entity.MessageTask{}). + Where("id = ? AND status IN (0, 1) AND finished_at IS NULL", taskID). + Updates(map[string]any{"status": 2, "finished_at": time.Now()}) + if res.Error == nil && res.RowsAffected == 1 { + logger.L().Info("billing_task_finished_by_report", zap.Int64("task_id", taskID)) + } else if res.Error != nil { + logger.L().Error("billing_task_finish_failed", zap.Int64("task_id", taskID), zap.Error(res.Error)) + } + } +} diff --git a/internal/service/report/billing_test.go b/internal/service/report/billing_test.go new file mode 100644 index 00000000..c0890a60 --- /dev/null +++ b/internal/service/report/billing_test.go @@ -0,0 +1,163 @@ +// billing_test.go Day 57:计费确认单测——三态资金动作(成功零动作/失败退款/ +// UNKNOWN 冻结释放)+task 计数覆写联动(聚合幂等,防下发口径双计)+ +// 无在途兜底完成。fakeStore 记录 Refund 调用序列供断言。 +package report + +import ( + "context" + "sync" + "testing" + "time" + + "github.com/glebarez/sqlite" + "gorm.io/gorm" + "gorm.io/gorm/logger" + + "go-sms/internal/model/entity" +) + +// refundCall fakeStore 记录的退款调用。 +type refundCall struct { + accountID, amount int64 + refID, reason string +} + +// fakeStore balance.Store 桩(记退款序列;Hold 恒成功)。 +type fakeStore struct { + mu sync.Mutex + refunds []refundCall +} + +func (f *fakeStore) Hold(_ context.Context, _ int64, _ int64, _ string) error { return nil } +func (f *fakeStore) Refund(_ context.Context, accountID, amount int64, refID, reason string) error { + f.mu.Lock() + defer f.mu.Unlock() + f.refunds = append(f.refunds, refundCall{accountID, amount, refID, reason}) + return nil +} +func (f *fakeStore) Mode() string { return "fake" } + +func (f *fakeStore) calls() []refundCall { + f.mu.Lock() + defer f.mu.Unlock() + return append([]refundCall(nil), f.refunds...) +} + +func newBillingDB(t *testing.T) *gorm.DB { + t.Helper() + db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{Logger: logger.Discard}) + if err != nil { + t.Fatalf("打开内存库失败: %v", err) + } + if err := db.AutoMigrate(&entity.MessageDetail{}, &entity.MessageReport{}, + &entity.MessageReportSeg{}, &entity.MessageTask{}); err != nil { + t.Fatalf("AutoMigrate 失败: %v", err) + } + return db +} + +func getTask(t *testing.T, db *gorm.DB, id int64) entity.MessageTask { + t.Helper() + var tk entity.MessageTask + if err := db.First(&tk, id).Error; err != nil { + t.Fatal(err) + } + return tk +} + +// TestBilling_SuccessNoMoneyMove 成功终态:零资金动作(A-5.2 预扣=实扣半边)。 +func TestBilling_SuccessNoMoneyMove(t *testing.T) { + db := newBillingDB(t) + fs := &fakeStore{} + d := mkDetail(t, db, 7, "13800002222", 1) + bill := NewBilling(db, fs) + bill.Confirm(testCtx, d.ID, 2) + if got := len(fs.calls()); got != 0 { + t.Fatalf("成功终态不应退款,实得 %d 次", got) + } +} + +// TestBilling_FailureRefundOnce 失败终态:按 detail.Fee(整型条数)退款一次。 +func TestBilling_FailureRefundOnce(t *testing.T) { + db := newBillingDB(t) + fs := &fakeStore{} + d := entity.MessageDetail{TaskID: 7, AccountID: 5, Mobile: "13800003333", Status: 1, Fee: 3} + d.ID = time.Now().UnixNano() + if err := db.Create(&d).Error; err != nil { + t.Fatal(err) + } + NewBilling(db, fs).Confirm(testCtx, d.ID, 3) + calls := fs.calls() + if len(calls) != 1 { + t.Fatalf("失败终态应恰一次退款,实得 %d 次", len(calls)) + } + if calls[0].amount != 3 || calls[0].accountID != 5 { + t.Fatalf("退款口径错: %+v", calls[0]) + } + if calls[0].reason != "回执失败退款" { + t.Fatalf("reason 应为回执失败退款: %s", calls[0].reason) + } +} + +// TestBilling_UnknownRelease UNKNOWN 终态:冻结释放(A-5.4 同款退款)。 +func TestBilling_UnknownRelease(t *testing.T) { + db := newBillingDB(t) + fs := &fakeStore{} + d := mkDetail(t, db, 7, "13800004444", 1) + NewBilling(db, fs).Confirm(testCtx, d.ID, 4) + calls := fs.calls() + if len(calls) != 1 || calls[0].reason != "UNKNOWN冻结释放" { + t.Fatalf("UNKNOWN 应冻结释放一次: %+v", calls) + } +} + +// TestBilling_TaskCountersRewrite 计数联动:三态聚合覆写(拦截 5 不入三计数) +// +有在途不完成 +终态锁定后再 Confirm→无在途兜底完成+覆写幂等。 +func TestBilling_TaskCountersRewrite(t *testing.T) { + db := newBillingDB(t) + fs := &fakeStore{} + if err := db.Create(&entity.MessageTask{ + ID: 7, TaskNo: "T57A", AccountID: 1, MobileCount: 4, + Status: 1, // 下发侧置进行中,尚未 done + }).Error; err != nil { + t.Fatal(err) + } + mk := func(mobile string, status int8) entity.MessageDetail { return mkDetail(t, db, 7, mobile, status) } + mk("13800000001", 2) // 成功 + mk("13800000002", 3) // 失败 + mk("13800000003", 4) // 未知 + mk("13800000004", 5) // 拦截(不入三计数,FE intercepted_count 单列) + last := mk("13800000005", 1) + + bill := NewBilling(db, fs) + // 第一轮:last 仍在途(detail.status=1)→计数仅终态三行,不完成。 + bill.Confirm(testCtx, last.ID, 2) + tk := getTask(t, db, 7) + if tk.SuccessCount != 1 || tk.FailCount != 1 || tk.UnknownCount != 1 { + t.Fatalf("计数覆写错: s=%d f=%d u=%d", tk.SuccessCount, tk.FailCount, tk.UnknownCount) + } + if tk.FinishedAt != nil || tk.Status != 1 { + t.Fatalf("尚有在途不应完成: status=%d finished=%v", tk.Status, tk.FinishedAt) + } + // 第二轮:回执终态锁定(consumer.finishDetail 同款 UPDATE)后再 Confirm。 + if err := db.Model(&entity.MessageDetail{}). + Where("id = ? AND status = 1", last.ID). + Update("status", 2).Error; err != nil { + t.Fatal(err) + } + bill.Confirm(testCtx, last.ID, 2) + tk = getTask(t, db, 7) + if tk.SuccessCount != 2 || tk.FailCount != 1 || tk.UnknownCount != 1 { + t.Fatalf("末条计数错: s=%d f=%d u=%d", tk.SuccessCount, tk.FailCount, tk.UnknownCount) + } + if tk.Status != 2 || tk.FinishedAt == nil { + t.Fatalf("无在途应兜底完成: status=%d finished=%v", tk.Status, tk.FinishedAt) + } + // 第三轮:重放 Confirm——聚合覆写幂等(计数不变,零双计),finish 不再翻写。 + before := getTask(t, db, 7) + bill.Confirm(testCtx, last.ID, 2) + after := getTask(t, db, 7) + if after.SuccessCount != before.SuccessCount || after.FinishedAt == nil { + t.Fatalf("重放应幂等: before=%+v after=%+v", before, after) + } +} diff --git a/internal/service/report/compensator.go b/internal/service/report/compensator.go new file mode 100644 index 00000000..99c32384 --- /dev/null +++ b/internal/service/report/compensator.go @@ -0,0 +1,122 @@ +// compensator.go Day 57:无回执补偿扫描(A-5.4;实施计划 72h→项目日历 48h 口径; +// Day 71 起与入向长短信挂起窗统一 72h)。 +// 扫 status=1(已提交)且 COALESCE(send_at,created_at) 0 { + logger.L().Info("compensator_scan_closed", zap.Int("unknown_closed", n)) + } + tk := time.NewTicker(every) + defer tk.Stop() + for { + select { + case <-ctx.Done(): + return + case <-tk.C: + if n, err := c.ScanOnce(ctx); err != nil { + logger.L().Error("compensator_scan_failed", zap.Error(err)) + } else if n > 0 { + logger.L().Info("compensator_scan_closed", zap.Int("unknown_closed", n)) + } + } + } +} + +// ScanOnce 单轮扫描:返回结案条数(0=无到期挂起)。 +func (c *Compensator) ScanOnce(ctx context.Context) (int, error) { + cutoff := time.Now().Add(-c.window) + var ids []int64 + if err := c.db.WithContext(ctx).Model(&entity.MessageDetail{}). + Where("status = 1 AND COALESCE(send_at, created_at) < ?", cutoff). + Order("id").Limit(c.batch).Pluck("id", &ids).Error; err != nil { + return 0, err + } + now := time.Now() + closed := 0 + for _, id := range ids { + // 首到终态锁定:与迟到回执并发时至多一方生效(终态不可翻,资损安全)。 + res := c.db.WithContext(ctx).Model(&entity.MessageDetail{}). + Where("id = ? AND status = 1", id). + Updates(map[string]any{ + "status": 4, "error_code": "UNKNOWN", "report_at": now, + }) + if res.Error != nil { + return closed, res.Error + } + if res.RowsAffected == 0 { + continue // 已被回执锁定/他轮已结——幂等跳过 + } + closed++ + var d entity.MessageDetail + if err := c.db.WithContext(ctx).First(&d, id).Error; err != nil { + logger.L().Error("compensator_detail_load_failed", zap.Int64("detail_id", id), zap.Error(err)) + continue + } + if err := c.db.WithContext(ctx).Clauses(clause.OnConflict{ + Columns: []clause.Column{{Name: "detail_id"}}, + DoNothing: true, + }).Create(&entity.MessageReport{ + DetailID: id, ChannelID: d.ChannelID, + Status: string(StatusUnknown), RawCode: "UNKNOWN", + ErrorCode: "UNKNOWN", ReportAt: now, + }).Error; err != nil { + logger.L().Error("compensator_report_insert_failed", + zap.Int64("detail_id", id), zap.Error(err)) + } + if c.bill != nil { + c.bill.Confirm(ctx, id, 4) // 退款+计数联动(内部吞错记日志,方向=少退不少扣) + } + } + return closed, nil +} diff --git a/internal/service/report/compensator_test.go b/internal/service/report/compensator_test.go new file mode 100644 index 00000000..e2be81bd --- /dev/null +++ b/internal/service/report/compensator_test.go @@ -0,0 +1,150 @@ +// compensator_test.go Day 57:48h 补偿扫描单测——到期结案(UNKNOWN+退款+report +// 落库+计数联动)/未到期不动/已终态不翻(锁定)/重复扫描幂等(至多一次退款)。 +package report + +import ( + "testing" + "time" + + "github.com/glebarez/sqlite" + "gorm.io/gorm" + "gorm.io/gorm/logger" + + "go-sms/internal/model/entity" +) + +// newCompDB 补偿扫描测试库(同 newBillingDB,独立建避免用例间数据串扰)。 +func newCompDB(t *testing.T) *gorm.DB { + t.Helper() + db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{Logger: logger.Discard}) + if err != nil { + t.Fatalf("打开内存库失败: %v", err) + } + if err := db.AutoMigrate(&entity.MessageDetail{}, &entity.MessageReport{}, + &entity.MessageReportSeg{}, &entity.MessageTask{}); err != nil { + t.Fatalf("AutoMigrate 失败: %v", err) + } + return db +} + +// mkPending 直插挂起明细(send_at 相对 now 偏移;雪花 ID 显式)。 +func mkPending(t *testing.T, db *gorm.DB, taskID int64, mobile string, age time.Duration) entity.MessageDetail { + t.Helper() + d := entity.MessageDetail{ + TaskID: taskID, AccountID: 1, Mobile: mobile, Status: 1, + SendAt: ptrTime(time.Now().Add(-age)), + } + d.ID = time.Now().UnixNano() + 77 + if err := db.Create(&d).Error; err != nil { + t.Fatal(err) + } + return d +} + +func ptrTime(t time.Time) *time.Time { return &t } + +// TestCompensator_ExpiredToUnknown 到期挂起:置 4+退款+message_report 落库 +// +task unknown_count 联动(A-5.4 冻结释放全链)。 +func TestCompensator_ExpiredToUnknown(t *testing.T) { + db := newCompDB(t) + fs := &fakeStore{} + if err := db.Create(&entity.MessageTask{ + ID: 9, TaskNo: "T57C", AccountID: 1, MobileCount: 2, Status: 1, + }).Error; err != nil { + t.Fatal(err) + } + d := mkPending(t, db, 9, "13800005555", 73*time.Hour) // 72h 窗口外(Day71 统一口径) + + n, err := NewCompensator(db, NewBilling(db, fs), CompensatorOptions{}).ScanOnce(testCtx) + if err != nil { + t.Fatal(err) + } + if n != 1 { + t.Fatalf("应结案 1 条,实得 %d", n) + } + got := getDetail(t, db, d.ID) + if got.Status != 4 || got.ErrorCode != "UNKNOWN" { + t.Fatalf("应置 UNKNOWN(4): status=%d code=%s", got.Status, got.ErrorCode) + } + var cnt int64 + db.Model(&entity.MessageReport{}).Where("detail_id = ?", d.ID).Count(&cnt) + if cnt != 1 { + t.Fatalf("message_report 应落库 1 行,实得 %d", cnt) + } + calls := fs.calls() + if len(calls) != 1 || calls[0].reason != "UNKNOWN冻结释放" { + t.Fatalf("应冻结释放一次: %+v", calls) + } + tk := getTask(t, db, 9) + if tk.UnknownCount != 1 || tk.Status != 2 || tk.FinishedAt == nil { + t.Fatalf("task 联动错: %+v", tk) + } +} + +// TestCompensator_NotExpiredSkipped 窗口内(47h)与已终态(2)明细均不动。 +func TestCompensator_NotExpiredSkipped(t *testing.T) { + db := newCompDB(t) + fs := &fakeStore{} + mkPending(t, db, 9, "13800006666", 47*time.Hour) // 窗口内 + final := mkDetail(t, db, 9, "13800007777", 2) // 已成功锁定 + + n, err := NewCompensator(db, NewBilling(db, fs), CompensatorOptions{}).ScanOnce(testCtx) + if err != nil { + t.Fatal(err) + } + if n != 0 { + t.Fatalf("不应结案,实得 %d", n) + } + if len(fs.calls()) != 0 { + t.Fatalf("不应退款: %+v", fs.calls()) + } + if getDetail(t, db, final.ID).Status != 2 { + t.Fatal("已锁定终态被翻转(资损风险)") + } +} + +// TestCompensator_RescanIdempotent 两轮扫描:第二轮零结案零退款(幂等锚=锁定)。 +func TestCompensator_RescanIdempotent(t *testing.T) { + db := newCompDB(t) + fs := &fakeStore{} + d := mkPending(t, db, 9, "13800008888", 74*time.Hour) + comp := NewCompensator(db, NewBilling(db, fs), CompensatorOptions{}) + if n, err := comp.ScanOnce(testCtx); err != nil || n != 1 { + t.Fatalf("首轮应结案 1: n=%d err=%v", n, err) + } + if n, err := comp.ScanOnce(testCtx); err != nil || n != 0 { + t.Fatalf("次轮应零结案: n=%d err=%v", n, err) + } + if len(fs.calls()) != 1 { + t.Fatalf("重复扫描应恰一次退款,实得 %d 次", len(fs.calls())) + } + var cnt int64 + db.Model(&entity.MessageReport{}).Where("detail_id = ?", d.ID).Count(&cnt) + if cnt != 1 { + t.Fatalf("report 不应重复落库: %d", cnt) + } +} + +// TestCompensator_SendAtFallback send_at 缺失回退 created_at 口径。 +func TestCompensator_SendAtFallback(t *testing.T) { + db := newCompDB(t) + fs := &fakeStore{} + d := entity.MessageDetail{TaskID: 9, AccountID: 1, Mobile: "13800009999", Status: 1} + d.ID = time.Now().UnixNano() + 99 + d.CreatedAt = time.Now().Add(-73 * time.Hour) // 雪花模型仅 created_at,autoCreate 覆盖前显式 + if err := db.Create(&d).Error; err != nil { + t.Fatal(err) + } + // GORM autoCreateTime 会覆写 created_at——显式改回。 + if err := db.Model(&entity.MessageDetail{}).Where("id = ?", d.ID). + Update("created_at", time.Now().Add(-73*time.Hour)).Error; err != nil { + t.Fatal(err) + } + n, err := NewCompensator(db, NewBilling(db, fs), CompensatorOptions{}).ScanOnce(testCtx) + if err != nil { + t.Fatal(err) + } + if n != 1 { + t.Fatalf("created_at 回退口径应结案: %d", n) + } +} diff --git a/internal/service/report/consumer.go b/internal/service/report/consumer.go new file mode 100644 index 00000000..9a2ae643 --- /dev/null +++ b/internal/service/report/consumer.go @@ -0,0 +1,290 @@ +// 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=跳过) + requeue func(ev *Event) error // Day 69 三轮:unpaired 短重投出口(nil=直接按杂音丢弃) +} + +// 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 +} + +// 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 !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) + } + 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 +} diff --git a/internal/service/report/consumer_test.go b/internal/service/report/consumer_test.go new file mode 100644 index 00000000..69410c38 --- /dev/null +++ b/internal/service/report/consumer_test.go @@ -0,0 +1,443 @@ +// consumer_test.go Day 56:回执消费者单测——三态归一化联动(detail 终态)/ +// 长短信 9 片段级聚合(部分到达挂起/到齐成功/任一失败)/首到终态锁定 +// (乱序异态不翻转)/无配对段挂起不重试/合包多号独立置态。 +package report + +import ( + "context" + "fmt" + "sync" + "sync/atomic" + "testing" + "time" + + "github.com/glebarez/sqlite" + "gorm.io/gorm" + "gorm.io/gorm/logger" + + "go-sms/internal/model/entity" +) + +func newConsumerDB(t *testing.T) *gorm.DB { + t.Helper() + db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{Logger: logger.Discard}) + if err != nil { + t.Fatalf("打开内存库失败: %v", err) + } + if err := db.AutoMigrate(&entity.MessageDetail{}, &entity.MessageReport{}, &entity.MessageReportSeg{}); err != nil { + t.Fatalf("AutoMigrate 失败: %v", err) + } + return db +} + +var testCtx = context.Background() + +// detailSeq 测试明细 ID 序列(MessageDetail=雪花主键非自增,须显式赋值)。 +var detailSeq int64 + +// mkDetail 直插明细(显式雪花 ID)。 +func mkDetail(t *testing.T, db *gorm.DB, taskID int64, mobile string, status int8) entity.MessageDetail { + t.Helper() + d := entity.MessageDetail{TaskID: taskID, AccountID: 1, Mobile: mobile, Status: status} + d.ID = time.Now().UnixNano() + atomic.AddInt64(&detailSeq, 1) + if err := db.Create(&d).Error; err != nil { + t.Fatal(err) + } + return d +} + +// mkSeg 直插配对段(提交侧 writeSegRows 等价;msg_id 由 detailID+段序唯一化)。 +func mkSeg(t *testing.T, db *gorm.DB, detailID, channelID int64, mobile string, pkNumber, pkTotal int) string { + t.Helper() + mid := fmt.Sprintf("m%d-%02d", detailID, pkNumber) + row := entity.MessageReportSeg{ + DetailID: detailID, ChannelID: channelID, MsgID: mid, Mobile: mobile, + PkNumber: int8(pkNumber), PkTotal: int8(pkTotal), + } + if err := db.Create(&row).Error; err != nil { + t.Fatal(err) + } + return mid +} + +// ev 回执事件构造。 +func ev(channelID int64, msgID, stat, dest string) *Event { + return &Event{ChannelID: channelID, MsgID: msgID, Stat: stat, Dest: dest, RecvAt: time.Now().Format(time.RFC3339)} +} + +func getDetail(t *testing.T, db *gorm.DB, id int64) entity.MessageDetail { + t.Helper() + var d entity.MessageDetail + if err := db.First(&d, id).Error; err != nil { + t.Fatal(err) + } + return d +} + +// TestConsumer_SingleSuccess 单段成功:detail 1→2,message_report SUCCESS 落库。 +func TestConsumer_SingleSuccess(t *testing.T) { + db := newConsumerDB(t) + c := NewConsumer(db) + d := mkDetail(t, db, 1, "13800001111", 1) + mid := mkSeg(t, db, d.ID, 7, "13800001111", 1, 1) + + if err := c.Process(testCtx, ev(7, mid, "DELIVRD", "13800001111")); err != nil { + t.Fatal(err) + } + got := getDetail(t, db, d.ID) + if got.Status != 2 { + t.Fatalf("status=%d 期望 2(成功)", got.Status) + } + if got.ReportAt == nil { + t.Fatal("report_at 应写入") + } + var rep entity.MessageReport + if err := db.Where("detail_id = ?", d.ID).First(&rep).Error; err != nil { + t.Fatalf("message_report 未落库: %v", err) + } + if rep.Status != string(StatusSuccess) { + t.Fatalf("report.status=%s 期望 SUCCESS", rep.Status) + } +} + +// TestConsumer_SingleFailure 失败终态:detail→3,error_code=通道原始码。 +func TestConsumer_SingleFailure(t *testing.T) { + db := newConsumerDB(t) + c := NewConsumer(db) + d := mkDetail(t, db, 1, "13900002222", 1) + mid := mkSeg(t, db, d.ID, 7, "13900002222", 1, 1) + + if err := c.Process(testCtx, ev(7, mid, "UNDELIV", "13900002222")); err != nil { + t.Fatal(err) + } + got := getDetail(t, db, d.ID) + if got.Status != 3 || got.ErrorCode != "UNDELIV" { + t.Fatalf("status=%d code=%s 期望 3/UNDELIV", got.Status, got.ErrorCode) + } + var rep entity.MessageReport + if err := db.Where("detail_id = ?", d.ID).First(&rep).Error; err != nil { + t.Fatal(err) + } + if rep.Status != string(StatusFailure) { + t.Fatalf("report.status=%s 期望 FAILURE", rep.Status) + } +} + +// TestConsumer_NineSegAggregate 长短信 9 片段级聚合(验收主用例): +// 8 片 DELIVRD=挂起(detail 保持 1);第 9 片到齐=成功(2); +// 另一 9 片任务任一片 UNDELIV=失败(3)。 +func TestConsumer_NineSegAggregate(t *testing.T) { + db := newConsumerDB(t) + c := NewConsumer(db) + mobile := "13700003333" + d := mkDetail(t, db, 1, mobile, 1) + var mids []string + for pn := 1; pn <= 9; pn++ { + mids = append(mids, mkSeg(t, db, d.ID, 7, mobile, pn, 9)) + } + // 8 片成功:未到齐→挂起。 + for i := 0; i < 8; i++ { + if err := c.Process(testCtx, ev(7, mids[i], "DELIVRD", mobile)); err != nil { + t.Fatal(err) + } + } + if got := getDetail(t, db, d.ID); got.Status != 1 { + t.Fatalf("8/9 片应挂起(status=1),实际 %d", got.Status) + } + // 第 9 片到齐→成功(大小写空白容错同步验证)。 + if err := c.Process(testCtx, ev(7, mids[8], " DELIVRD ", mobile)); err != nil { + t.Fatal(err) + } + if got := getDetail(t, db, d.ID); got.Status != 2 { + t.Fatalf("9/9 片应成功(2),实际 %d", got.Status) + } + + // 第二任务:任一片失败→整条失败。 + d2 := mkDetail(t, db, 2, mobile, 1) + var mids2 []string + for pn := 1; pn <= 9; pn++ { + mids2 = append(mids2, mkSeg(t, db, d2.ID, 7, mobile, pn, 9)) + } + if err := c.Process(testCtx, ev(7, mids2[0], "DELIVRD", mobile)); err != nil { + t.Fatal(err) + } + if err := c.Process(testCtx, ev(7, mids2[3], "REJECTD", mobile)); err != nil { + t.Fatal(err) + } + got := getDetail(t, db, d2.ID) + if got.Status != 3 || got.ErrorCode != "REJECTD" { + t.Fatalf("任一片失败应整条失败(3/REJECTD),实际 %d/%s", got.Status, got.ErrorCode) + } +} + +// TestConsumer_UnknownPending UNKNOWN(中间态 GB:0001)不判终态:detail 保持 1。 +func TestConsumer_UnknownPending(t *testing.T) { + db := newConsumerDB(t) + c := NewConsumer(db) + d := mkDetail(t, db, 1, "13600004444", 1) + mid := mkSeg(t, db, d.ID, 7, "13600004444", 1, 1) + if err := c.Process(testCtx, ev(7, mid, "GB:0001", "13600004444")); err != nil { + t.Fatal(err) + } + if got := getDetail(t, db, d.ID); got.Status != 1 { + t.Fatalf("UNKNOWN 应挂起(status=1),实际 %d", got.Status) + } + var n int64 + db.Model(&entity.MessageReport{}).Where("detail_id = ?", d.ID).Count(&n) + if n != 0 { + t.Fatal("挂起不应写 message_report") + } +} + +// TestConsumer_FinalLocked 首到终态锁定:已成功(2)后再收 UNDELIV 不翻转。 +func TestConsumer_FinalLocked(t *testing.T) { + db := newConsumerDB(t) + c := NewConsumer(db) + d := mkDetail(t, db, 1, "13500005555", 2) + mid := mkSeg(t, db, d.ID, 7, "13500005555", 1, 1) + if err := c.Process(testCtx, ev(7, mid, "UNDELIV", "13500005555")); err != nil { + t.Fatal(err) + } + if got := getDetail(t, db, d.ID); got.Status != 2 { + t.Fatalf("终态锁定被破坏: %d", got.Status) + } +} + +// TestConsumer_UnpairedNoRetry 无配对段:返回 nil(不重试),挂起口径。 +func TestConsumer_UnpairedNoRetry(t *testing.T) { + db := newConsumerDB(t) + c := NewConsumer(db) + if err := c.Process(testCtx, ev(7, "404", "DELIVRD", "13000000000")); err != nil { + t.Fatalf("无配对应返回 nil(挂起不重试): %v", err) + } +} + +// TestConsumer_BatchMultiMobile 合包同 msg_id 多号:按 (msg_id,mobile) 独立置态。 +func TestConsumer_BatchMultiMobile(t *testing.T) { + db := newConsumerDB(t) + c := NewConsumer(db) + mos := []string{"13111110001", "13111110002"} + var ds []entity.MessageDetail + for _, mo := range mos { + ds = append(ds, mkDetail(t, db, 1, mo, 1)) + } + // 同一包 msg_id,两号各一段。 + for i, mo := range mos { + row := entity.MessageReportSeg{DetailID: ds[i].ID, ChannelID: 7, MsgID: "shared-1", Mobile: mo, PkNumber: 1, PkTotal: 1} + if err := db.Create(&row).Error; err != nil { + t.Fatal(err) + } + } + if err := c.Process(testCtx, ev(7, "shared-1", "DELIVRD", mos[0])); err != nil { + t.Fatal(err) + } + if err := c.Process(testCtx, ev(7, "shared-1", "EXPIRED", mos[1])); err != nil { + t.Fatal(err) + } + if got := getDetail(t, db, ds[0].ID); got.Status != 2 { + t.Fatalf("号1应成功: %d", got.Status) + } + if got := getDetail(t, db, ds[1].ID); got.Status != 3 { + t.Fatalf("号2应失败: %d", got.Status) + } +} + +// ---- Day 57:计费确认联动(msg_id 重复回执幂等主验收=A-5.2/A-5.3 零差额) ---- + +// TestConsumer_FailureRefundIdempotent 失败回执重复投递:detail 终态+退款 +// 恰一次(首到终态锁定=资金动作幂等锚;预扣-退款零差额)。 +func TestConsumer_FailureRefundIdempotent(t *testing.T) { + db := newBillingDB(t) + fs := &fakeStore{} + c := NewConsumer(db).WithBilling(NewBilling(db, fs)) + d := mkDetail(t, db, 1, "13222220001", 1) + mid := mkSeg(t, db, d.ID, 7, "13222220001", 1, 1) + for i := 0; i < 3; i++ { // 通道重推/重放三次 + if err := c.Process(testCtx, ev(7, mid, "UNDELIV", "13222220001")); err != nil { + t.Fatal(err) + } + } + if got := getDetail(t, db, d.ID); got.Status != 3 { + t.Fatalf("应失败终态: %d", got.Status) + } + if calls := fs.calls(); len(calls) != 1 { + t.Fatalf("重复回执应恰一次退款(msg_id 幂等),实得 %d 次: %+v", len(calls), calls) + } +} + +// TestConsumer_SuccessNoMoneyMove 成功回执:零资金动作(预扣=实扣半边)。 +func TestConsumer_SuccessNoMoneyMove(t *testing.T) { + db := newBillingDB(t) + fs := &fakeStore{} + c := NewConsumer(db).WithBilling(NewBilling(db, fs)) + d := mkDetail(t, db, 1, "13222220002", 1) + mid := mkSeg(t, db, d.ID, 7, "13222220002", 1, 1) + if err := c.Process(testCtx, ev(7, mid, "DELIVRD", "13222220002")); err != nil { + t.Fatal(err) + } + if got := getDetail(t, db, d.ID); got.Status != 2 { + t.Fatalf("应成功终态: %d", got.Status) + } + if calls := fs.calls(); len(calls) != 0 { + t.Fatalf("成功不应动钱,实得 %d 次: %+v", len(calls), calls) + } +} + +// TestConsumer_TaskCounterLinked 成功回执→task 聚合计数联动(覆写口径)。 +func TestConsumer_TaskCounterLinked(t *testing.T) { + db := newBillingDB(t) + if err := db.Create(&entity.MessageTask{ + ID: 3, TaskNo: "T57B", AccountID: 1, MobileCount: 2, Status: 1, + }).Error; err != nil { + t.Fatal(err) + } + c := NewConsumer(db).WithBilling(NewBilling(db, &fakeStore{})) + d := mkDetail(t, db, 3, "13222220003", 1) + mid := mkSeg(t, db, d.ID, 7, "13222220003", 1, 1) + if err := c.Process(testCtx, ev(7, mid, "DELIVRD", "13222220003")); err != nil { + t.Fatal(err) + } + if tk := getTask(t, db, 3); tk.SuccessCount != 1 || tk.UnknownCount != 0 { + t.Fatalf("task 计数联动错: %+v", tk) + } +} + +// TestConsumer_ConcurrentSegAggregate 并发聚合回归(Day 69 竞态修复): +// 同一 detail 两段回执并发 Process。sqlite 内存库每连接独立库,单连接 +// 强制串行——验证串行语义下"两段全到→恰终态一次+report 恰 1 条"; +// 真并发互不可见(MVCC)场景由生产 MySQL 的 detail 行 FOR UPDATE 串行 +// 化保障(consumer.go aggregate 锁,单测库不可复现该竞态)。 +func TestConsumer_ConcurrentSegAggregate(t *testing.T) { + db := newConsumerDB(t) + if sqlDB, err := db.DB(); err == nil { + sqlDB.SetMaxOpenConns(1) // :memory: 防串库;两 goroutine 事务排队串行 + } + c := NewConsumer(db) + mobile := "13700004444" + d := mkDetail(t, db, 3, mobile, 1) + m1 := mkSeg(t, db, d.ID, 9, mobile, 1, 2) + m2 := mkSeg(t, db, d.ID, 9, mobile, 2, 2) + + var wg sync.WaitGroup + errCh := make(chan error, 2) + for _, mid := range []string{m1, m2} { + wg.Add(1) + go func(mid string) { + defer wg.Done() + errCh <- c.Process(testCtx, ev(9, mid, "DELIVRD", mobile)) + }(mid) + } + wg.Wait() + close(errCh) + for err := range errCh { + if err != nil { + t.Fatal(err) + } + } + if got := getDetail(t, db, d.ID); got.Status != 2 { + t.Fatalf("两段全 DELIVRD 应到齐终态(2),实际 %d(挂起=聚合竞态回归)", got.Status) + } + var n int64 + db.Model(&entity.MessageReport{}).Where("detail_id = ?", d.ID).Count(&n) + if n != 1 { + t.Fatalf("message_report 应恰 1 条,实际 %d", n) + } +} + +// TestConsumer_RecheckPendingFinalizes 竞态双盲兜底回归(Day 69 二轮): +// 两段已全 SUCCESS 而 detail 仍挂起时,复查路径直接到齐终态——模拟并发 +// 簇最后提交者的 recheck 必见全部已提交段。(sqlite 单连接无法复现双盲 +// 交错,双盲时序由生产 MySQL 实机验证;复查路径本身在此锁定+幂等。) +func TestConsumer_RecheckPendingFinalizes(t *testing.T) { + db := newConsumerDB(t) + c := NewConsumer(db) + mobile := "13700005555" + d := mkDetail(t, db, 4, mobile, 1) + m1 := mkSeg(t, db, d.ID, 9, mobile, 1, 2) + m2 := mkSeg(t, db, d.ID, 9, mobile, 2, 2) + // 两段均已被"并发事务"置态 SUCCESS(模拟对方已提交、本方快照看不到)。 + if err := db.Model(&entity.MessageReportSeg{}).Where("msg_id IN ?", []string{m1, m2}). + Updates(map[string]any{"status": "SUCCESS", "raw_code": "DELIVRD"}).Error; err != nil { + t.Fatal(err) + } + if err := c.recheckPending(testCtx, ev(9, m1, "DELIVRD", mobile), StatusSuccess, time.Now()); err != nil { + t.Fatal(err) + } + if got := getDetail(t, db, d.ID); got.Status != 2 { + t.Fatalf("复查应到齐终态(2),实际 %d", got.Status) + } + var n int64 + db.Model(&entity.MessageReport{}).Where("detail_id = ?", d.ID).Count(&n) + if n != 1 { + t.Fatalf("message_report 应恰 1 条,实际 %d", n) + } + // 幂等:二次复查终态已锁——不翻转、不重报、不报错。 + if err := c.recheckPending(testCtx, ev(9, m2, "DELIVRD", mobile), StatusSuccess, time.Now()); err != nil { + t.Fatal(err) + } + if got := getDetail(t, db, d.ID); got.Status != 2 { + t.Fatalf("终态不应翻转,实际 %d", got.Status) + } + db.Model(&entity.MessageReport{}).Where("detail_id = ?", d.ID).Count(&n) + if n != 1 { + t.Fatalf("message_report 应仍 1 条,实际 %d", n) + } +} + +// TestConsumer_UnpairedRequeue 秒回竞态重投回归(Day 69 三轮):回执先于 +// 发送侧 seg 落库到达时 unpaired——短重投(计数透传+1)而非丢弃;重投后 +// seg 到位的二次消费正常配对终态(竞态自愈);耗尽按杂音丢弃;重投失败上抛。 +func TestConsumer_UnpairedRequeue(t *testing.T) { + db := newConsumerDB(t) + mobile := "13700006666" + d := mkDetail(t, db, 5, mobile, 1) + + var requeued []*Event + c := NewConsumer(db).WithRequeue(func(e *Event) error { + cp := *e + requeued = append(requeued, &cp) + return nil + }) + + // ① seg 未落库(竞态窗口):unpaired → 重投不丢弃,detail 保持挂起。 + e1 := ev(9, "race-1", "DELIVRD", mobile) + if err := c.Process(testCtx, e1); err != nil { + t.Fatal(err) + } + if len(requeued) != 1 || requeued[0].Retries != 1 { + t.Fatalf("应重投 1 次(Retries=1),实际 %v", requeued) + } + if got := getDetail(t, db, d.ID); got.Status != 1 { + t.Fatalf("seg 缺失时不应置态,实际 %d", got.Status) + } + + // ② 重投事件二次消费前 seg 已落库:正常配对(单段)直接终态=竞态自愈。 + mkSeg(t, db, d.ID, 9, mobile, 1, 1) // msg_id=m{d.ID}-01,与 race-1 不同—— + // 用真实 msg_id 再走一遍:重投载荷换为配对段号,模拟 seg 补登记后重放。 + segMid := fmt.Sprintf("m%d-01", d.ID) + e2 := ev(9, segMid, "DELIVRD", mobile) + e2.Retries = 1 + if err := c.Process(testCtx, e2); err != nil { + t.Fatal(err) + } + if got := getDetail(t, db, d.ID); got.Status != 2 { + t.Fatalf("seg 到位后应终态(2),实际 %d", got.Status) + } + + // ③ 重投耗尽(Retries=3):按杂音丢弃,不再重投、不报错。 + before := len(requeued) + e3 := ev(9, "noise-9", "DELIVRD", mobile) + e3.Retries = unpairedMaxRetries + if err := c.Process(testCtx, e3); err != nil { + t.Fatal(err) + } + if len(requeued) != before { + t.Fatalf("耗尽后不应重投,实际 %d 次", len(requeued)-before) + } + + // ④ 重投出口失败:上抛交消费组重试(消息不丢)。 + cFail := NewConsumer(db).WithRequeue(func(e *Event) error { return fmt.Errorf("kafka down") }) + if err := cFail.Process(testCtx, ev(9, "race-2", "DELIVRD", mobile)); err == nil { + t.Fatal("重投失败应上抛") + } +} diff --git a/internal/service/report/deliver_push.go b/internal/service/report/deliver_push.go new file mode 100644 index 00000000..867f0c48 --- /dev/null +++ b/internal/service/report/deliver_push.go @@ -0,0 +1,138 @@ +// deliver_push.go Day 61(P0.5):CMPP 协议客户回执下发桥——report 终态锁定后 +// 将「平台 MsgID 口径」的状态报告事件投递 cmpp-deliver,由 gateway 进程的 +// 协议接入侧消费并 PushDeliver 到客户活跃连接(跨进程经 Kafka 解耦: +// 回执消费在 consumer 进程,CMPP 会话在 gateway 进程)。 +package report + +import ( + "context" + "encoding/json" + "fmt" + "time" + + "go.uber.org/zap" + "gorm.io/gorm" + + "go-sms/internal/pkg/logger" + "go-sms/internal/pkg/queue" + "go-sms/internal/service/send" +) + +// DeliverEvent CMPP Deliver 下发事件(cmpp-deliver 载荷)。 +// MsgID 口径=平台明细 ID(detail snowflake)——与客户 Submit_Resp 收到的 +// MsgID 一致,客户端据此对账(上游 msg_id 不出 report 域)。 +type DeliverEvent struct { + AccountID int64 `json:"account_id"` + DetailID int64 `json:"detail_id"` + Mobile string `json:"mobile"` + Stat string `json:"stat"` // CMPP stat:DELIVRD/上游原始码/UNKNOWN + SubmitAt string `json:"submit_at"` // MMDDHHMMSS + DoneAt string `json:"done_at"` // MMDDHHMMSS +} + +// PushSink 回执下发出口(装配层注入 Kafka 生产者;nil=不下发,HTTP/控制台来源天然静默)。 +type PushSink interface { + PushDeliver(ctx context.Context, ev *DeliverEvent) error +} + +// ProducerPushSink queue.Producer 适配器(投 cmpp-deliver;失败仅 Warn—— +// 终态已锁定不回滚,下发尽力而为,离线/失败补推属 P1)。 +type ProducerPushSink struct { + P interface { + Send(topic string, key, value []byte) error + } + Topic string // 空=queue.TopicDeliver +} + +// PushDeliver 投递下发事件(key=账号 ID 保序)。 +func (s *ProducerPushSink) PushDeliver(ctx context.Context, ev *DeliverEvent) error { + if s.P == nil || ev == nil { + return nil + } + topic := s.Topic + if topic == "" { + topic = queue.TopicDeliver + } + value, err := json.Marshal(ev) + if err != nil { + return err + } + if err := s.P.Send(topic, []byte(fmt.Sprintf("%d", ev.AccountID)), value); err != nil { + logger.L().Warn("cmpp_deliver_push_send_failed", + zap.Int64("account_id", ev.AccountID), zap.Int64("detail_id", ev.DetailID), zap.Error(err)) + return err + } + return nil +} + +// StatForBlocked Day62c:受理期拦截终态 error_code→CMPP stat 映射(公开供装配适配)。 +// 签名拦截=SIGNREJ(7B 自释义);其余拦截码透传截 7B;空兜底 UNDELIV +// (语义=未下发而非未知,与上游回执 UNKNOWN 区分)。 +func StatForBlocked(errCode string) string { + switch errCode { + case "ISC:004": + return "SIGNREJ" + case "": + return "UNDELIV" + } + if r := []rune(errCode); len(r) > 7 { + return string(r[:7]) + } + return errCode +} + +// statForDeliver 平台明细终态(int8:2=成功 3=失败 4=未知)→CMPP stat 映射: +// 成功=DELIVRD(标准词);失败/未知优先透传上游原始码(UNDELIV/EXPIRED/GB:xxxx…; +// 超长截 7B),兜底 UNKNOWN(补偿结案无原始码场景)。 +func statForDeliver(status int8, rawCode string) string { + if status == 2 { // entity.MessageDetail 终态:2=成功 + return "DELIVRD" + } + code := rawCode + if r := []rune(code); len(r) > 7 { + code = string(r[:7]) + } + if code == "" { + code = "UNKNOWN" + } + return code +} + +// cmppTimeMMDDHHMMSS CMPP 状态报告时间格式(MMDDHHMMSS)。 +func cmppTimeMMDDHHMMSS(t time.Time) string { return t.Format("0102150405") } + +// pushDeliverLocked 终态锁定成功后的下发挂接(仅 CMPP 来源任务;阶段5收尾起 +// 为包级函数——Consumer 回执链与手动配对 PairService 共用): +// 联查 detail.account_id + task.source,source=CMPP 才投事件—— +// HTTP/控制台任务无活跃 CMPP 会话,零开销短路。 +func pushDeliverLocked(ctx context.Context, db *gorm.DB, push PushSink, detailID int64, + status int8, rawCode, mobile string, now time.Time) { + if push == nil { + return + } + var row struct { + AccountID int64 + Source int8 + } + if err := db.WithContext(ctx). + Table("message_detail AS d"). + Select("d.account_id AS account_id, t.source AS source"). + Joins("JOIN message_task t ON t.id = d.task_id"). + Where("d.id = ?", detailID). + Take(&row).Error; err != nil { + logger.L().Warn("cmpp_deliver_source_lookup_failed", zap.Int64("detail_id", detailID), zap.Error(err)) + return + } + if row.Source != send.TaskSourceCMPP { + return // 非 CMPP 来源:无协议侧下发诉求 + } + ev := &DeliverEvent{ + AccountID: row.AccountID, DetailID: detailID, Mobile: mobile, + Stat: statForDeliver(status, rawCode), + SubmitAt: cmppTimeMMDDHHMMSS(now), DoneAt: cmppTimeMMDDHHMMSS(now), + } + if err := push.PushDeliver(ctx, ev); err != nil { + // 已 Warn;终态不回滚(下发失败不影响对账事实源)。 + return + } +} diff --git a/internal/service/report/deliver_push_test.go b/internal/service/report/deliver_push_test.go new file mode 100644 index 00000000..5062c4fd --- /dev/null +++ b/internal/service/report/deliver_push_test.go @@ -0,0 +1,48 @@ +// deliver_push_test.go Day 61:stat 映射与时间格式纯函数测试。 +package report + +import ( + "testing" + "time" +) + +// TestStatForBlocked Day62c:拦截终态 stat 映射(ISC:004→SIGNREJ/空→UNDELIV/超长截 7B)。 +func TestStatForBlocked(t *testing.T) { + cases := []struct{ in, want string }{ + {"ISC:004", "SIGNREJ"}, + {"", "UNDELIV"}, + {"ISC:009", "ISC:009"}, + {"GB:0001:黑名单", "GB:0001"}, + } + for _, c := range cases { + if got := StatForBlocked(c.in); got != c.want { + t.Fatalf("StatForBlocked(%q)=%q want %q", c.in, got, c.want) + } + } +} + +func TestStatForDeliver(t *testing.T) { + cases := []struct { + status int8 + raw string + want string + }{ + {2, "DELIVRD", "DELIVRD"}, // 成功→标准词 + {3, "UNDELIV", "UNDELIV"}, // 失败→透传原始码 + {3, "GB:0001:缺失", "GB:0001"}, // 超长截 7B + {4, "", "UNKNOWN"}, // 兜底 + {3, "", "UNKNOWN"}, // 兜底 + } + for _, c := range cases { + if got := statForDeliver(c.status, c.raw); got != c.want { + t.Fatalf("statForDeliver(%d,%q)=%q want %q", c.status, c.raw, got, c.want) + } + } +} + +func TestCmppTimeMMDDHHMMSS(t *testing.T) { + ts := time.Date(2026, 9, 14, 18, 10, 33, 0, time.Local) + if got := cmppTimeMMDDHHMMSS(ts); got != "0914181033" { + t.Fatalf("时间格式=%q", got) + } +} diff --git a/internal/service/report/errorcode.go b/internal/service/report/errorcode.go new file mode 100644 index 00000000..a8ca4533 --- /dev/null +++ b/internal/service/report/errorcode.go @@ -0,0 +1,136 @@ +// errorcode.go Day 56:错误码维护(system_error_code 增改停用,A-5.x 运维 +// 接口服务层)。表结构=v1 种子既有(UT:xxxx 体系:code 唯一/name/raw_value/ +// action 处置策略/status 启停);本层只做 CRUD 校验,消费者归一化仍走 +// Day55 纯函数词表(两域解耦:词表判三态,本表管运维语义)。 +package report + +import ( + "context" + "errors" + "strings" + + "go-sms/internal/model/entity" + errs "go-sms/internal/pkg/errors" + + "gorm.io/gorm" +) + +// 错误码处置策略合法域(与实体注释对齐:0 失败 1 重发 2 入审)。 +var validActions = map[int8]bool{0: true, 1: true, 2: true} + +// ErrCodeNotFound 错误码不存在(包装 ISC:404)。 +var ErrCodeNotFound = errs.NotFound.WithMsg("错误码不存在") + +// ErrorCodeService 错误码维护服务。 +type ErrorCodeService struct{ db *gorm.DB } + +// NewErrorCodeService 构造。 +func NewErrorCodeService(db *gorm.DB) *ErrorCodeService { return &ErrorCodeService{db: db} } + +// ErrorCodeQuery 列表筛选(分页;code 前缀/name 模糊/status 精确)。 +type ErrorCodeQuery struct { + Page, PageSize int + Code string // 前缀匹配(UT:0 前缀检索) + Name string // 模糊 + Status *int8 // 1 启用 0 停用(nil=全部) +} + +// List 分页查询(code 升序稳定序)。 +func (s *ErrorCodeService) List(ctx context.Context, q ErrorCodeQuery) ([]entity.SystemErrorCode, int64, error) { + tx := s.db.WithContext(ctx).Model(&entity.SystemErrorCode{}) + if code := strings.TrimSpace(q.Code); code != "" { + tx = tx.Where("code LIKE ?", code+"%") + } + if name := strings.TrimSpace(q.Name); name != "" { + tx = tx.Where("name LIKE ?", "%"+name+"%") + } + if q.Status != nil { + tx = tx.Where("status = ?", *q.Status) + } + if q.Page <= 0 { + q.Page = 1 + } + if q.PageSize <= 0 || q.PageSize > 200 { + q.PageSize = 50 + } + var total int64 + if err := tx.Count(&total).Error; err != nil { + return nil, 0, err + } + var rows []entity.SystemErrorCode + if err := tx.Order("code ASC").Offset((q.Page - 1) * q.PageSize).Limit(q.PageSize). + Find(&rows).Error; err != nil { + return nil, 0, err + } + return rows, total, nil +} + +// Create 新增(code 唯一;重复返回 ISC:冲突语义错误)。 +func (s *ErrorCodeService) Create(ctx context.Context, code, name, rawValue string, action int8) (*entity.SystemErrorCode, error) { + code = strings.TrimSpace(code) + name = strings.TrimSpace(name) + if code == "" || len(code) > 16 { + return nil, errs.InvalidParam.WithMsg("code 必填且 ≤16 字符") + } + if name == "" || len(name) > 64 { + return nil, errs.InvalidParam.WithMsg("name 必填且 ≤64 字符") + } + if !validActions[action] { + return nil, errs.InvalidParam.WithMsg("action 非法(0 失败/1 重发/2 入审)") + } + var dup int64 + if err := s.db.WithContext(ctx).Model(&entity.SystemErrorCode{}). + Where("code = ?", code).Count(&dup).Error; err != nil { + return nil, err + } + if dup > 0 { + return nil, errs.InvalidParam.WithMsg("错误码已存在: " + code) + } + row := entity.SystemErrorCode{ + Code: code, Name: name, RawValue: strings.TrimSpace(rawValue), + Action: action, Status: 1, + } + if err := s.db.WithContext(ctx).Create(&row).Error; err != nil { + return nil, err + } + return &row, nil +} + +// Update 修改(name/raw_value/action/status;status=0 即停用——停用后 +// 不再参与拦截/重发策略,历史记录保留)。 +func (s *ErrorCodeService) Update(ctx context.Context, id int64, name, rawValue string, action int8, status int8) (*entity.SystemErrorCode, error) { + name = strings.TrimSpace(name) + if name == "" || len(name) > 64 { + return nil, errs.InvalidParam.WithMsg("name 必填且 ≤64 字符") + } + if !validActions[action] { + return nil, errs.InvalidParam.WithMsg("action 非法(0 失败/1 重发/2 入审)") + } + if status != 0 && status != 1 { + return nil, errs.InvalidParam.WithMsg("status 非法(1 启用/0 停用)") + } + res := s.db.WithContext(ctx).Model(&entity.SystemErrorCode{}). + Where("id = ?", id). + Updates(map[string]any{ + "name": name, "raw_value": strings.TrimSpace(rawValue), + "action": action, "status": status, + }) + if res.Error != nil { + return nil, res.Error + } + if res.RowsAffected == 0 { + var n int64 + _ = s.db.WithContext(ctx).Model(&entity.SystemErrorCode{}).Where("id = ?", id).Count(&n).Error + if n == 0 { + return nil, ErrCodeNotFound + } + } + var row entity.SystemErrorCode + if err := s.db.WithContext(ctx).First(&row, id).Error; err != nil { + if errors.Is(err, gorm.ErrRecordNotFound) { + return nil, ErrCodeNotFound + } + return nil, err + } + return &row, nil +} diff --git a/internal/service/report/errorcode_test.go b/internal/service/report/errorcode_test.go new file mode 100644 index 00000000..4fb39376 --- /dev/null +++ b/internal/service/report/errorcode_test.go @@ -0,0 +1,84 @@ +// errorcode_test.go Day 56:错误码维护单测——增(重复拒绝)/改/停用/列表筛选。 +package report + +import ( + "testing" + + "github.com/glebarez/sqlite" + "gorm.io/gorm" + "gorm.io/gorm/logger" + + "go-sms/internal/model/entity" +) + +func newErrCodeDB(t *testing.T) *gorm.DB { + t.Helper() + db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{Logger: logger.Discard}) + if err != nil { + t.Fatalf("打开内存库失败: %v", err) + } + if err := db.AutoMigrate(&entity.SystemErrorCode{}); err != nil { + t.Fatalf("AutoMigrate 失败: %v", err) + } + return db +} + +func TestErrorCode_CRUD(t *testing.T) { + db := newErrCodeDB(t) + s := NewErrorCodeService(db) + + // 增。 + row, err := s.Create(testCtx, "UT:9001", "网关超时", "GB:0008", 1) + if err != nil { + t.Fatal(err) + } + if row.Status != 1 || row.Action != 1 { + t.Fatalf("新增字段错误: %+v", row) + } + // 重复 code 拒绝。 + if _, err := s.Create(testCtx, "UT:9001", "dup", "", 0); err == nil { + t.Fatal("重复 code 应拒绝") + } + // 非法 action 拒绝。 + if _, err := s.Create(testCtx, "UT:9002", "bad", "", 9); err == nil { + t.Fatal("非法 action 应拒绝") + } + + // 改(语义修订)。 + upd, err := s.Update(testCtx, row.ID, "网关超时(可重发)", "GB:0008", 1, 1) + if err != nil { + t.Fatal(err) + } + if upd.Name != "网关超时(可重发)" { + t.Fatalf("改名未生效: %s", upd.Name) + } + // 停用。 + off, err := s.Update(testCtx, row.ID, "网关超时(可重发)", "GB:0008", 1, 0) + if err != nil { + t.Fatal(err) + } + if off.Status != 0 { + t.Fatalf("停用未生效: %d", off.Status) + } + + // 列表筛选:code 前缀+status。 + if _, err := s.Create(testCtx, "UT:9003", "停用样例", "", 0); err != nil { + t.Fatal(err) + } + rows, total, err := s.List(testCtx, ErrorCodeQuery{Code: "UT:9", Status: nil}) + if err != nil || total != 2 { + t.Fatalf("前缀筛选: total=%d err=%v", total, err) + } + if len(rows) != 2 { + t.Fatalf("前缀筛选行数: %d", len(rows)) + } + st0 := int8(0) + rows, total, err = s.List(testCtx, ErrorCodeQuery{Status: &st0}) + if err != nil || total != 1 || len(rows) != 1 { + t.Fatalf("status 筛选: total=%d err=%v", total, err) + } + // 不存在 id 更新→404 语义。 + if _, err := s.Update(testCtx, 9999, "x", "", 0, 1); err == nil { + t.Fatal("不存在 id 应报错") + } +} diff --git a/internal/service/report/normalize.go b/internal/service/report/normalize.go new file mode 100644 index 00000000..c3df60d4 --- /dev/null +++ b/internal/service/report/normalize.go @@ -0,0 +1,45 @@ +// normalize.go Day55:回执状态归一化起步(Day56 回执消费者地基)。 +// 通道原始 stat(CMPP Deliver Receipt)→平台三态 SUCCESS/FAILURE/UNKNOWN: +// - SUCCESS:DELIVRD(成功送达); +// - FAILURE:明确失败终态(EXPIRED 消息过期/UNDELIV 无法投递/REJECTD 短信拒收 +// 等——按词表判定,命中即失败,计费按失败退费口径); +// - UNKNOWN:空/未识别/网关中间态(如 GB:0xxx 处理中)——挂起等补偿扫描, +// 不计成功也不退费(资损安全方向:宁可挂起不可错判)。 +// +// 归一化纯函数、表驱动,消费者/错误码维护接口(Day56)共用同一张表。 +package report + +import "strings" + +// Status 平台回执三态(阶段 5 状态机口径)。 +type Status string + +const ( + StatusSuccess Status = "SUCCESS" + StatusFailure Status = "FAILURE" + StatusUnknown Status = "UNKNOWN" +) + +// Normalize 通道原始 stat→平台三态(大小写不敏感;空串=UNKNOWN)。 +func Normalize(stat string) Status { + s := strings.ToUpper(strings.TrimSpace(stat)) + switch s { + case "": + return StatusUnknown + case "DELIVRD": + return StatusSuccess + case "EXPIRED", "UNDELIV", "REJECTD", "DELETED", "ACCEPTD_FAIL", "FAILED": + // DELETED:已删除(运营商侧终态失败);ACCEPTD_FAIL/FAILED:虚拟上游/聚合器 + // 常见失败词(防御收录,未知词默认 UNKNOWN 兜底不受影响)。 + return StatusFailure + default: + // 未识别:含中间态(GB:0001 等)与未知错误码——UNKNOWN 挂起。 + return StatusUnknown + } +} + +// IsFinal 终态判定(UNKNOWN 非终态:补偿扫描窗口后仍无回执才转 UNKNOWN 结案, +// 与 reclaim 三重域口径一致)。 +func IsFinal(stat string) bool { + return Normalize(stat) != StatusUnknown +} diff --git a/internal/service/report/normalize_test.go b/internal/service/report/normalize_test.go new file mode 100644 index 00000000..23c862c0 --- /dev/null +++ b/internal/service/report/normalize_test.go @@ -0,0 +1,37 @@ +// normalize_test.go Day55:回执状态归一化表驱动测试(Day56 消费者地基)。 +package report + +import "testing" + +func TestNormalize(t *testing.T) { + cases := []struct { + stat string + want Status + why string + }{ + {"DELIVRD", StatusSuccess, "CMPP 标准成功"}, + {"delivrd", StatusSuccess, "大小写不敏感"}, + {" DelIVRd ", StatusSuccess, "容忍空白"}, + {"EXPIRED", StatusFailure, "消息过期"}, + {"UNDELIV", StatusFailure, "无法投递"}, + {"REJECTD", StatusFailure, "短信拒收"}, + {"DELETED", StatusFailure, "已删除终态"}, + {"", StatusUnknown, "空回执挂起"}, + {"GB:0001", StatusUnknown, "中间态非终态"}, + {"ID:0088", StatusUnknown, "未识别错误码挂起"}, + } + for _, c := range cases { + if got := Normalize(c.stat); got != c.want { + t.Errorf("Normalize(%q)=%v want %v(%s)", c.stat, got, c.want, c.why) + } + } +} + +func TestIsFinal(t *testing.T) { + if !IsFinal("DELIVRD") || !IsFinal("EXPIRED") { + t.Error("成功/失败应为终态") + } + if IsFinal("") || IsFinal("GB:0001") { + t.Error("空/中间态应非终态(挂起等补偿)") + } +} diff --git a/internal/service/report/pair.go b/internal/service/report/pair.go new file mode 100644 index 00000000..d152b14e --- /dev/null +++ b/internal/service/report/pair.go @@ -0,0 +1,380 @@ +// pair.go 阶段 5 收尾(Day58 挂账清偿/D28):回执重推与手动配对服务。 +// - Pending:挂起明细分页(status=1 且挂起超 3h,实施计划 5.5 可配对口径)—— +// 手动配对页数据源;msg_id 取该明细首段(message_report_seg MIN)。 +// - Pair:四方式(msg_mobile/detail/task_time/time_mobile)圈中挂起明细→ +// 人工指定终态(2 成功/3 失败退款/4 未知释放);终态链复用 finalizeDetail +// 单一实现(首锁回写+message_report 落库+计费确认+CMPP Deliver 推送), +// 与回执消费者行为零漂移——重复配对走锁定跳过分支,资金动作至多一次。 +// - Repush:30 天窗口回执重推——命中行重投 DeliverEvent(与首推同口径)+ +// push_status 回写;同步执行(dev 命中千级内;异步任务表挂账 D29 下载中心)。 +package report + +import ( + "context" + "errors" + "fmt" + "time" + + "go.uber.org/zap" + "gorm.io/gorm" + + "go-sms/internal/pkg/logger" + "go-sms/internal/util" +) + +// PairPendingWindow 手动配对可用窗口:挂起超 3h(实施计划 5.5 口径)。 +const PairPendingWindow = 3 * time.Hour + +// RepushWindowDays 回执重推数据源保留窗口(message_report 30 天)。 +const RepushWindowDays = 30 + +// RepushBatchMax 单次重推执行上限(同步执行保护;超出记日志截断)。 +const RepushBatchMax = 1000 + +// ErrPairParam 配对/重推参数错误(handler 映射 ISC:400)。 +var ErrPairParam = errors.New("pair/repush param") + +// PairQuery 挂起明细查询(配对页列表)。 +type PairQuery struct { + Page, PageSize int64 + Mobile string // 尾号模糊 + TaskNo string // 精确 +} + +// PairPendingRow 挂起明细行(契约 web/src/api/record.ts PendingDetail)。 +type PairPendingRow struct { + DetailID int64 + TaskNo string + MsgID string // 通道 msg_id(该明细首段;msg_mobile 配对键) + Mobile string + Content string + SentAt time.Time + AgeHours int64 +} + +// PairRequest 手动配对请求(四方式,按 mode 取对应字段)。 +type PairRequest struct { + Mode string // msg_mobile|detail|task_time|time_mobile + MsgID string // msg_mobile:通道 msg_id + Mobile string // msg_mobile/time_mobile + DetailID int64 // detail:明细雪花 ID 精确 + TaskNo string // task_time + Start, End *time.Time + TargetStatus int8 // 2 成功(不退费)/3 失败(退款)/4 未知(冻结释放) +} + +// PairResult 配对结果(matched=圈中挂起;updated=首锁回写;skipped=并发已终态)。 +type PairResult struct { + Matched int64 `json:"matched"` + Updated int64 `json:"updated"` + Skipped int64 `json:"skipped"` +} + +// RepushRequest 回执重推请求(时间窗必填;账号/手机号收窄)。 +type RepushRequest struct { + AccountID int64 + Mobiles []string + Start, End time.Time +} + +// PairService 回执重推+手动配对(gateway 进程装配;db/bill/push 与 Consumer 同构)。 +type PairService struct { + db *gorm.DB + bill *Billing + push PushSink + sf *util.Snowflake // 重推受理号(雪花;D29 异步任务表落地后即任务主键) +} + +// NewPairService 构造(bill/push 可为 nil=跳过计费/推送;sf 可为 nil=受理号降级时间戳)。 +func NewPairService(db *gorm.DB, bill *Billing, sf *util.Snowflake) *PairService { + return &PairService{db: db, bill: bill, sf: sf} +} + +// WithPushSink 注入 CMPP Deliver 下发出口(链式,nil=跳过)。 +func (p *PairService) WithPushSink(s PushSink) *PairService { + p.push = s + return p +} + +// DB 裸查询出口(handler 回执分页 JOIN 查询复用同一连接)。 +func (p *PairService) DB() *gorm.DB { return p.db } + +// pendingScope 挂起明细基础口径(status=1 且 COALESCE(send_at,created_at) 早于 now-3h)。 +func (p *PairService) pendingScope(ctx context.Context) *gorm.DB { + return p.db.WithContext(ctx). + Table("message_detail AS d"). + Where("d.status = 1 AND COALESCE(d.send_at, d.created_at) < ?", + time.Now().Add(-PairPendingWindow)) +} + +// Pending 挂起明细分页(挂起久在前;msg_id=该明细首段,长短信代表值)。 +func (p *PairService) Pending(ctx context.Context, q PairQuery) ([]PairPendingRow, int64, error) { + page, size := q.Page, q.PageSize + if page < 1 { + page = 1 + } + if size < 1 || size > 1000 { + size = 100 + } + scope := p.pendingScope(ctx). + Joins("JOIN message_task t ON t.id = d.task_id") + if q.Mobile != "" { + scope = scope.Where("d.mobile LIKE ?", "%"+q.Mobile) + } + if q.TaskNo != "" { + scope = scope.Where("t.task_no = ?", q.TaskNo) + } + // Count 独立构造:列表查询带 ORDER BY 别名(sent_at),Count 继承会在 + // sqlite 报 no such column(gorm 不剥离 ORDER BY)。 + var total int64 + cnt := p.pendingScope(ctx). + Joins("JOIN message_task t ON t.id = d.task_id") + if q.Mobile != "" { + cnt = cnt.Where("d.mobile LIKE ?", "%"+q.Mobile) + } + if q.TaskNo != "" { + cnt = cnt.Where("t.task_no = ?", q.TaskNo) + } + if err := cnt.Session(&gorm.Session{}).Count(&total).Error; err != nil { + return nil, 0, err + } + var rows []struct { + DetailID int64 + TaskNo string + MsgID *string + Mobile string + Content string + SentAt string // sqlite 下 COALESCE 结果退化 string(MySQL 侧兼容),Go 侧解析 + } + if err := scope.Session(&gorm.Session{}). + Select(`d.id AS detail_id, t.task_no AS task_no, + (SELECT MIN(s2.msg_id) FROM message_report_seg s2 WHERE s2.detail_id = d.id) AS msg_id, + d.mobile AS mobile, d.content AS content, + COALESCE(d.send_at, d.created_at) AS sent_at`). + Order("sent_at ASC"). + Limit(int(size)).Offset(int((page - 1) * size)). + Scan(&rows).Error; err != nil { + return nil, 0, err + } + parseSentAt := func(s string) time.Time { + for _, layout := range []string{time.RFC3339Nano, time.RFC3339, + "2006-01-02 15:04:05.999999999-07:00", "2006-01-02 15:04:05.999999999", "2006-01-02 15:04:05"} { + if t, err := time.ParseInLocation(layout, s, time.Local); err == nil { + return t + } + } + return time.Time{} + } + now := time.Now() + out := make([]PairPendingRow, 0, len(rows)) + for _, r := range rows { + msgID := "" + if r.MsgID != nil { + msgID = *r.MsgID + } + sentAt := parseSentAt(r.SentAt) + var age int64 + if !sentAt.IsZero() { + age = int64(now.Sub(sentAt).Hours()) + } + out = append(out, PairPendingRow{ + DetailID: r.DetailID, TaskNo: r.TaskNo, MsgID: msgID, + Mobile: r.Mobile, Content: r.Content, SentAt: sentAt, + AgeHours: age, + }) + } + return out, total, nil +} + +// statusFor 终态 int8 → Day55 三态词。 +func statusFor(status int8) Status { + switch status { + case 2: + return StatusSuccess + case 3: + return StatusFailure + default: + return StatusUnknown + } +} + +// Pair 手动配对:四方式圈中挂起明细→逐条 finalizeDetail(首锁语义, +// 重复配对/并发终态走锁定跳过=skipped;资金动作至多一次)。 +func (p *PairService) Pair(ctx context.Context, req PairRequest) (PairResult, error) { + // 受理即落账(与 Repush 同口径):断开不中止终态链;单条事务原子性 + // 由 gorm 保证,重试幂等(首锁跳过)。 + ctx = context.WithoutCancel(ctx) + var res PairResult + switch req.Mode { + case "msg_mobile", "detail", "task_time", "time_mobile": + default: + return res, fmt.Errorf("%w: 配对方式非法", ErrPairParam) + } + if req.TargetStatus < 2 || req.TargetStatus > 4 { + return res, fmt.Errorf("%w: 目标状态须为 2/3/4", ErrPairParam) + } + scope := p.pendingScope(ctx) + switch req.Mode { + case "msg_mobile": + if req.MsgID == "" || req.Mobile == "" { + return res, fmt.Errorf("%w: msg_id/mobile 必填", ErrPairParam) + } + scope = scope.Where( + "d.id IN (SELECT s.detail_id FROM message_report_seg s WHERE s.msg_id = ? AND s.mobile = ?)", + req.MsgID, req.Mobile) + case "detail": + if req.DetailID <= 0 { + return res, fmt.Errorf("%w: detail_id 非法", ErrPairParam) + } + scope = scope.Where("d.id = ?", req.DetailID) + case "task_time": + if req.TaskNo == "" { + return res, fmt.Errorf("%w: task_no 必填", ErrPairParam) + } + var taskID int64 + if err := p.db.WithContext(ctx). + Table("message_task").Select("id"). + Where("task_no = ?", req.TaskNo).Scan(&taskID).Error; err != nil || taskID == 0 { + return res, fmt.Errorf("%w: 任务号不存在", ErrPairParam) + } + scope = scope.Where("d.task_id = ?", taskID) + default: // time_mobile + if req.Mobile == "" { + return res, fmt.Errorf("%w: mobile 必填", ErrPairParam) + } + scope = scope.Where("d.mobile = ?", req.Mobile) + } + if req.Mode == "task_time" || req.Mode == "time_mobile" { + if req.Start != nil { + scope = scope.Where("COALESCE(d.send_at, d.created_at) >= ?", *req.Start) + } + if req.End != nil { + scope = scope.Where("COALESCE(d.send_at, d.created_at) <= ?", *req.End) + } + } + var ids []int64 + if err := scope.Limit(1000).Pluck("d.id", &ids).Error; err != nil { + return res, err + } + res.Matched = int64(len(ids)) + st := statusFor(req.TargetStatus) + now := time.Now() + for _, id := range ids { + var d struct { + ChannelID int64 + Mobile string + } + if err := p.db.WithContext(ctx).Table("message_detail"). + Select("channel_id, mobile").Where("id = ?", id).Scan(&d).Error; err != nil { + continue // 行消失(并发删除等):计入 skipped + } + locked, err := finalizeDetail(ctx, p.db, p.push, + id, d.ChannelID, req.TargetStatus, "MANUAL", now, st, d.Mobile) + if err != nil { + logger.L().Warn("pair_finalize_failed", + zap.Int64("detail_id", id), zap.Error(err)) + res.Skipped++ + continue + } + if locked { + res.Updated++ + // 计费确认在终态锁定成功后触发(与 Consumer 回执链同语义)。 + if p.bill != nil { + p.bill.Confirm(ctx, id, req.TargetStatus) + } + } else { + res.Skipped++ // 圈中窗口与执行窗口间被回执/并发配对锁定 + } + } + return res, nil +} + +// statusInt8From 三态词 → 终态 int8(重推反向映射)。 +func statusInt8From(s string) int8 { + switch s { + case string(StatusSuccess): + return 2 + case string(StatusFailure): + return 3 + default: + return 4 + } +} + +// Repush 30 天窗口回执重推:命中 report 行(detail JOIN 取 account/mobile)→ +// 重投 DeliverEvent(与首推同 payload 口径)→ push_status/pushed_at 回写。 +// 同步执行并返回 (受理号, 命中数);受理号雪花生成(D29 任务表落地后即任务主键)。 +func (p *PairService) Repush(ctx context.Context, req RepushRequest) (int64, int64, error) { + // 受理即落账:执行段脱离请求取消链(客户端超时断开不中止投递/回写, + // Day66 实机验收发现逐条回写随 ctx canceled 全部丢失)。 + ctx = context.WithoutCancel(ctx) + sess := p.db.WithContext(ctx). + Table("message_report AS r"). + Select("r.id AS report_id, r.detail_id, r.status, r.raw_code, d.account_id, d.mobile"). + Joins("JOIN message_detail d ON d.id = r.detail_id"). + Where("r.report_at >= ? AND r.report_at <= ?", req.Start, req.End) + if req.AccountID > 0 { + sess = sess.Where("d.account_id = ?", req.AccountID) + } + if len(req.Mobiles) > 0 { + sess = sess.Where("d.mobile IN ?", req.Mobiles) + } + var rows []struct { + ReportID int64 + DetailID int64 + Status string + RawCode string + AccountID int64 + Mobile string + } + if err := sess.Limit(RepushBatchMax + 1).Scan(&rows).Error; err != nil { + return 0, 0, err + } + if int64(len(rows)) > RepushBatchMax { + rows = rows[:RepushBatchMax] + logger.L().Warn("repush_batch_truncated", + zap.Int("cap", RepushBatchMax), zap.String("hint", "收窄时间窗/账号分批重推")) + } + now := time.Now() + // 批量回写:投递与回写按结果分组,2 次批量 UPDATE 替代逐条往返(千条窗 + // 25s+ → 秒级);失败仅记日志不中断(重推幂等:重复圈中重投无害)。 + pushed, failed := make([]int64, 0, len(rows)), make([]int64, 0, len(rows)) + for _, r := range rows { + ev := &DeliverEvent{ + AccountID: r.AccountID, DetailID: r.DetailID, Mobile: r.Mobile, + Stat: statForDeliver(statusInt8From(r.Status), r.RawCode), + SubmitAt: cmppTimeMMDDHHMMSS(now), DoneAt: cmppTimeMMDDHHMMSS(now), + } + // 注:重推不做 source=CMPP 短路——操作者圈中的即需重推的 + //(非 CMPP 源投递后网关消费侧按账号反查无会话自然丢弃,尽力而为同首推口径)。 + var pushErr error + if p.push != nil { + pushErr = p.push.PushDeliver(ctx, ev) + } + if pushErr != nil { + failed = append(failed, r.ReportID) + } else { + pushed = append(pushed, r.ReportID) + } + } + writeback := func(ids []int64, ps int8) { + if len(ids) == 0 { + return + } + if err := p.db.WithContext(ctx). + Table("message_report").Where("id IN ?", ids). + Updates(map[string]any{"push_status": ps, "pushed_at": now}).Error; err != nil { + logger.L().Warn("repush_status_writeback_failed", + zap.Int("count", len(ids)), zap.Int8("push_status", ps), zap.Error(err)) + } + } + writeback(pushed, 1) + writeback(failed, 2) + var taskID int64 + if p.sf != nil { + taskID = p.sf.NextID() + } else { + taskID = now.UnixMilli() + } + return taskID, int64(len(rows)), nil +} diff --git a/internal/service/report/sink.go b/internal/service/report/sink.go new file mode 100644 index 00000000..dcb3866e --- /dev/null +++ b/internal/service/report/sink.go @@ -0,0 +1,62 @@ +// sink.go Day 56:回执入口——通道 Deliver 状态报告 → sms-report 投递 +// (消费者归一化+段级配对见 consumer.go)。 +// 装配:gateway/consumer 双进程长连接均注入(channel.SetReportSink); +// producer=nil 降级仅日志(与 Day49 上行域同语义)。 +package report + +import ( + "context" + "encoding/json" + "time" + + "go-sms/internal/pkg/logger" + "go-sms/internal/pkg/queue" + + "go.uber.org/zap" +) + +// Producer Kafka 出口(装配层注入 queue.Producer;nil=不投递,降级)。 +type Producer interface { + Send(topic string, key, value []byte) error +} + +// Event sms-report 事件载荷(消费者段级配对+聚合判终态)。 +type Event struct { + ChannelID int64 `json:"channel_id"` + MsgID string `json:"msg_id"` + Stat string `json:"stat"` // 通道原始码(DELIVRD/UNDELIV/GB:0001…) + Dest string `json:"dest"` // 手机号(合包同 msg_id 多号的区分键) + DoneTime string `json:"done_time,omitempty"` + RecvAt string `json:"recv_at"` // RFC3339 + // Retries unpaired 短重投计数(Day 69 三轮:秒回模拟器回执链路可跑赢 + // 发送侧 seg 落库,<3 时回投 sms-report 尾部天然延迟后重配)。 + Retries int `json:"retries,omitempty"` +} + +// Sink 回执出口实现(channel.ReportSink 接口)。 +type Sink struct { + prod Producer +} + +// NewSink 构造(prod=nil 降级:仅 Warn 日志,不投递)。 +func NewSink(prod Producer) *Sink { return &Sink{prod: prod} } + +// IngestReport 回执受理:投 sms-report(key=msg_id,同段有序)。 +// 由通道链路读循环 goroutine 调用;投递失败仅日志(消费者侧重投/补偿 +// 由 48h 挂起扫描兜底,Day57 计费确认同批落地)。 +func (s *Sink) IngestReport(_ context.Context, channelID int64, msgID, stat, dest, doneTime string) { + if s.prod == nil { + logger.L().Warn("report_sink_producer_nil_drop", + zap.Int64("channel_id", channelID), zap.String("msg_id", msgID), zap.String("stat", stat)) + return + } + payload, _ := json.Marshal(Event{ + ChannelID: channelID, MsgID: msgID, Stat: stat, + Dest: dest, DoneTime: doneTime, + RecvAt: time.Now().Format(time.RFC3339), + }) + if err := s.prod.Send(queue.TopicReport, []byte(msgID), payload); err != nil { + logger.L().Warn("report_kafka_send_failed", + zap.Int64("channel_id", channelID), zap.String("msg_id", msgID), zap.Error(err)) + } +}