// timer.go Day 45:定时短信调度——Redis ZSet 唤醒索引 + 5s 扫描 + MySQL 原子认领。 // 设计要点: // // ① ZSet 只是"唤醒索引",真值始终在 MySQL——认领用 // UPDATE ... WHERE status=0 AND audit_status IN(1,3) AND schedule_at<=now 原子翻转, // 重复扫描/多实例并发天然幂等(RowsAffected=0 即丢弃并清理索引); // ② 每轮先"补偿入队"(DB 全量待发定时任务→ZADD,score 覆盖幂等): // 手动待审任务审核通过、改期(Reschedule)均无需跨包事件通知, // 下一轮补偿自动纠正 score——"重置批量生效"; // ③ Redis 不可用时 q=nil,纯 DB 扫描降级(行为等价,ZSet 仅省全表轮询); // ④ 到点分发经 TaskDispatcher(router 选路→CMPP 链路提交); // 逐号独立成败,任务终态置 2 完成并回填计数;系统性错误回滚 status=1→0 下轮重试。 package send import ( "context" "errors" "strconv" "time" "go-sms/internal/model/entity" "go-sms/internal/pkg/cache" "go-sms/internal/service/router" "github.com/redis/go-redis/v9" "gorm.io/gorm" ) // ErrDetailsNotReady 明细尚未落库(Day52 R2:事件明细在途,回滚认领留待重扫)。 var ErrDetailsNotReady = errors.New("明细尚未落库") // 审核态/任务态稳定契约值(与 audit 包常量一致;避免 send→audit 本体依赖)。 const ( auditReadyExempt = 3 // 免审(可发) taskStSending = 1 taskStDone = 2 detailStSubmitted = 1 // 明细:已提交 detailStFailed = 3 // 明细:失败 ) // TaskQueue 定时任务唤醒索引(Redis ZSet 实现;测试可替身)。 type TaskQueue interface { Enqueue(ctx context.Context, taskID int64, at time.Time) error Due(ctx context.Context, now time.Time, limit int) ([]int64, error) All(ctx context.Context) ([]int64, error) // 全量成员(差集清理用) Remove(ctx context.Context, taskID int64) error } // RedisZSetQueue ZSet 实现:member=taskID,score=unix(schedule_at)。 type RedisZSetQueue struct { rc *cache.Client key string } // NewRedisZSetQueue 构造(key 建议带业务前缀,如 go-sms:timer:tasks)。 func NewRedisZSetQueue(rc *cache.Client, key string) *RedisZSetQueue { return &RedisZSetQueue{rc: rc, key: key} } // Enqueue 入队/重排(ZADD 同 member 覆盖 score——改期幂等)。 func (q *RedisZSetQueue) Enqueue(ctx context.Context, taskID int64, at time.Time) error { return q.rc.ZAdd(ctx, q.key, redis.Z{ Score: float64(at.Unix()), Member: strconv.FormatInt(taskID, 10), }).Err() } // Due 取到点任务(score<=now,升序)。 func (q *RedisZSetQueue) Due(ctx context.Context, now time.Time, limit int) ([]int64, error) { ids, err := q.rc.ZRangeByScore(ctx, q.key, &redis.ZRangeBy{ Min: "-inf", Max: strconv.FormatInt(now.Unix(), 10), Offset: 0, Count: int64(limit), }).Result() if err != nil { return nil, err } out := make([]int64, 0, len(ids)) for _, s := range ids { if v, e := strconv.ParseInt(s, 10, 64); e == nil { out = append(out, v) } } return out, nil } // Remove 出队(终态/取消/拒绝清理)。 func (q *RedisZSetQueue) Remove(ctx context.Context, taskID int64) error { return q.rc.ZRem(ctx, q.key, strconv.FormatInt(taskID, 10)).Err() } // All 全量成员(差集清理:取消/拒绝/超时后不必等到点即出队)。 func (q *RedisZSetQueue) All(ctx context.Context) ([]int64, error) { ids, err := q.rc.ZRange(ctx, q.key, 0, -1).Result() if err != nil { return nil, err } out := make([]int64, 0, len(ids)) for _, s := range ids { if v, e := strconv.ParseInt(s, 10, 64); e == nil { out = append(out, v) } } return out, nil } // TaskDispatcher 到点任务分发(Day45:router 选路+CMPP 链路;Day47 升级 per-channel 令牌桶)。 // 返回逐号(成功,失败)计数;err 非 nil 表示系统性错误(触发 status 回滚重试)。 type TaskDispatcher interface { Dispatch(ctx context.Context, task *entity.MessageTask) (sent, failed int64, err error) } // LinkSubmitter 通道链路提交(channel.Service 实现;依赖倒置)。 // Day 56:返回各段 msg_id(顺序=PkNumber 1..N)——提交侧逐段登记 // message_report_seg 供回执段级配对(单条=1 个元素)。 type LinkSubmitter interface { SubmitViaLink(ctx context.Context, channelID int64, mobile, content string) ([]string, error) } // ChannelDispatcher 默认分发器:明细逐号 router 选路→链路提交→明细落终态。 // Day47:注入 SubmitAggregator(可选)时,链路提交段改走合包聚合(5s/1000 批), // 明细终态由聚合器 flush 时批量回写(markDetails)。 // Day48:可选注入 ChannelPacer(per-channel 令牌桶+在途窗口+自动降速,直发路径 // Acquire/Release/Observe)与 DetailWriter(终态批量落库,防消费阻塞)。 type ChannelDispatcher struct { db *gorm.DB rt *router.Router lk LinkSubmitter agg *SubmitAggregator // nil=直发(兼容既有链路/测试) pacer *ChannelPacer // nil=不限速(timer 旧链路保持行为) writer *DetailWriter // nil=直写(默认;消费链路注入批量 writer) } // NewChannelDispatcher 构造(agg 可选:第 4 参注入即启用聚合)。 func NewChannelDispatcher(db *gorm.DB, rt *router.Router, lk LinkSubmitter, agg ...*SubmitAggregator) *ChannelDispatcher { d := &ChannelDispatcher{db: db, rt: rt, lk: lk} if len(agg) > 0 && agg[0] != nil { d.agg = agg[0] d.agg.bindMark(d.markDetails) } return d } // WithPacer 注入限速器(Day48④;nil 或未 Open 时直通)。 func (d *ChannelDispatcher) WithPacer(p *ChannelPacer) *ChannelDispatcher { d.pacer = p return d } // WithDetailWriter 注入批量终态 writer(Day48④;nil 保持直写)。 func (d *ChannelDispatcher) WithDetailWriter(w *DetailWriter) *ChannelDispatcher { d.writer = w return d } // Dispatch 逐号分发:任务已置 channel_id 则直用;否则 router.Pick // (Step0 账号导流命中即直连→组四步→全局默认兜底)。明细独立成败; // 聚合模式下"入聚合"即计 sent(批量失败时聚合器回写 failed 终态)。 func (d *ChannelDispatcher) Dispatch(ctx context.Context, task *entity.MessageTask) (int64, int64, error) { var details []entity.MessageDetail if err := d.db.WithContext(ctx). Where("task_id = ? AND status = 0", task.ID).Find(&details).Error; err != nil { return 0, 0, err } // Day52 顺带修复:只下发存活号(status=0)——拦截终态 5 行受理期已退费, // 原全量读会重复下发并覆盖终态(部分拦截任务的存量缺陷)。 // Day52 R2 防御:任务有号但明细 0 行=事件明细尚未落库(ReclaimScanner 抢跑窗口), // 返回错误触发认领回滚,留待明细落库后重扫(避免空跑终态 0/0 造成明细悬置)。 if len(details) == 0 && task.MobileCount > 0 { return 0, 0, ErrDetailsNotReady } now := time.Now() var sent, failed int64 for _, det := range details { chID := task.ChannelID if chID == 0 { ch, _, perr := d.rt.Pick(ctx, 0, &router.PickReq{ AccountID: task.AccountID, Content: det.Content, Signature: task.Sign, }) if perr != nil { d.markDetail(ctx, det.ID, detailStFailed, chID, "NO_ROUTE:"+perr.Error(), now) failed++ continue } chID = ch.ID } if d.agg != nil { d.agg.Add(chID, det.Content, det.Mobile, det.ID) sent++ continue } // Day48④:直发路径限速(令牌桶+在途窗口;未启用直通)+延迟采样降速判定。 if d.pacer != nil { if aerr := d.pacer.Acquire(ctx, chID, 1); aerr != nil { d.markDetail(ctx, det.ID, detailStFailed, chID, aerr.Error(), now) failed++ continue } } start := time.Now() msgIDs, serr := d.lk.SubmitViaLink(ctx, chID, det.Mobile, det.Content) if d.pacer != nil { d.pacer.Observe(chID, float64(time.Since(start).Milliseconds())) d.pacer.Release(chID, 1) } if serr != nil { d.markDetail(ctx, det.ID, detailStFailed, chID, serr.Error(), now) failed++ continue } // Day 56:段级配对登记(单号 1~9 段,每段独立 msg_id)。 writeSegRows(ctx, d.db, segRowsFor(chID, det.ID, det.Mobile, msgIDs)) d.markDetail(ctx, det.ID, detailStSubmitted, chID, "", now) sent++ } if d.agg != nil { d.agg.FlushAll() // 任务级即时冲洗(定时到点批次不等待窗口;跨任务凑批由消费链路负责) } return sent, failed, nil } // TimerScheduler 定时扫描器(5s/轮,启动即扫)。 type TimerScheduler struct { db *gorm.DB q TaskQueue // nil → 纯 DB 扫描降级 dp TaskDispatcher interval time.Duration batch int // 单轮认领上限 } // NewTimerScheduler 构造(零值默认 5s/轮、单轮 100)。 func NewTimerScheduler(db *gorm.DB, q TaskQueue, dp TaskDispatcher) *TimerScheduler { return &TimerScheduler{db: db, q: q, dp: dp, interval: 5 * time.Second, batch: 100} } // WithInterval/WithBatch 覆写(测试注入)。 func (s *TimerScheduler) WithInterval(d time.Duration) *TimerScheduler { s.interval = d return s } func (s *TimerScheduler) WithBatch(n int) *TimerScheduler { s.batch = n return s } // Run 常驻扫描(随 ctx 退出;启动先扫一次)。 func (s *TimerScheduler) Run(ctx context.Context) { t := time.NewTicker(s.interval) defer t.Stop() for { _, _, _, _ = s.ScanOnce(ctx) // 单轮失败不阻断调度(错误可由调用方经日志观测) select { case <-ctx.Done(): return case <-t.C: } } } // ScanOnce 单轮:①补偿入队 ②取 Due ③原子认领 ④分发终态。 // 返回(补偿入队数, 认领数, 分发完成数, 错误)。 func (s *TimerScheduler) ScanOnce(ctx context.Context) (enq, claimed, done int, err error) { now := time.Now() // ① 补偿入队:DB 全部"定时+待发+审核可发"任务 → ZADD(score 覆盖幂等; // 手动审核通过/改期由此自动纠正,无需跨包事件通知)。q=nil 跳过。 if s.q != nil { var pend []entity.MessageTask if err = s.db.WithContext(ctx). Where("send_type = ? AND status = 0 AND audit_status IN (1, 3)", SendTypeTimer). Order("schedule_at ASC").Limit(200).Find(&pend).Error; err != nil { return 0, 0, 0, err } for _, t := range pend { if t.ScheduleAt == nil { continue } if qerr := s.q.Enqueue(ctx, t.ID, *t.ScheduleAt); qerr == nil { enq++ } } } // ①' 差集清理:ZSet 全量对照 DB——取消/拒绝/超时/非定时成员即时出队 // (不依赖到点 reconcile;Redis 故障跳过,残留到点仍会被 reconcile 兜底)。 if s.q != nil { if all, aerr := s.q.All(ctx); aerr == nil && len(all) > 0 { var invalid []entity.MessageTask if err = s.db.WithContext(ctx). Where("id IN ? AND NOT (send_type = ? AND status = 0 AND audit_status IN (1, 3))", all, SendTypeTimer).Find(&invalid).Error; err == nil { for _, t := range invalid { _ = s.q.Remove(ctx, t.ID) } } } } // ② 取 Due 候选(ZSet 优先;nil/不可达→DB 直查兜底)。 var ids []int64 if s.q != nil { ids, err = s.q.Due(ctx, now, s.batch) if err != nil { ids = nil // Redis 故障降级 } } if ids == nil { var rows []entity.MessageTask if err = s.db.WithContext(ctx). Where("send_type = ? AND status = 0 AND audit_status IN (1, 3) AND schedule_at <= ?", SendTypeTimer, now). Order("schedule_at ASC").Limit(s.batch).Find(&rows).Error; err != nil { return enq, 0, 0, err } ids = make([]int64, 0, len(rows)) for _, r := range rows { ids = append(ids, r.ID) } } // ③ 原子认领 + ④ 分发终态。 for _, id := range ids { ok, cerr := s.claim(ctx, id, now) if cerr != nil { _ = cerr // 认领错误跳过该条(原 err 死存储;函数终态恒返回 nil,语义不变) continue } if !ok { s.reconcile(ctx, id) // 认领失败:按任务现状清理索引或重排(改期) continue } claimed++ if s.dispatch(ctx, id) { done++ } } return enq, claimed, done, nil } // claim 原子认领:status 0→1(WHERE 审核可发+到点;RowsAffected=0 即被并发处理)。 func (s *TimerScheduler) claim(ctx context.Context, id int64, now time.Time) (bool, error) { res := s.db.WithContext(ctx).Model(&entity.MessageTask{}). Where("id = ? AND send_type = ? AND status = 0 AND audit_status IN (1, 3) AND schedule_at <= ?", id, SendTypeTimer, now). Update("status", taskStSending) return res.RowsAffected == 1, res.Error } // reconcile 认领失败善后:取消/终态/拒绝/超时/待审→出队;改期(未来)→按新时刻重排。 func (s *TimerScheduler) reconcile(ctx context.Context, id int64) { if s.q == nil { return } var t entity.MessageTask if err := s.db.WithContext(ctx).Select("id", "status", "audit_status", "schedule_at"). First(&t, id).Error; err != nil { _ = s.q.Remove(ctx, id) // 已删除任务:清索引 return } if t.Status == 0 && (t.AuditStatus == 1 || t.AuditStatus == auditReadyExempt) && t.ScheduleAt != nil && t.ScheduleAt.After(time.Now()) { _ = s.q.Enqueue(ctx, id, *t.ScheduleAt) // 改期:重排新时刻 return } _ = s.q.Remove(ctx, id) } // dispatch 分发并落终态:成功→status=2+计数+finished_at+出队; // 系统性错误→回滚 status 1→0(下轮重试,幂等由 claim 原子性保证)。 func (s *TimerScheduler) dispatch(ctx context.Context, id int64) bool { var task entity.MessageTask if err := s.db.WithContext(ctx).First(&task, id).Error; err != nil { return false } sent, failed, derr := s.dp.Dispatch(ctx, &task) if derr != nil { _ = s.db.WithContext(ctx).Model(&entity.MessageTask{}). Where("id = ? AND status = ?", id, taskStSending). Update("status", 0).Error return false } res := s.db.WithContext(ctx).Model(&entity.MessageTask{}). Where("id = ? AND status = ?", id, taskStSending). Updates(map[string]any{ "status": taskStDone, "success_count": sent, "fail_count": failed, "finished_at": time.Now(), }) if res.Error != nil || res.RowsAffected == 0 { return false } if s.q != nil { _ = s.q.Remove(ctx, id) } return true } // markDetail 明细终态(status/channel/send_at/error_code;error_code 截 16 字符防列溢出)。 func (d *ChannelDispatcher) markDetail(ctx context.Context, id int64, status int8, channelID int64, errCode string, at time.Time) { if ec := []rune(errCode); len(ec) > 16 { errCode = string(ec[:16]) } _ = d.db.WithContext(ctx).Model(&entity.MessageDetail{}).Where("id = ?", id). Updates(map[string]any{ "status": status, "channel_id": channelID, "error_code": errCode, "send_at": at, }).Error } // markDetails 批量明细终态(Day47 聚合器 flush 回写;同明细语义,error_code 同截断)。 // Day48:注入 DetailWriter 时改走异步批量(不阻塞消费;入队失败回落直写)。 func (d *ChannelDispatcher) markDetails(ctx context.Context, ids []int64, status int8, channelID int64, errCode string) { if len(ids) == 0 { return } if d.writer != nil && d.writer.Add(DetailUpdate{ IDs: ids, Status: status, ChannelID: channelID, ErrorCode: errCode, }) { return } if ec := []rune(errCode); len(ec) > 16 { errCode = string(ec[:16]) } _ = d.db.WithContext(ctx).Model(&entity.MessageDetail{}).Where("id IN ?", ids). Updates(map[string]any{ "status": status, "channel_id": channelID, "error_code": errCode, "send_at": time.Now(), }).Error } // QueueKey 生产 ZSet key(装配与运维排查共用口径)。 func QueueKey() string { return "go-sms:timer:tasks" }