430 lines
15 KiB
Go
430 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 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" }
|