Files
go-sms-V2/internal/service/interceptor/frequency.go
T

195 lines
5.9 KiB
Go

// frequency.go Day 42:频次拦截——滑动窗口,支持自然日/滚动 24h,同号码/同内容两维。
// 计数走 FreqStore 抽象:Redis ZSet(生产) / 内存(单测/降级);DryRun(预检)不计数。
package interceptor
import (
"context"
"fmt"
"hash/fnv"
"sync"
"time"
"go-sms/internal/model/entity"
errs "go-sms/internal/pkg/errors"
"github.com/redis/go-redis/v9"
"gorm.io/gorm"
)
// FreqStore 窗口计数:Incr 记录并返回窗口内第 N 次提交(1-based);Count 只读(预检)。
type FreqStore interface {
Incr(ctx context.Context, key string, window time.Duration) (int64, error)
Count(ctx context.Context, key string, window time.Duration) (int64, error)
}
// Frequency 频次拦截器(policy_frequency:dim/window_unit/max_count)。
type Frequency struct {
DB *gorm.DB // 策略库
Store FreqStore // 窗口计数
Now func() time.Time // 可注入时钟(测试)
}
// NewFrequency 构造(store nil 时用内存实现,仅建议测试/单机降级)。
func NewFrequency(db *gorm.DB, store FreqStore) *Frequency {
if store == nil {
store = NewMemoryFreqStore()
}
return &Frequency{DB: db, Store: store, Now: time.Now}
}
// Name 拦截器名。
func (f *Frequency) Name() string { return "frequency" }
// Check 逐条启用策略校验;白名单豁免;DryRun 只查不增。
func (f *Frequency) Check(ctx context.Context, r *Req) *Block {
if f == nil || f.DB == nil {
return nil
}
var policies []entity.PolicyFrequency
if r.Scope != nil {
// Day51 R3:白名单豁免复用快照集(与黑名单拦截器同一批查结果),
// 策略账号级一次 Find 跨号复用(查询失败=nil=放行,与逐号路径一致)。
if r.Scope.Whitelisted(r.Mobile) {
return nil
}
policies = r.Scope.FreqPolicies()
} else {
var wl int64
if err := f.DB.WithContext(ctx).Model(&entity.PolicyWhitelist{}).
Where("mobile = ? AND account_id IN ?", r.Mobile, []int64{0, r.AccountID}).
Count(&wl).Error; err == nil && wl > 0 {
return nil
}
if err := f.DB.WithContext(ctx).
Where("status = 1 AND account_id IN ?", []int64{0, r.AccountID}).
Order("id").Find(&policies).Error; err != nil {
return nil // 查询失败放行(可用性优先)
}
}
for _, p := range policies {
identity := r.Mobile
if p.Dim == 2 { // 同内容:内容哈希
h := fnv.New32a()
_, _ = h.Write([]byte(r.Content))
identity = fmt.Sprintf("c%x", h.Sum32())
}
var window time.Duration
var winTag string
if p.WindowUnit == 1 { // 自然日:窗口=至次日零点
now := f.Now()
next := time.Date(now.Year(), now.Month(), now.Day(), 24, 0, 0, 0, now.Location())
window = next.Sub(now)
winTag = "d" + now.Format("20060102")
} else { // 滚动 24h
window = 24 * time.Hour
winTag = "r24"
}
if window <= 0 {
window = time.Second
}
key := fmt.Sprintf("gosms:freq:%d:%d:%s:%s", p.AccountID, p.Dim, identity, winTag)
var n int64
var err error
if r.DryRun { // 预检:只读不占配额
n, err = f.Store.Count(ctx, key, window)
if err == nil && n >= int64(p.MaxCount) { // 已达上限即拦(第 max+1 次会被拒)
return f.block(p, r)
}
continue
}
n, err = f.Store.Incr(ctx, key, window)
if err != nil {
continue // 存储故障放行
}
if n > int64(p.MaxCount) {
return f.block(p, r)
}
}
return nil
}
func (f *Frequency) block(p entity.PolicyFrequency, _ *Req) *Block {
e := errs.SendLimited.WithMsg(fmt.Sprintf("频次超限:策略#%d %s最多 %d 条", p.ID,
map[int8]string{1: "同号码", 2: "同内容"}[p.Dim], p.MaxCount))
return &Block{Interceptor: f.Name(), Code: e.Code, Msg: e.Msg, HTTP: e}
}
// MemoryFreqStore 内存滑动窗口(测试/单机降级;非分布式安全)。
type MemoryFreqStore struct {
mu sync.Mutex
data map[string][]time.Time
now func() time.Time
}
// NewMemoryFreqStore 构造内存滑窗。
func NewMemoryFreqStore() *MemoryFreqStore {
return &MemoryFreqStore{data: make(map[string][]time.Time), now: time.Now}
}
// Incr 记录并返回窗口内次数(过期清除)。
func (m *MemoryFreqStore) Incr(_ context.Context, key string, window time.Duration) (int64, error) {
m.mu.Lock()
defer m.mu.Unlock()
now := m.now()
kept := prune(m.data[key], now, window)
kept = append(kept, now)
m.data[key] = kept
return int64(len(kept)), nil
}
// Count 只读窗口内次数。
func (m *MemoryFreqStore) Count(_ context.Context, key string, window time.Duration) (int64, error) {
m.mu.Lock()
defer m.mu.Unlock()
kept := prune(m.data[key], m.now(), window)
m.data[key] = kept
return int64(len(kept)), nil
}
// prune 清除窗口外时间戳(返回原地切片)。
func prune(list []time.Time, now time.Time, window time.Duration) []time.Time {
kept := list[:0]
for _, t := range list {
if now.Sub(t) < window {
kept = append(kept, t)
}
}
return kept
}
// RedisFreqStore Redis ZSet 滑动窗口(ZADD/ZREMRANGEBYSCORE/ZCARD+EXPIRE)。
type RedisFreqStore struct {
RDB redis.UniversalClient
Now func() time.Time
}
// NewRedisFreqStore 构造。
func NewRedisFreqStore(rdb redis.UniversalClient) *RedisFreqStore {
return &RedisFreqStore{RDB: rdb, Now: time.Now}
}
// Incr ZSet 滑窗计数(score/member 均纳秒精度,同毫秒多次不合并)。
func (s *RedisFreqStore) Incr(ctx context.Context, key string, window time.Duration) (int64, error) {
now := s.Now()
ns := now.UnixNano()
exp := ns - window.Nanoseconds()
pipe := s.RDB.TxPipeline()
pipe.ZRemRangeByScore(ctx, key, "-inf", fmt.Sprintf("(%d", exp))
pipe.ZAdd(ctx, key, redis.Z{Score: float64(ns), Member: ns})
pipe.Expire(ctx, key, window+time.Minute)
if _, err := pipe.Exec(ctx); err != nil {
return 0, err
}
return s.RDB.ZCard(ctx, key).Result()
}
// Count 只读窗口内次数(预检;仅清过期不写入)。
func (s *RedisFreqStore) Count(ctx context.Context, key string, window time.Duration) (int64, error) {
exp := s.Now().UnixNano() - window.Nanoseconds()
if err := s.RDB.ZRemRangeByScore(ctx, key, "-inf", fmt.Sprintf("(%d", exp)).Err(); err != nil {
return 0, err
}
return s.RDB.ZCard(ctx, key).Result()
}