Files
junhong_cmp_fiber/internal/polling/recalculate.go
邹进 98017ac053
All checks were successful
构建并部署到测试环境(无 SSH) / build-and-deploy (push) Successful in 9m37s
feat: 分层轮询、重置日前加密与激活前流量结算
- 轮询配置新增套餐状态、资产状态、重置日前窗口与窗口内流量间隔(迁移 248),间隔三态:正数按间隔、0 不检查、空继承
- 配置按 priority, id 排序合并;在库与已销售无套餐未匹配时告警不入队
- 新增优先级整体重排、匹配预览、立即重算到期时间(异步只提前)、分层统计与重置日前加密统计接口
- 已切换日快照计量的卡流量按观测时间归属,激活前用量只记已结算
- 订单购买与实名激活补齐资产级激活锁,激活前对已切换卡结算一次流量,失败只告警不阻塞,结算不触发通道阈值判定
2026-10-24 17:06:38 +09:00

130 lines
4.1 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package polling
import (
"context"
"fmt"
"strconv"
"time"
"github.com/redis/go-redis/v9"
"go.uber.org/zap"
"gorm.io/gorm"
"github.com/break/junhong_cmp_fiber/internal/model"
"github.com/break/junhong_cmp_fiber/pkg/constants"
)
// recalculateBatchSize 是重算到期时间每批读取的卡数。
const recalculateBatchSize = 500
// RecalculateProgress 是重算到期时间任务的进度快照。
type RecalculateProgress struct {
Total int
Processed int
Advanced int // 被提前的检查项数
}
// DueRecalculator 按当前轮询配置重算已在队列中的卡的下次到期时间:新到期 = min(当前到期, 上次检查 + 新间隔),只提前不推后。
// 只更新已在分片队列中的成员(ZADD XX LT),不新增成员,避免把执行中的卡重复放回队列;不调用网关。
type DueRecalculator struct {
db *gorm.DB
redis *redis.Client
configMgr *PollingConfigManager
queueMgr *PollingQueueManager
logger *zap.Logger
}
// NewDueRecalculator 创建重算器。
func NewDueRecalculator(db *gorm.DB, redisClient *redis.Client, configMgr *PollingConfigManager, queueMgr *PollingQueueManager, logger *zap.Logger) *DueRecalculator {
if logger == nil {
logger = zap.NewNop()
}
return &DueRecalculator{db: db, redis: redisClient, configMgr: configMgr, queueMgr: queueMgr, logger: logger}
}
// Run 执行重算;carrierID 非空时只处理该运营商账户的卡。每处理一批回调一次进度。
func (r *DueRecalculator) Run(ctx context.Context, carrierID *uint, report func(RecalculateProgress)) (RecalculateProgress, error) {
var progress RecalculateProgress
if r == nil || r.db == nil || r.redis == nil || r.configMgr == nil || r.queueMgr == nil {
return progress, fmt.Errorf("重算到期时间能力未配置")
}
if err := r.configMgr.Load(ctx); err != nil {
return progress, err
}
base := r.db.WithContext(ctx).Model(&model.IotCard{}).Where("enable_polling = true AND deleted_at IS NULL")
if carrierID != nil {
base = base.Where("carrier_id = ?", *carrierID)
}
var total int64
if err := base.Count(&total).Error; err != nil {
return progress, err
}
progress.Total = int(total)
if report != nil {
report(progress)
}
var lastID uint
for {
if err := ctx.Err(); err != nil {
return progress, err
}
var cards []*model.IotCard
query := r.db.WithContext(ctx).Where("id > ? AND enable_polling = true AND deleted_at IS NULL", lastID)
if carrierID != nil {
query = query.Where("carrier_id = ?", *carrierID)
}
if err := query.Order("id ASC").Limit(recalculateBatchSize).Find(&cards).Error; err != nil {
return progress, err
}
if len(cards) == 0 {
break
}
lastID = cards[len(cards)-1].ID
advanced, err := r.recalculateBatch(ctx, cards)
if err != nil {
return progress, err
}
progress.Processed += len(cards)
progress.Advanced += advanced
if report != nil {
report(progress)
}
}
return progress, nil
}
func (r *DueRecalculator) recalculateBatch(ctx context.Context, cards []*model.IotCard) (int, error) {
if tier := r.configMgr.TierResolver(); tier != nil {
tier.Prefill(ctx, cards)
}
now := time.Now()
pipe := r.redis.Pipeline()
var cmds []*redis.IntCmd
for _, card := range cards {
shardID := int(card.ID) % r.queueMgr.shardCount
member := strconv.FormatUint(uint64(card.ID), 10)
for taskType, info := range r.configMgr.MergedTaskIntervals(card) {
due := calculateNextCheckTime(lastCheckAtByTaskType(card, taskType), info.Interval, now)
if windowDue := r.configMgr.NextCheckAt(ctx, card, taskType, info, now); windowDue.Before(due) && windowDue.After(now) {
due = windowDue
}
cmds = append(cmds, pipe.ZAddArgs(ctx, constants.RedisPollingShardQueueKey(shardID, taskType), redis.ZAddArgs{
XX: true, LT: true, Ch: true, Members: []redis.Z{{Score: float64(due.Unix()), Member: member}},
}))
}
}
if len(cmds) == 0 {
return 0, nil
}
if _, err := pipe.Exec(ctx); err != nil && err != redis.Nil {
return 0, err
}
advanced := 0
for _, cmd := range cmds {
if n, err := cmd.Result(); err == nil {
advanced += int(n)
}
}
return advanced, nil
}