Files

422 lines
15 KiB
Go

// 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 dispatch
import (
"context"
"errors"
"go-sms/internal/service/send/submit"
"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("明细尚未落库")
// 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, submit.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, submit.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, submit.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, submit.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)", submit.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, submit.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 <= ?",
submit.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, submit.SendTypeTimer, now).
Update("status", submit.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 == submit.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, submit.TaskStSending).
Update("status", 0).Error
return false
}
res := s.db.WithContext(ctx).Model(&entity.MessageTask{}).
Where("id = ? AND status = ?", id, submit.TaskStSending).
Updates(map[string]any{
"status": submit.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" }