S1-B D2.1: B 层搬运 interceptor(拦截链:黑白名单/关键字/频次/码号,P1 等价零改动,13 文件;原样语义:命中终态5+退费链路上游接口)

This commit is contained in:
2026-11-13 16:32:44 +08:00
parent 59866809fb
commit a3a180a4a9
13 changed files with 1418 additions and 0 deletions
+112
View File
@@ -0,0 +1,112 @@
// blacklist.go Day 42:黑名单三级检测(白名单豁免)。
package interceptor
import (
"context"
"go-sms/internal/model/entity"
errs "go-sms/internal/pkg/errors"
"github.com/redis/go-redis/v9"
"gorm.io/gorm"
)
// BlacklistCacheKey 本地黑名单 Redis Set(持久,技术方案 9.3)。
const BlacklistCacheKey = "gosms:blacklist:local"
// ThirdPartyBlacklist 三级检测接口(第三方黑名单 API;生产按上家适配器实现)。
type ThirdPartyBlacklist interface {
CheckBlacklist(ctx context.Context, mobile string) (hit bool, err error)
}
// Blacklist 黑名单拦截器(三级+白名单豁免)。
type Blacklist struct {
DB *gorm.DB // 二级:本地库(必传)
RDB redis.UniversalClient // 一级:Redis 缓存(可 nil=降级直查库)
Third ThirdPartyBlacklist // 三级:第三方(可 nil=跳过)
}
// NewBlacklist 构造。
func NewBlacklist(db *gorm.DB, rdb redis.UniversalClient, third ThirdPartyBlacklist) *Blacklist {
return &Blacklist{DB: db, RDB: rdb, Third: third}
}
// Name 拦截器名。
func (b *Blacklist) Name() string { return "blacklist" }
// Check 三级检测;DB/Redis 瞬时故障按放行处理(可用性优先,漏拦由三级兜底)。
func (b *Blacklist) Check(ctx context.Context, r *Req) *Block {
if b == nil || b.DB == nil {
return nil
}
hit := func() *Block {
return &Block{Interceptor: b.Name(), Code: errs.Blacklist.Code,
Msg: "黑名单号码", HTTP: errs.Blacklist}
}
// Day51 R3:请求级快照路径(批量提交/预检)——白名单/黑名单各一次 IN 批查,
// Redis 一级 SMIsMember 批量;语义与逐号路径一致(豁免→一级→二级→三级)。
if r.Scope != nil {
if r.Scope.Whitelisted(r.Mobile) {
return nil
}
if b.RDB != nil && r.Scope.RedisBlacklisted(b.RDB, r.Mobile) {
return hit()
}
if r.Scope.Blacklisted(r.Mobile) {
b.cacheAdd(ctx, r.Mobile) // 命中回写(少数路径,单号回写足够)
return hit()
}
if b.Third != nil {
if ok, err := b.Third.CheckBlacklist(ctx, r.Mobile); err == nil && ok {
b.cacheAdd(ctx, r.Mobile)
return hit()
}
}
return nil
}
// 白名单豁免(账号级或全局 account_id=0)。
var wl int64
if err := b.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
}
// 一级:Redis 缓存。
if b.RDB != nil {
if n, err := b.RDB.SIsMember(ctx, BlacklistCacheKey, r.Mobile).Result(); err == nil && n {
return hit()
}
}
// 二级:本地库(手工/上行拒收/第三方来源)。
var cnt int64
if err := b.DB.WithContext(ctx).Model(&entity.PolicyBlacklist{}).
Where("mobile = ? AND account_id IN ?", r.Mobile, []int64{0, r.AccountID}).
Count(&cnt).Error; err == nil && cnt > 0 {
b.cacheAdd(ctx, r.Mobile)
return hit()
}
// 三级:第三方黑名单 API。
if b.Third != nil {
if ok, err := b.Third.CheckBlacklist(ctx, r.Mobile); err == nil && ok {
b.cacheAdd(ctx, r.Mobile)
return hit()
}
}
return nil
}
// cacheAdd 命中回写 Redis 缓存(尽力而为)。
func (b *Blacklist) cacheAdd(ctx context.Context, mobile string) {
if b.RDB != nil {
_ = b.RDB.SAdd(ctx, BlacklistCacheKey, mobile).Err()
}
}
// AddBlacklistCache 黑名单入库后同步缓存(策略中心写路径可调用)。
func AddBlacklistCache(ctx context.Context, rdb redis.UniversalClient, mobile string) error {
if rdb == nil {
return nil
}
return rdb.SAdd(ctx, BlacklistCacheKey, mobile).Err()
}
@@ -0,0 +1,94 @@
// blacklist_test.go Day 42:黑名单三级检测+白名单豁免。
package interceptor
import (
"context"
"testing"
"github.com/alicebob/miniredis/v2"
"github.com/redis/go-redis/v9"
"go-sms/internal/model/entity"
)
// thirdStub 三级接口桩。
type thirdStub struct{ hitFor map[string]bool }
func (s *thirdStub) CheckBlacklist(_ context.Context, mobile string) (bool, error) {
return s.hitFor[mobile], nil
}
// TestBlacklistLevels 验收:白名单豁免 → 本地库二级命中 → 三级第三方命中 → Redis 一级缓存。
func TestBlacklistLevels(t *testing.T) {
db := newTestDB(t)
mr := miniredis.RunT(t)
rdb := redis.NewClient(&redis.Options{Addr: mr.Addr()})
defer func() { _ = rdb.Close() }()
bl := NewBlacklist(db, rdb, &thirdStub{hitFor: map[string]bool{"13599990000": true}})
ctx := context.Background()
req := func(m string) *Req {
return &Req{AccountID: 5, Mobile: m, Content: "【测试】内容"}
}
// 未配置:全放行。
if bl.Check(ctx, req("13800000001")) != nil {
t.Fatal("无配置应放行")
}
// 二级:本地库命中(账号级)。
if err := db.Create(&entity.PolicyBlacklist{Mobile: "13800000002", AccountID: 5}).Error; err != nil {
t.Fatal(err)
}
if b := bl.Check(ctx, req("13800000002")); b == nil || b.Code != "ISC:006" {
t.Fatalf("本地库应拦截: %+v", b)
}
// 一级:二级命中已写回 Redis——删库后仍拦(缓存生效)。
if err := db.Where("mobile = ?", "13800000002").Delete(&entity.PolicyBlacklist{}).Error; err != nil {
t.Fatal(err)
}
if b := bl.Check(ctx, req("13800000002")); b == nil || b.Interceptor != "blacklist" {
t.Fatalf("Redis 缓存应拦截: %+v", b)
}
// 一级直接命中:预写缓存。
if err := rdb.SAdd(ctx, BlacklistCacheKey, "13800000003").Err(); err != nil {
t.Fatal(err)
}
if bl.Check(ctx, req("13800000003")) == nil {
t.Fatal("Redis 预写应拦截")
}
// 三级:第三方命中(本地库+缓存均无)。
if b := bl.Check(ctx, req("13599990000")); b == nil {
t.Fatal("第三方黑名单应拦截")
}
// 三级命中也回写缓存:断网第三方后仍拦。
blThirdDown := NewBlacklist(db, rdb, nil)
if blThirdDown.Check(ctx, req("13599990000")) == nil {
t.Fatal("三级命中回写缓存后应拦截")
}
// 白名单豁免:全局白名单压过本地黑名单。
if err := db.Create(&entity.PolicyBlacklist{Mobile: "13800000004", AccountID: 0}).Error; err != nil {
t.Fatal(err)
}
if err := db.Create(&entity.PolicyWhitelist{Mobile: "13800000004", AccountID: 0}).Error; err != nil {
t.Fatal(err)
}
if b := bl.Check(ctx, req("13800000004")); b != nil {
t.Fatalf("白名单应豁免黑名单: %+v", b)
}
// 全局黑名单(account_id=0)对任意账号生效。
if b := bl.Check(ctx, &Req{AccountID: 99, Mobile: "13800000005",
Content: "x"}); b == nil {
_ = b // 13599990000 之外的号无配置
}
if err := db.Create(&entity.PolicyBlacklist{Mobile: "13800000006", AccountID: 0}).Error; err != nil {
t.Fatal(err)
}
if bl.Check(ctx, &Req{AccountID: 99, Mobile: "13800000006", Content: "x"}) == nil {
t.Fatal("全局黑名单应拦截任意账号")
}
}
+55
View File
@@ -0,0 +1,55 @@
// default.go Day 42:默认链装配(固定顺序:黑名单→频次→签名→退订→地区)。
package interceptor
import (
"context"
"go-sms/internal/model/entity"
"github.com/redis/go-redis/v9"
"gorm.io/gorm"
)
// Options 链装配选项(零值=最小可用:仅黑名单本地库+频次内存计数+签名存在性)。
type Options struct {
ThirdBlacklist ThirdPartyBlacklist
FreqStore FreqStore // nil=内存(生产建议 NewRedisFreqStore)
SignAllow SignAllowlist
UnsubRequired bool
UnsubKeywords []string
RegionResolver RegionResolver
BlockedRegions []string
}
// NewDefaultChain 默认五类链(硬拦截在前:黑名单→频次→签名→退订→地区)。
func NewDefaultChain(db *gorm.DB, rdb redis.UniversalClient, rec Recorder, opt Options) *Chain {
c := NewChain(rec,
NewBlacklist(db, rdb, opt.ThirdBlacklist),
NewFrequency(db, opt.FreqStore),
NewSign(opt.SignAllow),
NewUnsubscribe(opt.UnsubRequired, opt.UnsubKeywords),
NewRegion(opt.RegionResolver, opt.BlockedRegions),
)
c.db = db // Day51:NewScope 依赖(与拦截器同库)
return c
}
// DBRecorder 拦截原因落库 send_block_log(同步写,拦截为少数路径)。
type DBRecorder struct {
DB *gorm.DB
}
// NewDBRecorder 构造。
func NewDBRecorder(db *gorm.DB) *DBRecorder { return &DBRecorder{DB: db} }
// Record 落库(失败仅吞错——拦截结论已定,落库失败不反向影响发送判定)。
func (d *DBRecorder) Record(ctx context.Context, r *Req, b *Block) {
if d == nil || d.DB == nil || b == nil {
return
}
_ = d.DB.WithContext(ctx).Create(&entity.SendBlockLog{
TaskNo: r.TaskNo, AccountID: r.AccountID, Mobile: r.Mobile,
Interceptor: b.Interceptor, Code: b.Code, Msg: b.Msg,
}).Error
}
+194
View File
@@ -0,0 +1,194 @@
// 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()
}
@@ -0,0 +1,165 @@
// frequency_test.go Day 42:频次滑动窗口——自然日/滚动 24h/同内容维/DryRun/Redis 实现。
package interceptor
import (
"context"
"testing"
"time"
"github.com/alicebob/miniredis/v2"
"github.com/redis/go-redis/v9"
"go-sms/internal/model/entity"
)
// TestFrequencyNaturalDay 验收:同号码自然日窗口 max_count=2,第 3 次拦截(ISC:032)。
func TestFrequencyNaturalDay(t *testing.T) {
db := newTestDB(t)
if err := db.Create(&entity.PolicyFrequency{
AccountID: 1, Dim: 1, WindowUnit: 1, MaxCount: 2, Status: 1,
}).Error; err != nil {
t.Fatal(err)
}
f := NewFrequency(db, nil)
ctx := context.Background()
req := &Req{AccountID: 1, Mobile: "13811112222", Content: "【测试】内容"}
for i := 1; i <= 2; i++ {
if b := f.Check(ctx, req); b != nil {
t.Fatalf("第 %d 次不应拦截", i)
}
}
b := f.Check(ctx, req)
if b == nil || b.Code != "ISC:032" || b.Interceptor != "frequency" {
t.Fatalf("第 3 次应频次拦截 ISC:032: %+v", b)
}
}
// TestFrequencyRolling24h 验收:滚动 24h 窗口过期后放行(注入时钟)。
func TestFrequencyRolling24h(t *testing.T) {
db := newTestDB(t)
if err := db.Create(&entity.PolicyFrequency{
AccountID: 1, Dim: 1, WindowUnit: 2, MaxCount: 1, Status: 1,
}).Error; err != nil {
t.Fatal(err)
}
now := time.Now()
store := NewMemoryFreqStore()
f := &Frequency{DB: db, Store: store, Now: func() time.Time { return now }}
ctx := context.Background()
req := &Req{AccountID: 1, Mobile: "13822223333", Content: "【测试】x"}
if b := f.Check(ctx, req); b != nil {
t.Fatal("第 1 次应放行")
}
if f.Check(ctx, req) == nil {
t.Fatal("第 2 次应拦截(滚动窗内)")
}
now = now.Add(25 * time.Hour) // 窗口滑出
store.now = func() time.Time { return now } // 内存 store 同步时钟
f.Now = func() time.Time { return now }
if b := f.Check(ctx, req); b != nil {
t.Fatalf("窗口过期后应放行: %+v", b)
}
}
// TestFrequencyContentDim 验收:同内容维(dim=2)不同号码同内容受限;换内容放行。
func TestFrequencyContentDim(t *testing.T) {
db := newTestDB(t)
if err := db.Create(&entity.PolicyFrequency{
AccountID: 1, Dim: 2, WindowUnit: 1, MaxCount: 1, Status: 1,
}).Error; err != nil {
t.Fatal(err)
}
f := NewFrequency(db, nil)
ctx := context.Background()
c1 := "【测试】活动 A"
if b := f.Check(ctx, &Req{AccountID: 1, Mobile: "13800000001", Content: c1}); b != nil {
t.Fatal("首条同内容应放行")
}
if f.Check(ctx, &Req{AccountID: 1, Mobile: "13800000002", Content: c1}) == nil {
t.Fatal("不同号码同内容(超限)应拦截")
}
if b := f.Check(ctx, &Req{AccountID: 1, Mobile: "13800000003", Content: "【测试】活动 B"}); b != nil {
t.Fatal("换内容应放行")
}
}
// TestFrequencyDryRun 验收:预检只读不占配额。
func TestFrequencyDryRun(t *testing.T) {
db := newTestDB(t)
if err := db.Create(&entity.PolicyFrequency{
AccountID: 1, Dim: 1, WindowUnit: 1, MaxCount: 1, Status: 1,
}).Error; err != nil {
t.Fatal(err)
}
f := NewFrequency(db, nil)
ctx := context.Background()
// 已发送 1 次(占满配额)。
_ = f.Check(ctx, &Req{AccountID: 1, Mobile: "13833334444", Content: "x"})
// DryRun:已达上限报告拦截,且不增加计数。
dry := &Req{AccountID: 1, Mobile: "13833334444", Content: "x", DryRun: true}
if f.Check(ctx, dry) == nil {
t.Fatal("DryRun 已满配额应报告拦截")
}
if f.Check(ctx, dry) == nil {
t.Fatal("DryRun 重复调用仍应拦截(未占新配额)")
}
// DryRun 不占配额:另一未用号 DryRun 不拦且之后真发仍放行。
fresh := &Req{AccountID: 1, Mobile: "13833335555", Content: "x"}
freshDry := &Req{AccountID: 1, Mobile: "13833335555", Content: "x", DryRun: true}
if f.Check(ctx, freshDry) != nil {
t.Fatal("未用号 DryRun 应放行")
}
if b := f.Check(ctx, fresh); b != nil {
t.Fatalf("DryRun 不应占配额: %+v", b)
}
}
// TestFrequencyWhitelistExempt 验收:白名单豁免频次。
func TestFrequencyWhitelistExempt(t *testing.T) {
db := newTestDB(t)
if err := db.Create(&entity.PolicyFrequency{
AccountID: 1, Dim: 1, WindowUnit: 1, MaxCount: 1, Status: 1,
}).Error; err != nil {
t.Fatal(err)
}
if err := db.Create(&entity.PolicyWhitelist{Mobile: "13844445555", AccountID: 1}).Error; err != nil {
t.Fatal(err)
}
f := NewFrequency(db, nil)
ctx := context.Background()
req := &Req{AccountID: 1, Mobile: "13844445555", Content: "x"}
for i := 0; i < 3; i++ {
if b := f.Check(ctx, req); b != nil {
t.Fatalf("白名单第 %d 次应豁免: %+v", i+1, b)
}
}
}
// TestRedisFreqStore 验收:Redis ZSet 滑窗与内存实现行为一致。
func TestRedisFreqStore(t *testing.T) {
mr := miniredis.RunT(t)
rdb := redis.NewClient(&redis.Options{Addr: mr.Addr()})
defer func() { _ = rdb.Close() }()
s := NewRedisFreqStore(rdb)
ctx := context.Background()
const key = "gosms:freq:test"
for i := int64(1); i <= 3; i++ {
n, err := s.Incr(ctx, key, time.Hour)
if err != nil || n != i {
t.Fatalf("Incr 第 %d 次: n=%d err=%v", i, n, err)
}
}
// 窗口滑出:快进 61 分钟(miniredis 快进真实时间不可,直接清过期分数)。
mr.FastForward(61 * time.Minute)
n, err := s.Incr(ctx, key, time.Hour)
if err != nil || n != 1 {
t.Fatalf("窗口过期后应重新计数: n=%d err=%v", n, err)
}
// Count 只读。
if c, err := s.Count(ctx, key, time.Hour); err != nil || c != 1 {
t.Fatalf("Count 只读应=1: c=%d err=%v", c, err)
}
if n, _ := s.Incr(ctx, key, time.Hour); n != 2 {
t.Fatal("Count 后 Incr 应=2(只读未写入)")
}
}
@@ -0,0 +1,89 @@
// Package interceptor Day 42(阶段 4):发送前拦截器链——
// 黑名单三级(白名单豁免) / 频次滑动窗口 / 签名 / 退订标识 / 地区屏蔽,
// 命中短路并经 Recorder 落库 send_block_log;Day 46 提交主链与 /send/precheck 预检共用。
package interceptor
import (
"context"
errs "go-sms/internal/pkg/errors"
"gorm.io/gorm"
)
// Req 拦截器入参(单号码粒度;Content 为渲染后完整内容=签名+正文)。
type Req struct {
TaskNo string
AccountID int64
Mobile string
Content string
SendType int8
// DryRun 预检模式(D18/调试):不产生频次计数等副作用,只报告当前状态。
DryRun bool
// Scope 请求级数据快照(Day51 R3):批量提交/预检时由 Chain.NewScope 构造,
// 拦截器经其批量 IN+跨号复用消除逐号重复查库;nil=逐号旧路径(单号调用)。
Scope *Scope
}
// Block 拦截结果( nil=放行)。
type Block struct {
Interceptor string // 命中的拦截器名(链内唯一)
Code string // ISC 码(落库/前端字典)
Msg string // 拒绝原因(落库/响应)
HTTP *errs.Error // HTTP 语义错误(已 WithMsg)
}
// Interceptor 单个拦截器:Check 返回 nil 放行。
type Interceptor interface {
Name() string
Check(ctx context.Context, r *Req) *Block
}
// Recorder 拦截原因落库(Day 42 验收:拦截原因落库)。
type Recorder interface {
Record(ctx context.Context, r *Req, b *Block)
}
// Chain 有序拦截器链:按序执行,首个命中短路返回;命中经 Recorder 落库。
// 固定顺序(硬拦截在前):黑名单 → 频次 → 签名 → 退订 → 地区(NewDefaultChain)。
type Chain struct {
items []Interceptor
rec Recorder // 可 nil(测试/预检不落库)
db *gorm.DB // Day51:NewScope 依赖(装配库;NewChain 直造为零值=scope 降级放行)
}
// NewChain 构造链(items 顺序即执行顺序)。
func NewChain(rec Recorder, items ...Interceptor) *Chain {
return &Chain{items: items, rec: rec}
}
// NewScope 生成请求级快照(Day51 R3:批量提交/预检的拦截链入口调用;
// 逐号 Check 前构造一次,所有拦截器共享;db 取链装配库;nil 链返回 nil=降级逐号)。
func (c *Chain) NewScope(ctx context.Context, accountID int64, mobiles []string) *Scope {
if c == nil {
return nil
}
return NewScope(ctx, c.db, accountID, mobiles)
}
// Names 链顺序(验收:命中顺序符合配置)。
func (c *Chain) Names() []string {
out := make([]string, len(c.items))
for i, it := range c.items {
out[i] = it.Name()
}
return out
}
// Check 执行链:返回首个 Block(命中即短路并落库),nil=放行。
func (c *Chain) Check(ctx context.Context, r *Req) *Block {
for _, it := range c.items {
if b := it.Check(ctx, r); b != nil {
if c.rec != nil && !r.DryRun { // DryRun 预检不落库(仅真实提交拦截留痕)
c.rec.Record(ctx, r, b)
}
return b
}
}
return nil
}
@@ -0,0 +1,113 @@
// interceptor_test.go Day 42:链顺序/短路/Recorder 落库调用——验收「命中顺序符合配置」。
package interceptor
import (
"context"
"testing"
"github.com/glebarez/sqlite"
"gorm.io/gorm"
"go-sms/internal/model/entity"
)
// newTestDB 建 sqlite 内存库并建策略/拦截日志表。
// 注:policy_blacklist 与 policy_whitelist 同用索引名 uk_mobile_account,
// glebarez sqlite 索引名为库级作用域(与 MySQL 表级不同),第二表建索引报错但表已建好,
// 故忽略该错误(列结构完整,查询不受影响)。
func newTestDB(t *testing.T) *gorm.DB {
t.Helper()
db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
if err != nil {
t.Fatal(err)
}
if sqlDB, e := db.DB(); e == nil {
sqlDB.SetMaxOpenConns(1)
}
_ = db.AutoMigrate(&entity.PolicyBlacklist{})
_ = db.AutoMigrate(&entity.PolicyWhitelist{})
if err := db.AutoMigrate(&entity.PolicyFrequency{}, &entity.SendBlockLog{}); err != nil {
t.Fatal(err)
}
for _, tbl := range []string{"policy_blacklist", "policy_whitelist"} {
if !db.Migrator().HasTable(tbl) {
t.Fatalf("表 %s 未建成", tbl)
}
}
return db
}
// fakeInt 可控行为拦截器。
type fakeInt struct {
name string
hit bool
}
func (f *fakeInt) Name() string { return f.name }
func (f *fakeInt) Check(_ context.Context, _ *Req) *Block {
if !f.hit {
return nil
}
return &Block{Interceptor: f.name, Code: "ISC:000", Msg: "hit " + f.name}
}
// memRec 内存 Recorder。
type memRec struct{ rows []SendBlockLogRow }
// SendBlockLogRow Recorder 收到的简化行。
type SendBlockLogRow struct {
Mobile, Interceptor, Code string
}
func (m *memRec) Record(_ context.Context, r *Req, b *Block) {
m.rows = append(m.rows, SendBlockLogRow{Mobile: r.Mobile, Interceptor: b.Interceptor, Code: b.Code})
}
// TestChainOrderAndShortCircuit 验收:默认链顺序固定;首个命中短路;Recorder 收到命中行。
func TestChainOrderAndShortCircuit(t *testing.T) {
// 顺序:黑名单→频次→签名→退订→地区(硬拦截在前)
c := NewDefaultChain(newTestDB(t), nil, nil, Options{})
want := []string{"blacklist", "frequency", "sign", "unsubscribe", "region"}
got := c.Names()
if len(got) != len(want) {
t.Fatalf("链长 %d != %d", len(got), len(want))
}
for i := range want {
if got[i] != want[i] {
t.Fatalf("链顺序不符: %v", got)
}
}
// 短路:首拦截器命中,后续不再执行;Recorder 收到一次。
rec := &memRec{}
a, b := &fakeInt{"a", true}, &fakeInt{"b", true}
ch := NewChain(rec, a, b)
blk := ch.Check(context.Background(), &Req{Mobile: "13800000000"})
if blk == nil || blk.Interceptor != "a" {
t.Fatalf("应命中首个拦截器 a: %+v", blk)
}
if len(rec.rows) != 1 || rec.rows[0].Interceptor != "a" {
t.Fatalf("Recorder 应收到 1 行 a: %+v", rec.rows)
}
// 放行链:全过。
ch2 := NewChain(nil, &fakeInt{"a", false}, &fakeInt{"b", false})
if ch2.Check(context.Background(), &Req{}) != nil {
t.Fatal("全放行链应返回 nil")
}
}
// TestDBRecorder 验收:拦截原因落库 send_block_log。
func TestDBRecorder(t *testing.T) {
db := newTestDB(t)
rec := NewDBRecorder(db)
rec.Record(context.Background(), &Req{TaskNo: "T1", AccountID: 7, Mobile: "13911112222"},
&Block{Interceptor: "blacklist", Code: "ISC:006", Msg: "黑名单号码"})
var rows []entity.SendBlockLog
if err := db.Find(&rows).Error; err != nil || len(rows) != 1 {
t.Fatalf("应落 1 行: err=%v n=%d", err, len(rows))
}
r := rows[0]
if r.TaskNo != "T1" || r.Mobile != "13911112222" || r.Interceptor != "blacklist" || r.Code != "ISC:006" {
t.Fatalf("落库字段不符: %+v", r)
}
}
+135
View File
@@ -0,0 +1,135 @@
// misc_test.go Day 42:签名/退订/地区拦截单测。
package interceptor
import (
"context"
"testing"
"go-sms/internal/model/entity"
)
// TestSign 验收:缺【】签名拦截;有签名放行;白名单外签名拦截。
func TestSign(t *testing.T) {
ctx := context.Background()
s := NewSign(nil)
if b := s.Check(ctx, &Req{Content: "无签名内容"}); b == nil || b.Code != "ISC:004" {
t.Fatalf("缺签名应拦截 ISC:004: %+v", b)
}
if b := s.Check(ctx, &Req{Content: "【云端科技】您的验证码 1234"}); b != nil {
t.Fatalf("含签名应放行: %+v", b)
}
// 提取规则:首个【】。
if got := ExtractSign("【A】x【B】y"); got != "A" {
t.Fatalf("应取首个签名: %q", got)
}
if got := ExtractSign("【】内容"); got != "" {
t.Fatalf("空签名应视为无: %q", got)
}
// 白名单:未报备拦截/已报备放行。
allow := signAllowStub{map[int64][]string{9: {"云端科技"}}}
s2 := NewSign(allow)
if b := s2.Check(ctx, &Req{AccountID: 9, Content: "【野签名】x"}); b == nil {
t.Fatal("白名单外签名应拦截")
}
if b := s2.Check(ctx, &Req{AccountID: 9, Content: "【云端科技】x"}); b != nil {
t.Fatalf("白名单内签名应放行: %+v", b)
}
if b := s2.Check(ctx, &Req{AccountID: 8, Content: "【任意】x"}); b != nil {
t.Fatalf("无白名单配置账号应放行: %+v", b)
}
}
type signAllowStub struct{ m map[int64][]string }
func (s signAllowStub) AllowedSigns(_ context.Context, id int64) ([]string, error) {
return s.m[id], nil
}
// TestUnsubscribe 验收:Required 时末尾须含退订标识;非 Required 放行。
func TestUnsubscribe(t *testing.T) {
ctx := context.Background()
u := NewUnsubscribe(true, nil)
if b := u.Check(ctx, &Req{Content: "【云】促销 5 折"}); b == nil || b.Code != "ISC:031" {
t.Fatalf("缺退订标识应拦截 ISC:031: %+v", b)
}
if b := u.Check(ctx, &Req{Content: "【云】促销 5 折 拒收请回复R"}); b != nil {
t.Fatalf("末尾含标识应放行: %+v", b)
}
if b := u.Check(ctx, &Req{Content: "【云】促销 5 折 拒收请回复R\n"}); b != nil {
t.Fatalf("尾随空白应容忍: %+v", b)
}
// 标识不在末尾(正文中)不满足。
if u.Check(ctx, &Req{Content: "拒收请回复R【云】促销"}) == nil {
t.Fatal("标识须在末尾")
}
// 非强制:放行。
if b := NewUnsubscribe(false, nil).Check(ctx, &Req{Content: "【云】x"}); b != nil {
t.Fatalf("非强制应放行: %+v", b)
}
}
// TestRegion 验收:归属省命中屏蔽列表拦截(ISC:036);未命中/未启用放行。
func TestRegion(t *testing.T) {
ctx := context.Background()
resolver := RegionFunc(func(mobile string) string {
if len(mobile) == 11 && mobile[:3] == "199" {
return "新疆"
}
return "广东"
})
g := NewRegion(resolver, []string{"新疆", "西藏"})
if b := g.Check(ctx, &Req{Mobile: "19900001111"}); b == nil || b.Code != "ISC:036" {
t.Fatalf("屏蔽省应拦截 ISC:036: %+v", b)
}
if b := g.Check(ctx, &Req{Mobile: "13800001111"}); b != nil {
t.Fatalf("非屏蔽省应放行: %+v", b)
}
// 未启用:resolver nil / 空列表。
if NewRegion(nil, []string{"新疆"}).Check(ctx, &Req{Mobile: "19900001111"}) != nil {
t.Fatal("未启用解析器应放行")
}
if NewRegion(resolver, nil).Check(ctx, &Req{Mobile: "19900001111"}) != nil {
t.Fatal("空屏蔽列表应放行")
}
}
// TestChainEndToEnd 验收(链路):黑名单优先于频次;频次优先于签名(顺序即配置)。
func TestChainEndToEnd(t *testing.T) {
db := newTestDB(t)
ctx := context.Background()
// 黑名单(全局)+频次策略(max=1)同号配置。
if err := db.Create(&entity.PolicyBlacklist{Mobile: "13811112222", AccountID: 0}).Error; err != nil {
t.Fatal(err)
}
if err := db.Create(&entity.PolicyFrequency{
AccountID: 1, Dim: 1, WindowUnit: 1, MaxCount: 1, Status: 1,
}).Error; err != nil {
t.Fatal(err)
}
c := NewDefaultChain(db, nil, nil, Options{FreqStore: NewMemoryFreqStore()})
req := &Req{AccountID: 1, Mobile: "13811112222", Content: "【云】无退订标识"}
// 1) 黑名单(链首)——同号黑名单+频次满配,应报黑名单(链序在前)。
_ = c.Check(ctx, req) // 占频次一次(实际被黑名单短路,但频次未执行)
if b := c.Check(ctx, req); b == nil || b.Interceptor != "blacklist" {
t.Fatalf("应先命中黑名单: %+v", b)
}
// 2) 移除黑名单后→频次(策略 max=1,首过)。
if err := db.Where("mobile = ?", "13811112222").Delete(&entity.PolicyBlacklist{}).Error; err != nil {
t.Fatal(err)
}
if b := c.Check(ctx, req); b != nil {
t.Fatalf("首次频次应放行: %+v", b)
}
if b := c.Check(ctx, req); b == nil || b.Interceptor != "frequency" {
t.Fatalf("二次应频次拦截: %+v", b)
}
// 3) 换新号(无频次负担)→签名(无【】)。
if b := c.Check(ctx, &Req{AccountID: 1, Mobile: "13899998888", Content: "无签名"}); b == nil || b.Interceptor != "sign" {
t.Fatalf("应签名拦截: %+v", b)
}
// 4) 新号有签名,退订默认非强制、地区未启用→放行。
// (13899998888 在步骤 3 已被频次计数占满——链序频次先于签名,属正确语义,故换新号)
if b := c.Check(ctx, &Req{AccountID: 1, Mobile: "13899997777", Content: "【云】验证码 1"}); b != nil {
t.Fatalf("应放行: %+v", b)
}
}
+54
View File
@@ -0,0 +1,54 @@
// region.go Day 42:地区屏蔽拦截——号码归属省命中屏蔽列表则拒绝。
// 归属地解析经 RegionResolver 注入(号段库 Day 后续接入;nil=不启用);
// 屏蔽列表全局起步,账号/通道级 Day47 调度器接入。
package interceptor
import (
"context"
errs "go-sms/internal/pkg/errors"
)
// RegionResolver 号码归属省解析(如「新疆」;空串=未知放行)。
type RegionResolver interface {
Region(mobile string) string
}
// RegionFunc 函数适配。
type RegionFunc func(mobile string) string
// Region 实现 RegionFunc。
func (f RegionFunc) Region(mobile string) string { return f(mobile) }
// Region 地区屏蔽拦截器。
type Region struct {
Resolver RegionResolver // 可 nil=不启用
Blocked []string // 屏蔽省列表
}
// NewRegion 构造。
func NewRegion(resolver RegionResolver, blocked []string) *Region {
return &Region{Resolver: resolver, Blocked: blocked}
}
// Name 拦截器名。
func (g *Region) Name() string { return "region" }
// Check 归属省命中屏蔽列表 → ISC:036。
func (g *Region) Check(_ context.Context, r *Req) *Block {
if g == nil || g.Resolver == nil || len(g.Blocked) == 0 {
return nil
}
region := g.Resolver.Region(r.Mobile)
if region == "" {
return nil
}
for _, b := range g.Blocked {
if b == region {
e := errs.BlockedRegion.WithMsg("地区屏蔽: " + region)
return &Block{Interceptor: g.Name(), Code: e.Code, Msg: e.Msg, HTTP: e}
}
}
return nil
}
+128
View File
@@ -0,0 +1,128 @@
// scope.go Day 51(R3 性能债专项 1/4):请求级数据快照——同一次提交/预检内,
// 账号级数据(频次策略/签名白名单)只查一次,号码级数据(白名单/黑名单)批量 IN 一次取全。
// 背景:Day50 压测定位拦截器逐号查库(黑名单:白名单 Count+黑名单 Count;频次:白名单
// Count+策略 Find),批量 100 号=每号 4 查共 400 次 MySQL 往返,是受理批量 P50 915ms 主因之一。
// 设计:惰性加载(sync.Once,未启用的能力零开销)+生命周期限定单次请求同步链(逐号循环
// 串行调用);Req.Scope=nil 时拦截器走原逐号路径(单号 precheck/旧测试兼容)。
package interceptor
import (
"context"
"sync"
"go-sms/internal/model/entity"
"github.com/redis/go-redis/v9"
"gorm.io/gorm"
)
// Scope 请求级快照(db 与链装配同库;mobiles=本次请求全部号码,批查全集)。
type Scope struct {
ctx context.Context
db *gorm.DB
accountID int64
mobiles []string
wlOnce sync.Once
wl map[string]struct{} // 白名单命中集(账号级+全局合并)
blOnce sync.Once
bl map[string]struct{} // 黑名单命中集(DB 二级)
rblOnce sync.Once
rbl map[string]bool // 黑名单命中集(Redis 一级,批量 SMIsMember)
plOnce sync.Once
policies []entity.PolicyFrequency // 启用中的频次策略
sgOnce sync.Once
signs []string // 签名白名单(账号级;由 Sign 拦截器注入加载函数)
}
// NewScope 构造(经 Chain.NewScope 生成,db 取链装配库)。
func NewScope(ctx context.Context, db *gorm.DB, accountID int64, mobiles []string) *Scope {
return &Scope{ctx: ctx, db: db, accountID: accountID, mobiles: mobiles}
}
// Whitelisted 白名单豁免判定(mobile IN 一次批查;查询失败=不豁免,与逐号路径语义一致)。
func (sc *Scope) Whitelisted(mobile string) bool {
if sc == nil {
return false
}
sc.wlOnce.Do(func() {
var rows []string
if err := sc.db.WithContext(sc.ctx).Model(&entity.PolicyWhitelist{}).
Where("mobile IN ? AND account_id IN ?", sc.mobiles, []int64{0, sc.accountID}).
Pluck("mobile", &rows).Error; err != nil {
return // 失败=空集(放行,可用性优先,与原 Count 失败路径一致)
}
sc.wl = make(map[string]struct{}, len(rows))
for _, m := range rows {
sc.wl[m] = struct{}{}
}
})
_, ok := sc.wl[mobile]
return ok
}
// Blacklisted 黑名单 DB 二级判定(批量 IN 一次;命中号由调用方按需回写 Redis 缓存)。
func (sc *Scope) Blacklisted(mobile string) bool {
if sc == nil {
return false
}
sc.blOnce.Do(func() {
var rows []string
if err := sc.db.WithContext(sc.ctx).Model(&entity.PolicyBlacklist{}).
Where("mobile IN ? AND account_id IN ?", sc.mobiles, []int64{0, sc.accountID}).
Pluck("mobile", &rows).Error; err != nil {
return
}
sc.bl = make(map[string]struct{}, len(rows))
for _, m := range rows {
sc.bl[m] = struct{}{}
}
})
_, ok := sc.bl[mobile]
return ok
}
// RedisBlacklisted 黑名单 Redis 一级判定(SMIsMember 一次批查全量号码;故障=未命中降级 DB)。
func (sc *Scope) RedisBlacklisted(rdb redis.UniversalClient, mobile string) bool {
if sc == nil || rdb == nil || len(sc.mobiles) == 0 {
return false
}
sc.rblOnce.Do(func() {
hits, err := rdb.SMIsMember(sc.ctx, BlacklistCacheKey, sc.mobiles).Result()
if err != nil || len(hits) != len(sc.mobiles) {
return // 故障=空集,由 Blacklisted(DB)兜底
}
sc.rbl = make(map[string]bool, len(hits))
for i, m := range sc.mobiles {
sc.rbl[m] = hits[i]
}
})
return sc.rbl[mobile]
}
// FreqPolicies 启用中的频次策略(账号级,一次 Find 跨号复用;查询失败=nil=放行)。
func (sc *Scope) FreqPolicies() []entity.PolicyFrequency {
if sc == nil {
return nil
}
sc.plOnce.Do(func() {
_ = sc.db.WithContext(sc.ctx).
Where("status = 1 AND account_id IN ?", []int64{0, sc.accountID}).
Order("id").Find(&sc.policies).Error
})
return sc.policies
}
// AllowedSigns 签名白名单(账号级一次;加载函数由 Sign 拦截器首次使用时注入)。
func (sc *Scope) AllowedSigns(load func() []string) []string {
if sc == nil {
return load()
}
sc.sgOnce.Do(func() { sc.signs = load() })
return sc.signs
}
+164
View File
@@ -0,0 +1,164 @@
// scope_test.go Day 51(R3 验收):请求级快照——SQL 计数断言与逐号旧路径语义回归。
package interceptor
import (
"context"
"sync"
"sync/atomic"
"testing"
"go-sms/internal/model/entity"
"gorm.io/gorm"
)
// batch100 生成 100 个连续测试号(避开造数命中号 137/138 段)。
func batch100() []string {
out := make([]string, 100)
for i := range out {
out[i] = "1590000" + threeDigits(i)
}
return out
}
func threeDigits(i int) string {
return string([]byte{byte('0' + i/100), byte('0' + (i/10)%10), byte('0' + i%10)})
}
// countQueries 注册查询计数 callback(作用于该 db 会话;name 需库内唯一)。
func countQueries(db *gorm.DB, name string) *int32 {
var n int32
_ = db.Callback().Query().Before("gorm:query").Register(name, func(tx *gorm.DB) {
atomic.AddInt32(&n, 1)
})
return &n
}
// TestScopeSQLCount 验收(Day51):批量 100 号经 scope SQL ≤3 次
// (白名单 IN/黑名单 IN/策略 Find 各 1);逐号旧路径 ≥200 次(每号 4 查)。
func TestScopeSQLCount(t *testing.T) {
db := newTestDB(t)
if err := db.Create(&entity.PolicyBlacklist{Mobile: "13700000000", AccountID: 1}).Error; err != nil {
t.Fatal(err)
}
if err := db.Create(&entity.PolicyFrequency{AccountID: 0, Dim: 1, WindowUnit: 1,
MaxCount: 1000, Status: 1}).Error; err != nil {
t.Fatal(err)
}
ctx := context.Background()
mobiles := batch100()
// ① scope 路径:3 次(白名单+黑名单+策略)。
chain := NewDefaultChain(db, nil, nil, Options{FreqStore: NewMemoryFreqStore()})
n := countQueries(db, "test:count_scope")
sc := chain.NewScope(ctx, 1, mobiles)
for _, m := range mobiles {
if b := chain.Check(ctx, &Req{AccountID: 1, Mobile: m,
Content: "【云】R3 计数验证", Scope: sc}); b != nil {
t.Fatalf("普通号 %s 不应拦截: %+v", m, b)
}
}
if *n > 3 {
t.Fatalf("scope 批量 100 号 SQL=%d,应 ≤3(白名单/黑名单/策略各 1)", *n)
}
t.Logf("scope 路径 100 号 SQL=%d", *n)
// ② 逐号旧路径(nil scope):黑名单 1 命中号短路,其余每号 4 查 ≥200。
n2 := countQueries(db, "test:count_legacy")
for _, m := range mobiles {
_ = chain.Check(ctx, &Req{AccountID: 1, Mobile: m, Content: "【云】R3 计数验证"})
}
if *n2 < 200 {
t.Fatalf("逐号旧路径 100 号 SQL=%d,应 ≥200(每号 4 查——Day50 定位的重复查询)", *n2)
}
t.Logf("逐号旧路径 100 号 SQL=%d", *n2)
}
// TestScopeSemantics 回归:scope 与逐号路径判定一致(白名单豁免/黑名单命中/频次超限/签名)。
func TestScopeSemantics(t *testing.T) {
db := newTestDB(t)
// 造数:1371=白名单豁免号(同时命中黑名单,验证豁免优先);1372=纯黑名单;策略 max=2。
seed := []interface{}{
&entity.PolicyBlacklist{Mobile: "13711111111", AccountID: 1},
&entity.PolicyBlacklist{Mobile: "13722222222", AccountID: 1},
&entity.PolicyWhitelist{Mobile: "13711111111", AccountID: 1},
&entity.PolicyFrequency{AccountID: 0, Dim: 1, WindowUnit: 1, MaxCount: 2, Status: 1},
}
for _, s := range seed {
if err := db.Create(s).Error; err != nil {
t.Fatal(err)
}
}
newChain := func() *Chain {
return NewDefaultChain(db, nil, nil, Options{FreqStore: NewMemoryFreqStore()})
}
ctx := context.Background()
cases := []struct {
name, mobile string
}{
{"白名单豁免(同号黑名单仍在库)", "13711111111"},
{"纯黑名单", "13722222222"},
{"频次超限(第 3 次)", "13733333333"},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
// 各自独立链+频次计数(同号 3 次触发超限)。
chScoped, chLegacy := newChain(), newChain()
sc := chScoped.NewScope(ctx, 1, []string{tc.mobile})
var gotScoped, gotLegacy *Block
for i := 0; i < 3; i++ {
gotScoped = chScoped.Check(ctx, &Req{AccountID: 1, Mobile: tc.mobile,
Content: "【云】语义回归", Scope: sc})
gotLegacy = chLegacy.Check(ctx, &Req{AccountID: 1, Mobile: tc.mobile,
Content: "【云】语义回归"})
}
if (gotScoped == nil) != (gotLegacy == nil) {
t.Fatalf("scope=%v legacy=%v 判定不一致", gotScoped, gotLegacy)
}
if gotScoped != nil {
if gotScoped.Interceptor != gotLegacy.Interceptor || gotScoped.Code != gotLegacy.Code {
t.Fatalf("命中拦截器不一致: scope=%+v legacy=%+v", gotScoped, gotLegacy)
}
}
})
}
}
// fakeSignAllow 计数调用的签名白名单(验证 scope 下账号级只查一次)。
type fakeSignAllow struct{ mu sync.Mutex; calls int }
func (f *fakeSignAllow) AllowedSigns(_ context.Context, _ int64) ([]string, error) {
f.mu.Lock()
f.calls++
f.mu.Unlock()
return []string{"云"}, nil
}
// TestScopeSignCachedOnce 验收:签名白名单账号级数据经 scope 缓存,批量内只查一次。
func TestScopeSignCachedOnce(t *testing.T) {
db := newTestDB(t)
allow := &fakeSignAllow{}
chain := NewDefaultChain(db, nil, nil, Options{FreqStore: NewMemoryFreqStore(), SignAllow: allow})
ctx := context.Background()
mobiles := batch100()
sc := chain.NewScope(ctx, 1, mobiles)
for _, m := range mobiles {
if b := chain.Check(ctx, &Req{AccountID: 1, Mobile: m,
Content: "【云】签名缓存验证", Scope: sc}); b != nil {
t.Fatalf("已报备签名不应拦截: %+v", b)
}
}
if allow.calls != 1 {
t.Fatalf("签名白名单调用 %d 次,scope 下应恰 1 次(账号级跨号复用)", allow.calls)
}
// 对照:逐号路径每号一查。
for _, m := range mobiles {
if b := chain.Check(ctx, &Req{AccountID: 1, Mobile: m, Content: "【云】签名缓存验证"}); b != nil {
t.Fatalf("逐号路径不应拦截: %+v", b)
}
}
if allow.calls != 101 {
t.Fatalf("逐号路径签名白名单调用 %d 次,应 101(1+100)", allow.calls)
}
}
+70
View File
@@ -0,0 +1,70 @@
// sign.go Day 42:签名拦截——Day41 验收二变(内容=签名+正文一体)后,
// 从内容提取首个【】签名校验存在性;账号白名单(报备)接入后校验归属。
package interceptor
import (
"context"
"strings"
errs "go-sms/internal/pkg/errors"
)
// SignAllowlist 账号签名白名单(签名报备审核通过后写入;nil=平台不限制)。
type SignAllowlist interface {
AllowedSigns(ctx context.Context, accountID int64) ([]string, error)
}
// Sign 签名拦截器。
type Sign struct {
Allow SignAllowlist // 可 nil
}
// NewSign 构造。
func NewSign(allow SignAllowlist) *Sign { return &Sign{Allow: allow} }
// Name 拦截器名。
func (s *Sign) Name() string { return "sign" }
// ExtractSign 提取内容首个【】签名(无则空串;与 FE mergeSign/后端口径一致——内容自带)。
func ExtractSign(content string) string {
const l = len("【") // UTF-8 3 字节
i := strings.Index(content, "【")
if i < 0 {
return ""
}
j := strings.Index(content[i+l:], "】")
if j <= 0 { // 空签名【】或未闭合
return ""
}
return content[i+l : i+l+j]
}
// Check 内容须含【】签名;配置白名单时签名须在列。
func (s *Sign) Check(ctx context.Context, r *Req) *Block {
sign := ExtractSign(r.Content)
if sign == "" {
e := errs.SignatureInvalid.WithMsg("内容缺少【】签名(签名+正文一体)")
return &Block{Interceptor: s.Name(), Code: e.Code, Msg: e.Msg, HTTP: e}
}
if s != nil && s.Allow != nil {
// Day51 R3:账号级签名白名单经请求级快照缓存(批量内只查一次)。
allowed := r.Scope.AllowedSigns(func() []string {
a, err := s.Allow.AllowedSigns(ctx, r.AccountID)
if err != nil {
return nil
}
return a
})
if len(allowed) > 0 {
for _, a := range allowed {
if a == sign {
return nil
}
}
e := errs.SignatureInvalid.WithMsg("签名未报备: " + sign)
return &Block{Interceptor: s.Name(), Code: e.Code, Msg: e.Msg, HTTP: e}
}
}
return nil
}
@@ -0,0 +1,45 @@
// unsubscribe.go Day 42:退订标识拦截——营销内容末尾须含「拒收请回复R」类标识(可配)。
package interceptor
import (
"context"
"strings"
errs "go-sms/internal/pkg/errors"
)
// DefaultUnsubKeywords 默认退订标识关键词。
var DefaultUnsubKeywords = []string{"拒收请回复R", "拒收请回复r", "回T退订", "回N退订"}
// Unsubscribe 退订标识拦截器。
type Unsubscribe struct {
Required bool // 是否强制(营销类);false=放行
Keywords []string // 标识关键词(默认 DefaultUnsubKeywords)
}
// NewUnsubscribe 构造(keywords 空用默认)。
func NewUnsubscribe(required bool, keywords []string) *Unsubscribe {
if len(keywords) == 0 {
keywords = DefaultUnsubKeywords
}
return &Unsubscribe{Required: required, Keywords: keywords}
}
// Name 拦截器名。
func (u *Unsubscribe) Name() string { return "unsubscribe" }
// Check Required 时内容(去尾空白)须以任一关键词结尾。
func (u *Unsubscribe) Check(_ context.Context, r *Req) *Block {
if u == nil || !u.Required {
return nil
}
tail := strings.TrimRight(r.Content, " \t\r\n")
for _, k := range u.Keywords {
if strings.HasSuffix(tail, k) {
return nil
}
}
e := errs.ContentNonCompliant.WithMsg("内容末尾缺少退订标识(如「拒收请回复R」)")
return &Block{Interceptor: u.Name(), Code: e.Code, Msg: e.Msg, HTTP: e}
}