From a3a180a4a9433bb59dd27e2ec389c60bb0799445 Mon Sep 17 00:00:00 2001 From: Tory Date: Fri, 13 Nov 2026 16:32:44 +0800 Subject: [PATCH] =?UTF-8?q?S1-B=20D2.1:=20B=20=E5=B1=82=E6=90=AC=E8=BF=90?= =?UTF-8?q?=20interceptor(=E6=8B=A6=E6=88=AA=E9=93=BE:=E9=BB=91=E7=99=BD?= =?UTF-8?q?=E5=90=8D=E5=8D=95/=E5=85=B3=E9=94=AE=E5=AD=97/=E9=A2=91?= =?UTF-8?q?=E6=AC=A1/=E7=A0=81=E5=8F=B7,P1=20=E7=AD=89=E4=BB=B7=E9=9B=B6?= =?UTF-8?q?=E6=94=B9=E5=8A=A8,13=20=E6=96=87=E4=BB=B6;=E5=8E=9F=E6=A0=B7?= =?UTF-8?q?=E8=AF=AD=E4=B9=89:=E5=91=BD=E4=B8=AD=E7=BB=88=E6=80=815+?= =?UTF-8?q?=E9=80=80=E8=B4=B9=E9=93=BE=E8=B7=AF=E4=B8=8A=E6=B8=B8=E6=8E=A5?= =?UTF-8?q?=E5=8F=A3)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- internal/service/interceptor/blacklist.go | 112 ++++++++++ .../service/interceptor/blacklist_test.go | 94 +++++++++ internal/service/interceptor/default.go | 55 +++++ internal/service/interceptor/frequency.go | 194 ++++++++++++++++++ .../service/interceptor/frequency_test.go | 165 +++++++++++++++ internal/service/interceptor/interceptor.go | 89 ++++++++ .../service/interceptor/interceptor_test.go | 113 ++++++++++ internal/service/interceptor/misc_test.go | 135 ++++++++++++ internal/service/interceptor/region.go | 54 +++++ internal/service/interceptor/scope.go | 128 ++++++++++++ internal/service/interceptor/scope_test.go | 164 +++++++++++++++ internal/service/interceptor/sign.go | 70 +++++++ internal/service/interceptor/unsubscribe.go | 45 ++++ 13 files changed, 1418 insertions(+) create mode 100644 internal/service/interceptor/blacklist.go create mode 100644 internal/service/interceptor/blacklist_test.go create mode 100644 internal/service/interceptor/default.go create mode 100644 internal/service/interceptor/frequency.go create mode 100644 internal/service/interceptor/frequency_test.go create mode 100644 internal/service/interceptor/interceptor.go create mode 100644 internal/service/interceptor/interceptor_test.go create mode 100644 internal/service/interceptor/misc_test.go create mode 100644 internal/service/interceptor/region.go create mode 100644 internal/service/interceptor/scope.go create mode 100644 internal/service/interceptor/scope_test.go create mode 100644 internal/service/interceptor/sign.go create mode 100644 internal/service/interceptor/unsubscribe.go diff --git a/internal/service/interceptor/blacklist.go b/internal/service/interceptor/blacklist.go new file mode 100644 index 00000000..ea2c8f9e --- /dev/null +++ b/internal/service/interceptor/blacklist.go @@ -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() +} diff --git a/internal/service/interceptor/blacklist_test.go b/internal/service/interceptor/blacklist_test.go new file mode 100644 index 00000000..94bdbae1 --- /dev/null +++ b/internal/service/interceptor/blacklist_test.go @@ -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("全局黑名单应拦截任意账号") + } +} diff --git a/internal/service/interceptor/default.go b/internal/service/interceptor/default.go new file mode 100644 index 00000000..de48aea7 --- /dev/null +++ b/internal/service/interceptor/default.go @@ -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 +} diff --git a/internal/service/interceptor/frequency.go b/internal/service/interceptor/frequency.go new file mode 100644 index 00000000..2f28ee98 --- /dev/null +++ b/internal/service/interceptor/frequency.go @@ -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() +} diff --git a/internal/service/interceptor/frequency_test.go b/internal/service/interceptor/frequency_test.go new file mode 100644 index 00000000..309ae795 --- /dev/null +++ b/internal/service/interceptor/frequency_test.go @@ -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(只读未写入)") + } +} diff --git a/internal/service/interceptor/interceptor.go b/internal/service/interceptor/interceptor.go new file mode 100644 index 00000000..df3fdc05 --- /dev/null +++ b/internal/service/interceptor/interceptor.go @@ -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 +} diff --git a/internal/service/interceptor/interceptor_test.go b/internal/service/interceptor/interceptor_test.go new file mode 100644 index 00000000..50ab1a5d --- /dev/null +++ b/internal/service/interceptor/interceptor_test.go @@ -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) + } +} diff --git a/internal/service/interceptor/misc_test.go b/internal/service/interceptor/misc_test.go new file mode 100644 index 00000000..92c06af2 --- /dev/null +++ b/internal/service/interceptor/misc_test.go @@ -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) + } +} diff --git a/internal/service/interceptor/region.go b/internal/service/interceptor/region.go new file mode 100644 index 00000000..95030433 --- /dev/null +++ b/internal/service/interceptor/region.go @@ -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 +} diff --git a/internal/service/interceptor/scope.go b/internal/service/interceptor/scope.go new file mode 100644 index 00000000..b87a8e1b --- /dev/null +++ b/internal/service/interceptor/scope.go @@ -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 +} diff --git a/internal/service/interceptor/scope_test.go b/internal/service/interceptor/scope_test.go new file mode 100644 index 00000000..31448c3f --- /dev/null +++ b/internal/service/interceptor/scope_test.go @@ -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) + } +} + diff --git a/internal/service/interceptor/sign.go b/internal/service/interceptor/sign.go new file mode 100644 index 00000000..a28c5fc2 --- /dev/null +++ b/internal/service/interceptor/sign.go @@ -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 +} diff --git a/internal/service/interceptor/unsubscribe.go b/internal/service/interceptor/unsubscribe.go new file mode 100644 index 00000000..70c74bfe --- /dev/null +++ b/internal/service/interceptor/unsubscribe.go @@ -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} +}