- 四个轮询处理器拆为步骤函数 Step(返回结果分类),旧 Asynq Handle 只做并发控制与原有重入队映射,行为不变;carrier 模式下旧 handler 直接结束
- 网关限流增加等待模式(ctx 标记),NSQ 消费者等名额到单步超时,超时按限流处理不计失败;记录限流等待次数
- 卡任务执行器:核对 token 并抢执行权,按配置步骤顺序串行执行到期检查(单步超时、总超时、panic 恢复、流量已触发评估时跳过套餐),执行中续期并 Touch,续期失败立即停止;收尾写回到期、连续失败、退避、延迟确认与告警
- 分发器:每秒按账户抢分发锁领取(执行上限按消费能力收紧、优先占比、按限流组剩余 QPS 估算),发布到 polling.card.{账户},发布失败释放;消费旧优先提示与手动触发;心跳与处理中标记到期计数
- NSQ 生产者与按账户动态订阅的消费者管理器,优雅退出宽限期
- 失败告警异步写 tb_polling_failure_alert(同卡同类型一条未处理,成功转已恢复),账户窗口内告警数超阈值产生账户级告警
- 模式监听:切 carrier 时旧分片调度停止出队,加锁初始化新结构后开始领取并订阅;回 legacy 时停止消费、重建旧分片队列;生命周期(API 与 Worker)在 carrier 模式写账户队列
200 lines
7.2 KiB
Go
200 lines
7.2 KiB
Go
package polling
|
||
|
||
import (
|
||
"context"
|
||
"sync"
|
||
"sync/atomic"
|
||
"time"
|
||
|
||
"go.uber.org/zap"
|
||
|
||
"github.com/break/junhong_cmp_fiber/internal/model"
|
||
"github.com/break/junhong_cmp_fiber/internal/polling/carrierqueue"
|
||
"github.com/break/junhong_cmp_fiber/internal/store/postgres"
|
||
"github.com/break/junhong_cmp_fiber/pkg/constants"
|
||
)
|
||
|
||
// CarrierScheduling 是按运营商账户调度在轮询包内的接缝:判断当前模式,并按卡计算各检查类型到期时间写入账户队列。
|
||
// 所有写入轮询结构的入口(初始化、生命周期、优先提示、手动触发)按当前模式写新结构或旧分片结构。
|
||
type CarrierScheduling struct {
|
||
store *carrierqueue.Store
|
||
settings *carrierqueue.SettingsProvider
|
||
configMgr *PollingConfigManager
|
||
logger *zap.Logger
|
||
}
|
||
|
||
// NewCarrierScheduling 创建按运营商账户调度接缝。
|
||
func NewCarrierScheduling(store *carrierqueue.Store, settings *carrierqueue.SettingsProvider, configMgr *PollingConfigManager, logger *zap.Logger) *CarrierScheduling {
|
||
if logger == nil {
|
||
logger = zap.NewNop()
|
||
}
|
||
return &CarrierScheduling{store: store, settings: settings, configMgr: configMgr, logger: logger}
|
||
}
|
||
|
||
// Active 判断当前是否为按运营商账户调度。
|
||
func (c *CarrierScheduling) Active(ctx context.Context) bool {
|
||
return c != nil && c.store != nil && c.settings != nil && c.settings.Current(ctx).CarrierMode()
|
||
}
|
||
|
||
// Store 返回账户队列存储。
|
||
func (c *CarrierScheduling) Store() *carrierqueue.Store {
|
||
if c == nil {
|
||
return nil
|
||
}
|
||
return c.store
|
||
}
|
||
|
||
// Settings 返回调度参数提供者。
|
||
func (c *CarrierScheduling) Settings() *carrierqueue.SettingsProvider {
|
||
if c == nil {
|
||
return nil
|
||
}
|
||
return c.settings
|
||
}
|
||
|
||
// DuesForCard 按卡匹配的轮询配置计算各检查类型下次到期时间。
|
||
// fromLastCheck 为 true 时按各类型上次检查时间计算(初始化);否则按当前时间加抖动(新卡、恢复轮询、状态变化)。
|
||
// 间隔为 0 或未配置的类型不返回;重置日前加密窗口规则算出的时间更早时以它为准。
|
||
func (c *CarrierScheduling) DuesForCard(ctx context.Context, card *model.IotCard, fromLastCheck bool) map[string]time.Time {
|
||
dues := map[string]time.Time{}
|
||
if c == nil || c.configMgr == nil || card == nil {
|
||
return dues
|
||
}
|
||
now := time.Now()
|
||
for taskType, info := range c.configMgr.MergedTaskIntervals(card) {
|
||
checkType := constants.CheckTypeFromTaskType(taskType)
|
||
if checkType == "" || info.Interval <= 0 {
|
||
continue
|
||
}
|
||
var due time.Time
|
||
if fromLastCheck {
|
||
due = calculateNextCheckTime(lastCheckAtByTaskType(card, taskType), info.Interval, now)
|
||
if windowDue := c.configMgr.NextCheckAt(ctx, card, taskType, info, now); windowDue.Before(due) && windowDue.After(now) {
|
||
due = windowDue
|
||
}
|
||
} else {
|
||
due = calcInitialDelay(info.Interval)
|
||
}
|
||
dues[checkType] = due
|
||
}
|
||
return dues
|
||
}
|
||
|
||
// UpsertCard 把卡写入所属账户队列;fromLastCheck 含义同 DuesForCard。
|
||
func (c *CarrierScheduling) UpsertCard(ctx context.Context, card *model.IotCard, fromLastCheck bool) {
|
||
if c == nil || c.store == nil || card == nil {
|
||
return
|
||
}
|
||
if err := c.store.Upsert(ctx, card.ID, card.CarrierID, c.DuesForCard(ctx, card, fromLastCheck)); err != nil {
|
||
c.logger.Warn("写入运营商账户轮询队列失败", zap.Uint("card_id", card.ID), zap.Uint("carrier_id", card.CarrierID), zap.Error(err))
|
||
}
|
||
}
|
||
|
||
// RemoveCard 把卡移出所属账户队列;carrierID 为 0 时按到期信息中记录的账户移出。
|
||
func (c *CarrierScheduling) RemoveCard(ctx context.Context, cardID, carrierID uint) {
|
||
if c == nil || c.store == nil {
|
||
return
|
||
}
|
||
if carrierID == 0 {
|
||
due, err := c.store.ReadDue(ctx, cardID)
|
||
if err != nil || due.CarrierID == 0 {
|
||
return
|
||
}
|
||
carrierID = due.CarrierID
|
||
}
|
||
if err := c.store.Remove(ctx, cardID, carrierID); err != nil {
|
||
c.logger.Warn("移出运营商账户轮询队列失败", zap.Uint("card_id", cardID), zap.Error(err))
|
||
}
|
||
}
|
||
|
||
// RequestTaskType 把卡的某检查类型(旧任务类型 polling:xxx)设为立即到期放入账户优先队列(优先提示、手动触发)。
|
||
// 卡不在轮询中时不处理。
|
||
func (c *CarrierScheduling) RequestTaskType(ctx context.Context, cardID, carrierID uint, taskType string) {
|
||
checkType := constants.CheckTypeFromTaskType(taskType)
|
||
if c == nil || c.store == nil || checkType == "" {
|
||
return
|
||
}
|
||
if _, err := c.store.RequestCheck(ctx, carrierqueue.CheckRequest{CardID: cardID, CarrierID: carrierID, CheckTypes: []string{checkType}}); err != nil {
|
||
c.logger.Warn("写入运营商账户优先队列失败", zap.Uint("card_id", cardID), zap.String("task_type", taskType), zap.Error(err))
|
||
}
|
||
}
|
||
|
||
// CarrierInitializer 从数据库按批初始化全部运营商账户队列与卡到期信息;进度与旧初始化器同结构,供 init-progress 展示。
|
||
type CarrierInitializer struct {
|
||
scheduling *CarrierScheduling
|
||
iotCardStore *postgres.IotCardStore
|
||
logger *zap.Logger
|
||
|
||
mu sync.RWMutex
|
||
progress InitProgress
|
||
running atomic.Bool
|
||
}
|
||
|
||
// NewCarrierInitializer 创建新结构初始化器。
|
||
func NewCarrierInitializer(scheduling *CarrierScheduling, iotCardStore *postgres.IotCardStore, logger *zap.Logger) *CarrierInitializer {
|
||
if logger == nil {
|
||
logger = zap.NewNop()
|
||
}
|
||
return &CarrierInitializer{scheduling: scheduling, iotCardStore: iotCardStore, logger: logger}
|
||
}
|
||
|
||
// Progress 返回初始化进度快照。
|
||
func (i *CarrierInitializer) Progress() InitProgress {
|
||
i.mu.RLock()
|
||
defer i.mu.RUnlock()
|
||
return i.progress
|
||
}
|
||
|
||
// Run 同步执行一次全量初始化:按批读取启用轮询的卡,计算各类型到期并写入账户队列。返回写入的卡数。
|
||
func (i *CarrierInitializer) Run(ctx context.Context) (int64, error) {
|
||
if !i.running.CompareAndSwap(false, true) {
|
||
return 0, nil
|
||
}
|
||
defer i.running.Store(false)
|
||
started := time.Now()
|
||
total, err := i.iotCardStore.CountForPolling(ctx)
|
||
if err != nil {
|
||
i.setProgress(func(p *InitProgress) { p.Status, p.ErrorMessage = "failed", err.Error() })
|
||
return 0, err
|
||
}
|
||
i.setProgress(func(p *InitProgress) {
|
||
*p = InitProgress{TotalCards: total, StartTime: started, Status: "running"}
|
||
})
|
||
const batchSize = 2000
|
||
var lastID uint
|
||
var written int64
|
||
for {
|
||
if err := ctx.Err(); err != nil {
|
||
i.setProgress(func(p *InitProgress) { p.Status, p.ErrorMessage = "failed", err.Error() })
|
||
return written, err
|
||
}
|
||
cards, fetchErr := i.iotCardStore.ListForPollingBatch(ctx, lastID, batchSize)
|
||
if fetchErr != nil {
|
||
i.setProgress(func(p *InitProgress) { p.Status, p.ErrorMessage = "failed", fetchErr.Error() })
|
||
return written, fetchErr
|
||
}
|
||
if len(cards) == 0 {
|
||
break
|
||
}
|
||
if tier := i.scheduling.configMgr.TierResolver(); tier != nil {
|
||
tier.Prefill(ctx, cards)
|
||
}
|
||
for _, card := range cards {
|
||
i.scheduling.UpsertCard(ctx, card, true)
|
||
written++
|
||
}
|
||
lastID = cards[len(cards)-1].ID
|
||
loaded := written
|
||
i.setProgress(func(p *InitProgress) { p.LoadedCards, p.LastBatchTime = loaded, time.Now() })
|
||
}
|
||
i.setProgress(func(p *InitProgress) { p.Status = "completed" })
|
||
i.logger.Info("运营商账户轮询结构初始化完成", zap.Int64("cards", written), zap.Duration("duration", time.Since(started)))
|
||
return written, nil
|
||
}
|
||
|
||
func (i *CarrierInitializer) setProgress(update func(*InitProgress)) {
|
||
i.mu.Lock()
|
||
update(&i.progress)
|
||
i.mu.Unlock()
|
||
}
|