479 lines
18 KiB
Go
479 lines
18 KiB
Go
// consumer.go Day 48:submit 消费者——sms-submit 事件驱动立即任务下发。
|
|
// 设计与 timer 同构(Kafka 事件=加速器,MySQL 原子认领=事实源):
|
|
// - HandlePayload:解析事件 → claim(UPDATE status 0→1 WHERE 审核可发+send_type∈{1,2})
|
|
// →RowsAffected=0 直接成功(已处理/待审/定时域,天然幂等去重);
|
|
// - ReclaimScanner:5s 补偿扫描同域任务(事件丢失/审核通过后无人认领的兜底,
|
|
// 顺带修复"手动审核通过后任务停滞"缺陷);
|
|
// - 分发复用 ChannelDispatcher(router 选路→聚合/直发链路→明细终态);
|
|
// 系统性错误回滚 status 1→0 留待重扫(claim 原子性保证重试幂等)。
|
|
package send
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"go-sms/internal/model/entity"
|
|
"go-sms/internal/service/balance"
|
|
"go-sms/internal/service/interceptor"
|
|
"go-sms/internal/util"
|
|
|
|
"go.uber.org/zap"
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/clause"
|
|
)
|
|
|
|
// SubmitEvent sms-submit 事件载荷(Day46 openapi 五字段向后兼容+Day48 扩展+Day52 R2 明细全量)。
|
|
type SubmitEvent struct {
|
|
TaskID int64 `json:"task_id"`
|
|
TaskNo string `json:"task_no"`
|
|
AccountID int64 `json:"account_id"`
|
|
SendType int8 `json:"send_type"`
|
|
PassCount int `json:"pass_count"` // 过拦截条数(0=全拦,消费者跳过;Day52 起由 details 推导)
|
|
Source string `json:"source"`
|
|
CreatedAt string `json:"created_at"`
|
|
Business string `json:"business,omitempty"` // Day 49:sms/video(biz_type 路由;空=sms 兼容 Day48 旧载荷)
|
|
// Day52 R2:明细全量(入口预生成雪花 ID+拦截终态;消费侧批量落库,入口事务零明细写)。
|
|
// 空=Day48 旧格式/兜底扫描场景,消费侧不落(明细已由降级路径或旧版本落库)。
|
|
Details []EventDetail `json:"details,omitempty"`
|
|
// P0-1(Day 63)接入异步化:Deferred=true 表示受理侧走 SubmitFast 快路径
|
|
// (Validate+预扣+DetailID 预生成+投递,零 DB 写),task 落库/拦截判定/退费/
|
|
// 审核分流全部由消费侧补全(handleDeferred);TaskID=0(自增主键消费侧生成)。
|
|
Deferred bool `json:"deferred,omitempty"`
|
|
// TaskMeta Deferred 专用:任务行补建字段(与 entity.MessageTask 对齐;
|
|
// 旧事件零携带,消费侧按非 Deferred 老路径处理)。
|
|
TaskMeta *SubmitTaskMeta `json:"task_meta,omitempty"`
|
|
}
|
|
|
|
// SubmitTaskMeta 快路径任务补建载荷(受理侧未落库,消费侧 INSERT 重建)。
|
|
type SubmitTaskMeta struct {
|
|
Content string `json:"content"`
|
|
Sign string `json:"sign"`
|
|
MobileCount int `json:"mobile_count"`
|
|
FeeTotal float64 `json:"fee_total"`
|
|
SubmitIP string `json:"submit_ip"`
|
|
CallData string `json:"call_data"`
|
|
Source int8 `json:"source"` // 任务来源 int8(WEB=4/CMPP=2/SMPP=3/API=1)
|
|
ScheduleAt string `json:"schedule_at,omitempty"` // RFC3339,空=非定时
|
|
}
|
|
|
|
// EventDetail 明细行载荷(task_id/account_id 公共字段在事件级;字段与 entity.MessageDetail 对齐)。
|
|
type EventDetail struct {
|
|
ID int64 `json:"id"` // 雪花主键(入口预生成,回执配对键)
|
|
Mobile string `json:"mobile"`
|
|
Content string `json:"content"`
|
|
Status int8 `json:"status"` // 0=存活 5=拦截终态(受理期已退费)
|
|
Fee float64 `json:"fee"` // 计费条数
|
|
ErrorCode string `json:"error_code,omitempty"`
|
|
ExtCode string `json:"ext_code,omitempty"`
|
|
CallData string `json:"call_data,omitempty"`
|
|
// Day66:明细单表化冗余(空=旧载荷,persistDetailsDB 兜底 ev.Business/'sms')。
|
|
Business string `json:"business,omitempty"`
|
|
Source int8 `json:"source,omitempty"` // 0=旧载荷→兜底 API
|
|
}
|
|
|
|
// SubmitConsumer 事件消费者。
|
|
type SubmitConsumer struct {
|
|
db *gorm.DB
|
|
dp TaskDispatcher
|
|
log *zap.Logger
|
|
blocked BlockedDeliverSink // Day62c:拦截终态 CMPP 下发出口(nil=静默)
|
|
// P0-1(Day 63)Deferred 补全依赖(受理快路径的同步链后移;nil=对应环节降级)。
|
|
chain *interceptor.Chain // 拦截器链(nil=全放行,兼容最小装配)
|
|
rt TaskRouter // 审核分流(nil=停留待审,48h Scanner 兜底)
|
|
bal balance.Store // 拦截/审核拒退费(nil=不退,对账 Reconciler 兜底)
|
|
}
|
|
|
|
// BlockedDeliverSink Day62c:受理期拦截终态(status=5)下发出口。
|
|
// 背景:拦截明细不经 finishDetail(上游回执路径),CMPP 客户收不到任何状态
|
|
// (真机报障:8 条 ISC:004 全拦,客户端一直等回执)。接口在 send 域定义、
|
|
// 装配层适配 report.DeliverEvent,避免 send↔report 循环依赖。
|
|
type BlockedDeliverSink interface {
|
|
// PushBlocked errCode 透传(ISC:004 等);submitAt=MMDDHHMMSS;尽力而为不返回错误。
|
|
PushBlocked(ctx context.Context, accountID, detailID int64, mobile, errCode, submitAt string)
|
|
}
|
|
|
|
// WithBlockedDeliverSink 注入拦截终态下发出口(Day62c;链式)。
|
|
func (c *SubmitConsumer) WithBlockedDeliverSink(s BlockedDeliverSink) *SubmitConsumer {
|
|
c.blocked = s
|
|
return c
|
|
}
|
|
|
|
// WithConsumerChain 注入拦截器链(P0-1 Deferred 补全;链式)。
|
|
func (c *SubmitConsumer) WithConsumerChain(ch *interceptor.Chain) *SubmitConsumer {
|
|
c.chain = ch
|
|
return c
|
|
}
|
|
|
|
// WithConsumerRouter 注入审核分流(P0-1 Deferred 补全;链式)。
|
|
func (c *SubmitConsumer) WithConsumerRouter(rt TaskRouter) *SubmitConsumer {
|
|
c.rt = rt
|
|
return c
|
|
}
|
|
|
|
// WithConsumerBalance 注入资金 Store(P0-1 Deferred 退费;链式)。
|
|
func (c *SubmitConsumer) WithConsumerBalance(b balance.Store) *SubmitConsumer {
|
|
c.bal = b
|
|
return c
|
|
}
|
|
|
|
// NewSubmitConsumer 构造。
|
|
func NewSubmitConsumer(db *gorm.DB, dp TaskDispatcher, log *zap.Logger) *SubmitConsumer {
|
|
if log == nil {
|
|
log = zap.NewNop()
|
|
}
|
|
return &SubmitConsumer{db: db, dp: dp, log: log}
|
|
}
|
|
|
|
// HandlePayload 处理单条事件(装配层适配 sarama 消息取 Value)。
|
|
// 解析失败返回错误(进重试→死信,毒丸不阻塞分区);业务态跳过返回 nil。
|
|
// Day52 R2:明细批量落库先于认领/下发(回执配对键先于 submit 存在;
|
|
// 雪花主键冲突 DoNothing=重投幂等;失败返回错误进重试——明细为对账事实源不能丢)。
|
|
func (c *SubmitConsumer) HandlePayload(ctx context.Context, payload []byte) error {
|
|
var ev SubmitEvent
|
|
if err := json.Unmarshal(payload, &ev); err != nil {
|
|
return err
|
|
}
|
|
// P0-1(Day 63)快路径补全分支:受理侧零 DB 写,消费侧补建任务/拦截/退费/审核。
|
|
if ev.Deferred {
|
|
return c.handleDeferred(ctx, &ev)
|
|
}
|
|
if ev.TaskID == 0 {
|
|
return nil // 无任务标识:忽略(防御旧格式)
|
|
}
|
|
if err := c.persistDetails(ctx, &ev); err != nil {
|
|
return fmt.Errorf("明细落库(task %d): %w", ev.TaskID, err)
|
|
}
|
|
if ev.PassCount == 0 { // 零值兼容 Day46 事件(未带 pass_count):按任务现状认领
|
|
ev.PassCount = 1
|
|
}
|
|
if !c.claim(ctx, ev.TaskID) {
|
|
return nil // 已处理/待审/定时域/全拦终态:幂等成功(明细已落)
|
|
}
|
|
return c.dispatch(ctx, ev.TaskID)
|
|
}
|
|
|
|
// handleDeferred P0-1(Day 63)快路径事件补全:受理侧 SubmitFast 零 DB 写,
|
|
// 本函数在消费侧重建完整受理语义(与 SubmitService.Submit 同口径):
|
|
// ①拦截器链判定(命中→明细终态 5+拦截费退)②task INSERT 补建(uk_task_no
|
|
// 冲突=重投幂等:查回既有 ID,退费仅首次执行)③明细落库+拦截回执桥(Day62c)
|
|
// ④全拦→任务终态 ⑤审核分流(拒绝→存活费退)⑥claim/dispatch(待审/定时自然跳过)。
|
|
func (c *SubmitConsumer) handleDeferred(ctx context.Context, ev *SubmitEvent) error {
|
|
if len(ev.Details) == 0 || ev.TaskMeta == nil {
|
|
return nil // 防御:Deferred 事件必带明细与任务载荷(缺失静默,防毒丸循环重试)
|
|
}
|
|
// ①拦截判定(nil=全放行,兼容最小装配;请求级快照单事件构造一次)。
|
|
var blockedFee float64
|
|
if c.chain != nil {
|
|
mobiles := make([]string, 0, len(ev.Details))
|
|
for i := range ev.Details {
|
|
mobiles = append(mobiles, ev.Details[i].Mobile)
|
|
}
|
|
sc := c.chain.NewScope(ctx, ev.AccountID, mobiles)
|
|
for i := range ev.Details {
|
|
d := &ev.Details[i]
|
|
if b := c.chain.Check(ctx, &interceptor.Req{
|
|
TaskNo: ev.TaskNo, AccountID: ev.AccountID, Mobile: d.Mobile,
|
|
Content: d.Content, SendType: ev.SendType, Scope: sc,
|
|
}); b != nil {
|
|
d.Status = 5
|
|
d.ErrorCode = util.Truncate(b.Code, 16)
|
|
blockedFee += d.Fee
|
|
}
|
|
}
|
|
}
|
|
// ②任务补建(自增主键消费侧生成;uk_task_no 冲突=事件重投:取回既有 ID)。
|
|
var scheduleAt *time.Time
|
|
if ev.TaskMeta.ScheduleAt != "" {
|
|
if at, perr := time.Parse(time.RFC3339, ev.TaskMeta.ScheduleAt); perr == nil {
|
|
scheduleAt = &at
|
|
}
|
|
}
|
|
task := entity.MessageTask{
|
|
TaskNo: ev.TaskNo, AccountID: ev.AccountID, SendType: ev.SendType,
|
|
Content: ev.TaskMeta.Content, Sign: ev.TaskMeta.Sign,
|
|
MobileCount: ev.TaskMeta.MobileCount, FeeTotal: ev.TaskMeta.FeeTotal,
|
|
AuditStatus: 0, Status: 0, ScheduleAt: scheduleAt,
|
|
SubmitIP: ev.TaskMeta.SubmitIP, CallData: util.Truncate(ev.TaskMeta.CallData, 64),
|
|
Source: ev.TaskMeta.Source,
|
|
}
|
|
// ②④任务补建+明细落库(Day65 合一事务:单号事件原先两写事务→一,省一次
|
|
// commit fsync 往返;失败整体回滚重试,幂等锚=uk_task_no+明细雪花主键)。
|
|
firstInsert := false
|
|
skipRoute := false // 重投幂等:任务已分流(audit≠0)则跳过 Route(ISC:037 防死信)
|
|
var inserted int64
|
|
txErr := c.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
res := tx.Create(&task)
|
|
if res.Error == nil {
|
|
firstInsert = true
|
|
} else if isDupTaskNo(res.Error) {
|
|
// 重投幂等:查回既有任务续跑(明细 OnConflict/claim 原子幂等;退费不重复执行)。
|
|
var exist entity.MessageTask
|
|
if err := tx.Select("id", "audit_status").
|
|
Where("task_no = ?", ev.TaskNo).Take(&exist).Error; err != nil {
|
|
return fmt.Errorf("deferred 重投查任务: %w", err)
|
|
}
|
|
task.ID = exist.ID
|
|
if exist.AuditStatus != 0 {
|
|
skipRoute = true
|
|
}
|
|
} else {
|
|
return fmt.Errorf("deferred 建任务: %w", res.Error)
|
|
}
|
|
ev.TaskID = task.ID
|
|
var perr error
|
|
inserted, perr = persistDetailsDB(tx, ctx, ev)
|
|
return perr
|
|
})
|
|
if txErr != nil {
|
|
return fmt.Errorf("明细落库(task %s): %w", ev.TaskNo, txErr)
|
|
}
|
|
// ③拦截号退费(仅首次建任务执行;预扣在受理侧,此处对冲被拦号——事务提交后
|
|
// 执行,Redis 侧对冲不参与 DB 回滚)。拦截回执桥同置事务外(RowsAffected 防重)。
|
|
if firstInsert && blockedFee > 0 && c.bal != nil {
|
|
_ = c.bal.Refund(ctx, ev.AccountID, int64(blockedFee), ev.TaskNo, "拦截号码退费")
|
|
}
|
|
c.pushBlocked(ctx, ev, inserted)
|
|
// ⑤全拦:任务直接终态(与 Submit 同口径;拦截回执已由桥推送)。
|
|
pass := 0
|
|
for i := range ev.Details {
|
|
if ev.Details[i].Status == 0 {
|
|
pass++
|
|
}
|
|
}
|
|
if pass == 0 {
|
|
_ = c.db.WithContext(ctx).Model(&entity.MessageTask{}).
|
|
Where("id = ? AND status = ?", task.ID, 0).
|
|
Updates(map[string]any{
|
|
"status": taskStDone, "fail_count": len(ev.Details), "finished_at": time.Now(),
|
|
}).Error
|
|
return nil
|
|
}
|
|
// ⑥审核分流(nil=停留待审,48h Scanner 兜底;拒绝→存活费退;重投已分流跳过)。
|
|
if c.rt != nil && !skipRoute {
|
|
t2, _, rerr := c.rt.Route(ctx, task.ID)
|
|
if rerr != nil {
|
|
return fmt.Errorf("deferred 审核分流(task %d): %w", task.ID, rerr)
|
|
}
|
|
if t2 != nil && t2.AuditStatus == 2 && c.bal != nil {
|
|
_ = c.bal.Refund(ctx, ev.AccountID,
|
|
int64(ev.TaskMeta.FeeTotal)-int64(blockedFee), ev.TaskNo, "审核拒绝退费")
|
|
}
|
|
}
|
|
// ⑦认领+分发(待审/定时域 claim 自然跳过;已处理幂等成功)。
|
|
if !c.claim(ctx, task.ID) {
|
|
return nil
|
|
}
|
|
return c.dispatch(ctx, task.ID)
|
|
}
|
|
|
|
// isDupTaskNo 唯一键冲突判定(MySQL 1062/DUPLICATE 与 SQLite 兼容,同 Submit 口径)。
|
|
func isDupTaskNo(err error) bool {
|
|
msg := strings.ToUpper(err.Error())
|
|
return strings.Contains(msg, "DUPLICATE") || strings.Contains(msg, "1062") ||
|
|
strings.Contains(msg, "UNIQUE CONSTRAINT")
|
|
}
|
|
|
|
// 定时/全拦事件同样落明细后由 claim 语义自然跳过下发;旧格式无 details 直通。
|
|
// Day62c:落库成功且本轮实际插入(RowsAffected>0,重投幂等防重)时,对拦截终态行
|
|
// (status=5)且 task.source=CMPP 逐条推送下发事件——拦截明细无上游回执可等,
|
|
// 不推则 CMPP 客户永远收不到状态(真机报障实证)。
|
|
// Day65:内核拆出 persistDetailsDB(exec)——deferred 路径与任务补建同事务执行。
|
|
func (c *SubmitConsumer) persistDetails(ctx context.Context, ev *SubmitEvent) error {
|
|
inserted, err := persistDetailsDB(c.db.WithContext(ctx), ctx, ev)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.pushBlocked(ctx, ev, inserted)
|
|
return nil
|
|
}
|
|
|
|
// persistDetailsDB 明细批量落库(exec=连接或事务;返回本轮实际插入行数——
|
|
// 重投幂等锚=雪花主键 OnConflict DoNothing)。
|
|
func persistDetailsDB(exec *gorm.DB, ctx context.Context, ev *SubmitEvent) (int64, error) {
|
|
if len(ev.Details) == 0 {
|
|
return 0, nil
|
|
}
|
|
rows := make([]entity.MessageDetail, 0, len(ev.Details))
|
|
for i := range ev.Details {
|
|
d := &ev.Details[i]
|
|
// Day66:business/source 冗余透传;旧载荷兜底(ev.Business 空=sms 兼容 Day48;
|
|
// source 0=API 缺省——与 task 侧 Normalize 口径一致)。
|
|
biz, src := d.Business, d.Source
|
|
if biz == "" {
|
|
biz = ev.Business
|
|
if biz == "" {
|
|
biz = "sms"
|
|
}
|
|
}
|
|
if src == 0 {
|
|
src = TaskSourceAPI
|
|
}
|
|
rows = append(rows, entity.MessageDetail{
|
|
SnowflakeModel: entity.SnowflakeModel{ID: d.ID},
|
|
TaskID: ev.TaskID,
|
|
AccountID: ev.AccountID,
|
|
Mobile: d.Mobile,
|
|
Content: d.Content,
|
|
Status: d.Status,
|
|
Fee: d.Fee,
|
|
ErrorCode: d.ErrorCode,
|
|
ExtCode: d.ExtCode,
|
|
CallData: d.CallData,
|
|
Business: biz,
|
|
Source: src,
|
|
})
|
|
}
|
|
res := exec.WithContext(ctx).
|
|
Clauses(clause.OnConflict{DoNothing: true}).
|
|
CreateInBatches(rows, 500)
|
|
if res.Error != nil {
|
|
return 0, res.Error
|
|
}
|
|
return res.RowsAffected, nil
|
|
}
|
|
|
|
// pushBlocked 拦截终态下发(Day62c):本轮新插入才推(RowsAffected=0=纯重投跳过;
|
|
// 批内混合插入的极端重投重复可容忍,客户端按 Stat 幂等处理)。
|
|
func (c *SubmitConsumer) pushBlocked(ctx context.Context, ev *SubmitEvent, inserted int64) {
|
|
if c.blocked == nil || inserted == 0 {
|
|
return
|
|
}
|
|
hasBlocked := false
|
|
for i := range ev.Details {
|
|
if ev.Details[i].Status == 5 {
|
|
hasBlocked = true
|
|
break
|
|
}
|
|
}
|
|
if !hasBlocked {
|
|
return
|
|
}
|
|
// 事件不含 task.source 数值(入口字符串标识),查一次任务来源;非 CMPP 短路零开销。
|
|
var source int8
|
|
if err := c.db.WithContext(ctx).
|
|
Table("message_task").Select("source").Where("id = ?", ev.TaskID).
|
|
Take(&source).Error; err != nil {
|
|
c.log.Warn("blocked_deliver_source_lookup_failed",
|
|
zap.Int64("task_id", ev.TaskID), zap.Error(err))
|
|
return
|
|
}
|
|
if source != TaskSourceCMPP {
|
|
return // HTTP/控制台/SMPP 来源无 CMPP 会话诉求(SMPP 下发另立项)
|
|
}
|
|
submitAt := time.Now().Format("0102150405") // CMPP MMDDHHMMSS
|
|
for i := range ev.Details {
|
|
d := &ev.Details[i]
|
|
if d.Status != 5 {
|
|
continue
|
|
}
|
|
c.blocked.PushBlocked(ctx, ev.AccountID, d.ID, d.Mobile, d.ErrorCode, submitAt)
|
|
}
|
|
}
|
|
|
|
// claim 原子认领(与 timer.claim 同构;send_type∈{1,2} 立即/个性域)。
|
|
func (c *SubmitConsumer) claim(ctx context.Context, id int64) bool {
|
|
res := c.db.WithContext(ctx).Model(&entity.MessageTask{}).
|
|
Where("id = ? AND status = 0 AND audit_status IN (1, 3) AND send_type IN (1, 2)", id).
|
|
Update("status", taskStSending)
|
|
return res.RowsAffected == 1
|
|
}
|
|
|
|
// dispatch 分发并落终态(系统性错误回滚 1→0 留待重扫)。
|
|
func (c *SubmitConsumer) dispatch(ctx context.Context, id int64) error {
|
|
var task entity.MessageTask
|
|
if err := c.db.WithContext(ctx).First(&task, id).Error; err != nil {
|
|
return c.rollback(ctx, id)
|
|
}
|
|
sent, failed, derr := c.dp.Dispatch(ctx, &task)
|
|
if derr != nil {
|
|
// Day62d:陈年孤儿任务(旧格式无明细,事件永不再来)一次性终态结案——
|
|
// 否则 ReclaimScanner 5s/轮死循环重试(dev 实证 task 343 刷 warn 两日)。
|
|
// 1h 宽限覆盖 Day52 事件在途窗口;正常任务明细早已落库。
|
|
if errors.Is(derr, ErrDetailsNotReady) && time.Since(task.CreatedAt) > time.Hour {
|
|
c.log.Warn("orphan_task_finalized",
|
|
zap.Int64("task_id", id), zap.Time("created_at", task.CreatedAt))
|
|
res := c.db.WithContext(ctx).Model(&entity.MessageTask{}).
|
|
Where("id = ? AND status = ?", id, taskStSending).
|
|
Updates(map[string]any{"status": taskStDone, "finished_at": time.Now()})
|
|
if res.Error == nil && res.RowsAffected > 0 {
|
|
return nil
|
|
}
|
|
}
|
|
c.log.Warn("submit_dispatch_rollback", zap.Int64("task_id", id), zap.Error(derr))
|
|
return c.rollback(ctx, id)
|
|
}
|
|
res := c.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 nil // 并发终态:以先写者为准
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// rollback 认领回退(status 1→0,下轮重扫;幂等由 claim 保证)。
|
|
func (c *SubmitConsumer) rollback(ctx context.Context, id int64) error {
|
|
return c.db.WithContext(ctx).Model(&entity.MessageTask{}).
|
|
Where("id = ? AND status = ?", id, taskStSending).
|
|
Update("status", 0).Error
|
|
}
|
|
|
|
// ReclaimScanner 补偿扫描(5s/轮,单轮 batch 条;48h 内同域任务)。
|
|
type ReclaimScanner struct {
|
|
db *gorm.DB
|
|
sc *SubmitConsumer
|
|
batch int
|
|
}
|
|
|
|
// NewReclaimScanner 构造。
|
|
func NewReclaimScanner(db *gorm.DB, dp TaskDispatcher, log *zap.Logger) *ReclaimScanner {
|
|
return &ReclaimScanner{db: db, sc: NewSubmitConsumer(db, dp, log), batch: 100}
|
|
}
|
|
|
|
// WithBatch 覆写单轮上限(测试)。
|
|
func (s *ReclaimScanner) WithBatch(n int) *ReclaimScanner { s.batch = n; return s }
|
|
|
|
// ScanOnce 单轮:捞同域待发任务逐个认领分发(claim 失败即跳过)。
|
|
func (s *ReclaimScanner) ScanOnce(ctx context.Context) (claimed, done int, err error) {
|
|
var ids []int64
|
|
if err = s.db.WithContext(ctx).Model(&entity.MessageTask{}).
|
|
Where("status = 0 AND audit_status IN (1, 3) AND send_type IN (1, 2)"+
|
|
" AND created_at > ?", time.Now().Add(-48*time.Hour)).
|
|
Limit(s.batch).Pluck("id", &ids).Error; err != nil {
|
|
return 0, 0, err
|
|
}
|
|
for _, id := range ids {
|
|
if !s.sc.claim(ctx, id) {
|
|
continue
|
|
}
|
|
claimed++
|
|
if derr := s.sc.dispatch(ctx, id); derr == nil {
|
|
done++
|
|
}
|
|
}
|
|
return claimed, done, nil
|
|
}
|
|
|
|
// Run 周期扫描(默认 5s;随 ctx 退出)。
|
|
func (s *ReclaimScanner) Run(ctx context.Context, interval time.Duration) {
|
|
tk := time.NewTicker(interval)
|
|
defer tk.Stop()
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case <-tk.C:
|
|
if _, _, err := s.ScanOnce(ctx); err != nil {
|
|
continue // 单轮失败不退出(下轮重试)
|
|
}
|
|
}
|
|
}
|
|
}
|