From 2434b1db67e69b4647e5568c2bdbcdbc8c71c437 Mon Sep 17 00:00:00 2001 From: Tory Date: Fri, 13 Nov 2026 16:56:10 +0800 Subject: [PATCH] =?UTF-8?q?S1-B=20D4.3:=20B=20=E5=B1=82=E6=90=AC=E8=BF=90?= =?UTF-8?q?=20access(CMPP=20=E6=8E=A5=E5=85=A5+=E9=95=BF=E7=9F=AD=E4=BF=A1?= =?UTF-8?q?=2072h=20=E6=8C=82=E8=B5=B7=E5=88=B6/UDH=20=E8=81=9A=E5=90=88/r?= =?UTF-8?q?eaper;73.3%=20-race=20=E7=BB=BF;=E6=8C=81=E4=B9=85=E5=8C=96-?= =?UTF-8?q?=E8=BF=98=E5=8E=9F=E9=94=AE=E6=88=90=E5=AF=B9=E5=AE=A1=E8=AE=A1?= =?UTF-8?q?=E5=85=A5=E6=B5=8B=E8=AF=95=E6=A8=A1=E6=9D=BF=E9=A1=B9=E9=9A=8F?= =?UTF-8?q?=20P2)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- internal/service/access/access.go | 382 ++++++++++++++++++++++ internal/service/access/access_test.go | 270 +++++++++++++++ internal/service/access/longsms.go | 317 ++++++++++++++++++ internal/service/access/longsms_reaper.go | 194 +++++++++++ internal/service/access/longsms_test.go | 360 ++++++++++++++++++++ internal/service/access/push.go | 61 ++++ 6 files changed, 1584 insertions(+) create mode 100644 internal/service/access/access.go create mode 100644 internal/service/access/access_test.go create mode 100644 internal/service/access/longsms.go create mode 100644 internal/service/access/longsms_reaper.go create mode 100644 internal/service/access/longsms_test.go create mode 100644 internal/service/access/push.go diff --git a/internal/service/access/access.go b/internal/service/access/access.go new file mode 100644 index 00000000..171f893e --- /dev/null +++ b/internal/service/access/access.go @@ -0,0 +1,382 @@ +// access.go Day 47:客户协议接入域服务(api/open/protocol)。 +// 职责:①CMPP/SMPP 连接鉴权(复用账号体系:username + AccountConfig.ApiSecret +// +// 32hex 串即共享密钥,与 Day46 HTTP 验签同源凭据)②Submit 业务适配—— +// +// 通道号前缀校验(SrcID 须以账号 ext_code 为前缀,开发计划「UT:0012」语义) +// →openapi.Service.SendMass 复用受理链(校验/计费/落库/审核分流/Kafka 事件)。 +package access + +import ( + "context" + "crypto/subtle" + "strings" + "sync" + "sync/atomic" + "time" + + "go-sms/internal/model/entity" + "go-sms/internal/pkg/logger" + "go-sms/internal/protocol/cmpp" + "go-sms/internal/protocol/smpp" + "go-sms/internal/service/account" + "go-sms/internal/service/openapi" + "go-sms/internal/service/report" + "go-sms/internal/service/send" + "go.uber.org/zap" + "gorm.io/gorm" +) + +// submitStatsT Day62d:CMPP 接入受理埋点(盲区修复:客户 20 链压测全程零留痕, +// 吞吐排查只能靠 DB 倒推;30s 汇总 qps/均值/慢占比,拒绝分支另有 cmpp_submit_rejected)。 +type submitStatsT struct { + start sync.Once + count atomic.Int64 + slow atomic.Int64 // >200ms 受理耗时(SLOW SQL/在途链路观测锚点) + ms atomic.Int64 // 累计耗时 +} + +var submitStats submitStatsT + +func (s *submitStatsT) record(el time.Duration) { + s.count.Add(1) + s.ms.Add(el.Milliseconds()) + if el > 200*time.Millisecond { + s.slow.Add(1) + } +} + +// report 惰性启动 30s 汇总上报(首条 Submit 触发;零流量静默不刷屏)。 +func (s *submitStatsT) report() { + s.start.Do(func() { + go func() { + tk := time.NewTicker(30 * time.Second) + defer tk.Stop() + for range tk.C { + c := s.count.Swap(0) + if c == 0 { + continue + } + logger.L().Info("cmpp_submit_stats", + zap.Int64("count_30s", c), + zap.Float64("qps", float64(c)/30), + zap.Int64("avg_ms", s.ms.Swap(0)/c), + zap.Int64("slow_gt_200ms", s.slow.Swap(0))) + } + }() + }) +} + +// Service 客户接入服务(db 只读鉴权 + 提交转发)。 +type Service struct { + db *gorm.DB + api *openapi.Service + limits SystemLimits // Day 62:CMPP 接入系统默认(账号级 0 时回退) + // P0-1(Day 63)受理热路径账号缓存:username→(user,cfg),TTL 30s。 + // Submit/ConnLimit/SubmitRateLimit 每条提交调用,原每次 2 次 SELECT + // (~5ms/条)为快路径最后 DB 残留;连接级鉴权 Connect 不走缓存(实时)。 + accCache sync.Map // string → *accountCacheEntry + accTTL time.Duration + // 长短信片聚合器(批次 2278141 修复):入向 UDH 拼接多片按组聚合, + // 到齐合并为一条逻辑 task;超时逐片退化直发。见 longsms.go。 + grouper *longSmsGrouper +} + +// accountCacheEntry 账号缓存条目(u/cfg nil=查无,负缓存防穿透)。 +type accountCacheEntry struct { + u, cfg any // *entity.AccountUser | *entity.AccountConfig | nil + expireAt time.Time +} + +const accountCacheTTL = 30 * time.Second + +// SystemLimits CMPP 接入系统默认值(来自服务端 config;账号级配置 0 时回退)。 +type SystemLimits struct { + MaxConns int // 每账号最大连接数(≤0=不限) + SubmitRate int // 单链提交限速 条/s(≤0=不限) + // LongSmsWindow Day 71:入向长短信挂起窗(≤0=默认 72h;到期不齐失败终态)。 + LongSmsWindow time.Duration +} + +// New 构造(api=openapi 提交服务,复用 SendMass 受理链;limits=系统默认配额)。 +func New(db *gorm.DB, api *openapi.Service, limits SystemLimits) *Service { + g := newLongSmsGrouper(db) + if limits.LongSmsWindow > 0 { + g.window = limits.LongSmsWindow + } + return &Service{db: db, api: api, limits: limits, accTTL: accountCacheTTL, + grouper: g} +} + +// StartLongSmsMaintenance Day 71:长短信挂起制启动(重启恢复+72h 到期扫描器; +// gateway 装配调用,CMPP 无挂起行时零成本)。push=nil 只落失败记录不推回执 +// (producer 降级场景);every<=0 默认 1min。 +func (s *Service) StartLongSmsMaintenance(ctx context.Context, + push report.PushSink, every time.Duration) { + if n := s.grouper.restore(s.restoreLongSmsAuth); n > 0 { + logger.L().Info("cmpp_longsms_restored", zap.Int("groups", n)) + } + go newLongSmsReaper(s.grouper, s.api, s.db, push, s.restoreLongSmsAuth).Run(ctx, every) +} + +// restoreLongSmsAuth 挂起组 auth 重建(restore/reaper 共用;账号删除/停用 +// 返回 nil——restore 跳过该组/remerge 走失败终态)。 +func (s *Service) restoreLongSmsAuth(username string, accountID int64) *openapi.AuthContext { + u, cfg := s.loadAccount(context.Background(), username) + if u == nil || cfg == nil { + return nil + } + return &openapi.AuthContext{AccountID: u.ID, Username: username, Config: cfg, + Source: send.TaskSourceCMPP} +} + +// ConnLimit 实现 cmpp.ConnLimiter(Day 62):账号级最大连接数, +// account_config.cmpp_max_conns(0=回退系统默认;负值兜底不限)。 +func (s *Service) ConnLimit(sourceAddr string) int { + _, cfg := s.loadAccountDB(context.Background(), sourceAddr) + if cfg == nil { + return s.limits.MaxConns // 账号缺失时鉴权必拒,取系统默认不放大窗口 + } + if cfg.CmppMaxConns > 0 { + return cfg.CmppMaxConns + } + return s.limits.MaxConns +} + +// SubmitRateLimit 实现 cmpp.SubmitRateLimiter(Day 62):账号级单链限速 条/s, +// account_config.cmpp_speed(0=回退系统默认)。 +func (s *Service) SubmitRateLimit(sourceAddr string) int { + _, cfg := s.loadAccountDB(context.Background(), sourceAddr) + if cfg == nil { + return s.limits.SubmitRate + } + if cfg.CmppSpeed > 0 { + return cfg.CmppSpeed + } + return s.limits.SubmitRate +} + +// loadAccount 按用户名装载账号+业务配置(不存在/停用/无配置统一拒绝)。 +// P0-1(Day 63)热路径缓存(TTL 30s,负缓存防穿透;Connect 鉴权路径不走缓存)。 +func (s *Service) loadAccount(ctx context.Context, username string) (*entity.AccountUser, *entity.AccountConfig) { + if s.accTTL > 0 { + if v, ok := s.accCache.Load(username); ok { + e := v.(*accountCacheEntry) + if time.Now().Before(e.expireAt) { + var u *entity.AccountUser + var cfg *entity.AccountConfig + if e.u != nil { + u = e.u.(*entity.AccountUser) + } + if e.cfg != nil { + cfg = e.cfg.(*entity.AccountConfig) + } + return u, cfg + } + } + } + u, cfg := s.loadAccountDB(ctx, username) + if s.accTTL > 0 { + s.accCache.Store(username, &accountCacheEntry{ + u: accountPtr(u), cfg: configPtr(cfg), expireAt: time.Now().Add(s.accTTL), + }) + } + return u, cfg +} + +// accountPtr/configPtr nil→any(nil) 规整(避免 typed-nil 断言歧义)。 +func accountPtr(u *entity.AccountUser) any { + if u == nil { + return nil + } + return u +} + +func configPtr(c *entity.AccountConfig) any { + if c == nil { + return nil + } + return c +} + +// loadAccountDB 原直查路径(缓存未命中回源)。 +func (s *Service) loadAccountDB(ctx context.Context, username string) (*entity.AccountUser, *entity.AccountConfig) { + var u entity.AccountUser + if err := s.db.WithContext(ctx).Where("username = ?", username). + First(&u).Error; err != nil { + return nil, nil + } + if u.Status != 1 { + return &u, nil + } + var cfg entity.AccountConfig + if err := s.db.WithContext(ctx). + Where("account_id = ? AND business = ?", u.ID, "sms"). + First(&cfg).Error; err != nil { + return &u, nil + } + return &u, &cfg +} + +// ---- CMPP ---- + +// Connect 实现 cmpp.ServerHandler:CMPP authenticator 鉴权(MD5 链路见 cmpp/body.go)。 +// Day62b 可观测:各失败分支落 warn 日志(source_addr/client_ip/ts/status)—— +// 旧版静默回状态码,客户连接被拒时服务端零痕迹(真机排查 -1 报障时暴露盲区)。 +func (s *Service) Connect(sourceAddr string, ts uint32, authenticator []byte, clientIP string) byte { + ctx := context.Background() + u, cfg := s.loadAccountDB(ctx, sourceAddr) + if u == nil { + logger.L().Warn("cmpp_conn_auth_failed", + zap.String("source_addr", sourceAddr), zap.String("client_ip", clientIP), + zap.Uint32("ts", ts), zap.Uint8("status", cmpp.ConnectBadAuth)) // 不泄露存在性,码值 2 + return cmpp.ConnectBadAuth // 不泄露存在性 + } + if cfg == nil { + logger.L().Warn("cmpp_conn_disabled", + zap.String("source_addr", sourceAddr), zap.String("client_ip", clientIP), + zap.Uint8("status", cmpp.ConnectDisabled)) + return cmpp.ConnectDisabled + } + if !account.IPAllowed(u.IPBind, clientIP) { + logger.L().Warn("cmpp_conn_bad_ip", + zap.String("source_addr", sourceAddr), zap.String("client_ip", clientIP), + zap.Uint8("status", cmpp.ConnectBadIP)) + return cmpp.ConnectBadIP + } + if cfg.ApiSecret == "" { + logger.L().Warn("cmpp_conn_auth_failed", + zap.String("source_addr", sourceAddr), zap.String("client_ip", clientIP), + zap.Uint32("ts", ts), zap.Uint8("status", cmpp.ConnectBadAuth), + zap.String("reason", "secret_not_issued")) + return cmpp.ConnectBadAuth + } + if !cmpp.VerifyAuth(sourceAddr, cfg.ApiSecret, ts, authenticator) { + logger.L().Warn("cmpp_conn_auth_failed", + zap.String("source_addr", sourceAddr), zap.String("client_ip", clientIP), + zap.Uint32("ts", ts), zap.Uint8("status", cmpp.ConnectBadAuth)) // 密码不匹配(不输出库值/指纹) + return cmpp.ConnectBadAuth + } + return cmpp.ConnectOK +} + +// Submit 实现 cmpp.ServerHandler:账号/通道号前缀校验→SendMass 受理。 +// 长短信片(udh 非 nil 且单目的码)改走聚合器:按组拼接合并为一条逻辑 +// 短信单次受理(批次 2278141 修复,决策①A/②A/③——详见 longsms.go);其余 +// (普通提交/多目的码片)走原直发路径不变。 +func (s *Service) Submit(sourceAddr, srcID string, dest []string, + content string, udh *cmpp.UDHInfo, registeredDelivery uint8, msgFmt uint8) (uint64, byte) { + submitStats.report() + t0 := time.Now() + defer func() { submitStats.record(time.Since(t0)) }() + ctx := context.Background() + if udh != nil && udh.Total > 1 && len(dest) == 1 { + cfg, result := s.precheck(ctx, sourceAddr, srcID) + if cfg == nil { + return 0, result + } + return s.grouper.submitFragment(s.api, cfg, sourceAddr, srcID, + dest[0], content, udh, msgFmt == cmpp.MsgFmtUCS2) + } + return s.submitDirect(ctx, sourceAddr, srcID, dest, content, msgFmt) +} + +// precheck 账号加载+通道号前缀校验(cfg=nil 时返回值为 CMPP 拒绝码)。 +// 直发与长短信聚合共用(聚合组以首片账号快照为准)。 +func (s *Service) precheck(ctx context.Context, sourceAddr, srcID string) (*entity.AccountConfig, byte) { + _, cfg := s.loadAccount(ctx, sourceAddr) + if cfg == nil { + return nil, cmpp.SubmitRejected + } + // 通道号前缀:账号 ext_code 非空时 SrcID 必须以其为前缀(UT:0012 语义)。 + if cfg.ExtCode != "" && !strings.HasPrefix(srcID, cfg.ExtCode) { + logger.L().Warn("cmpp_submit_src_prefix_mismatch", + zap.String("source_addr", sourceAddr), zap.String("src_id", srcID), + zap.String("ext_code", cfg.ExtCode)) + return nil, cmpp.SubmitBadCode + } + return cfg, cmpp.SubmitOK +} + +// submitDirect 普通提交(原 Submit 主体):P0-1(Day 63)快路径受理。 +// RegisteredDelivery 语义不变:回执由 Day61 push 链按明细驱动,受理参数不传递。 +func (s *Service) submitDirect(ctx context.Context, sourceAddr, srcID string, + dest []string, content string, msgFmt uint8) (uint64, byte) { + tAcc := time.Now() + cfg, result := s.precheck(ctx, sourceAddr, srcID) + tAccCost := time.Since(tAcc) + if cfg == nil { + return 0, result + } + t0 := time.Now() + resp := s.api.SendMassFast(ctx, &openapi.AuthContext{ + AccountID: cfg.AccountID, Username: sourceAddr, Config: cfg, + Source: send.TaskSourceCMPP, // Day 60:受理来源打标(CMPP 接入) + }, &openapi.MassReq{ + PhoneList: dest, + Content: content, + SignName: "", // CMPP 内容自带【签名】,与 Day41 验收二变口径一致 + ExtCode: strings.TrimPrefix(srcID, cfg.ExtCode), + // Day 70:按 MsgFmt 分流计费口径(UCS2=8:每码元 2B;fee≡上游真实片数)。 + ContentEncoding: ucs2Encoding(msgFmt == cmpp.MsgFmtUCS2), + }, remoteIPPlaceholder) + if resp.Code != openapi.CodeOK { + logger.L().Warn("cmpp_submit_rejected", + zap.String("source_addr", sourceAddr), zap.Int("code", resp.Code), + zap.String("message", resp.Message)) + return 0, cmpp.SubmitRejected + } + // P0-1 诊断:分段耗时(loadAccount/受理链),>100ms 打点(临时,Day63 复压定位)。 + if d := time.Since(t0); d > 100*time.Millisecond { + logger.L().Warn("cmpp_submit_slow_seg", + zap.Duration("total", d), zap.Duration("load_account", tAccCost), + zap.Duration("fast_path", d-tAccCost), + zap.String("source_addr", sourceAddr)) + } + return uint64(resp.MsgID), cmpp.SubmitOK +} + +// remoteIPPlaceholder 提交侧 IP 留痕(接入 IP 由协议层日志记录;SendMass 仅落库用)。 +const remoteIPPlaceholder = "protocol" + +// Bind 实现 smpp.ServerHandler:明文密码常数时间比对(ApiSecret 即密码)。 +func (s *Service) Bind(systemID, password, clientIP string) smpp.Status { + ctx := context.Background() + u, cfg := s.loadAccount(ctx, systemID) + if u == nil || cfg == nil { + return smpp.StatusBindFail + } + if !account.IPAllowed(u.IPBind, clientIP) { + return smpp.StatusBindFail + } + if cfg.ApiSecret == "" || + subtle.ConstantTimeCompare([]byte(cfg.ApiSecret), []byte(password)) != 1 { + return smpp.StatusBindFail + } + return smpp.StatusOK +} + +// SubmitSM 实现 smpp.ServerHandler:源地址前缀校验→SendMass 受理。 +func (s *Service) SubmitSM(systemID, srcAddr, destAddr, content string, + registeredDelivery uint8) (string, smpp.Status) { + ctx := context.Background() + _, cfg := s.loadAccount(ctx, systemID) + if cfg == nil { + return "", smpp.StatusSysErr + } + if cfg.ExtCode != "" && !strings.HasPrefix(srcAddr, cfg.ExtCode) { + return "", smpp.StatusSysErr + } + resp := s.api.SendMass(ctx, &openapi.AuthContext{ + AccountID: cfg.AccountID, Username: systemID, Config: cfg, + Source: send.TaskSourceSMPP, // Day 60:受理来源打标(SMPP 接入) + }, &openapi.MassReq{ + PhoneList: []string{destAddr}, + Content: content, + ExtCode: strings.TrimPrefix(srcAddr, cfg.ExtCode), + }, remoteIPPlaceholder) + if resp.Code != openapi.CodeOK { + return "", smpp.StatusSysErr + } + return resp.TaskNo, smpp.StatusOK +} diff --git a/internal/service/access/access_test.go b/internal/service/access/access_test.go new file mode 100644 index 00000000..dbb45b33 --- /dev/null +++ b/internal/service/access/access_test.go @@ -0,0 +1,270 @@ +// access_test.go Day 47:客户接入域测试——CMPP authenticator 鉴权(通过/拒绝/停用)、 +// 通道号前缀校验、提交经 openapi 受理链落库、SMPP bind/前缀校验。 +package access + +import ( + "context" + "testing" + "time" + + "github.com/glebarez/sqlite" + "gorm.io/gorm" + + "go-sms/internal/model/entity" + "go-sms/internal/protocol/cmpp" + "go-sms/internal/protocol/smpp" + "go-sms/internal/service/openapi" + "go-sms/internal/service/send" + "go-sms/internal/util" +) + +// newAccessDB 测试库(与 send.submit_test 同款表集)。 +func newAccessDB(t *testing.T) *gorm.DB { + t.Helper() + db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{}) + if err != nil { + t.Fatal(err) + } + for _, m := range []any{ + &entity.MessageTask{}, &entity.MessageDetail{}, + &entity.PolicyKeyword{}, &entity.AccountConfig{}, &entity.AccountUser{}, + &entity.LongSmsPending{}, // Day 71:挂起组持久化 + } { + if err := db.Migrator().CreateTable(m); err != nil { + t.Fatal(err) + } + } + // Day48:预扣/退款流水(索引撞名故原生建表,同 submit_test 注记)。 + db.Exec(`CREATE TABLE account_balance_log ( + id integer primary key autoincrement, created_at datetime, + account_id integer, biz_type text, amount integer, + balance_after integer, ref_id text, operator text, remark text)`) + return db +} + +// seedAccount 账号+配置(apiSecret=共享密钥;extCode=通道号前缀)。 +func seedAccount(t *testing.T, db *gorm.DB) (userID int64) { + t.Helper() + u := entity.AccountUser{Username: "cmpp_user", Status: 1, Balance: 10000} + if err := db.Create(&u).Error; err != nil { + t.Fatal(err) + } + cfg := entity.AccountConfig{AccountID: u.ID, Business: "sms", + ApiSecret: "shared-secret-32hex", ExtCode: "UT:0012", AuditMode: 0} + if err := db.Create(&cfg).Error; err != nil { + t.Fatal(err) + } + return u.ID +} + +// accessSinkStub P0-1 快路径事件出口桩(捕获 Deferred 事件供断言)。 +type accessSinkStub struct { + tasks []*entity.MessageTask + details [][]entity.MessageDetail +} + +func (a *accessSinkStub) EmitSubmit(_ context.Context, t *entity.MessageTask, + d []entity.MessageDetail) error { + a.tasks = append(a.tasks, t) + a.details = append(a.details, d) + return nil +} + +// accessBalStub 资金桩(余额充足直通)。 +type accessBalStub struct{} + +func (accessBalStub) Hold(context.Context, int64, int64, string) error { return nil } +func (accessBalStub) Refund(context.Context, int64, int64, string, string) error { + return nil +} +func (accessBalStub) Mode() string { return "stub" } + +// newSvc 装配 access(P0-1 起走 SendMassFast 快路径:stub sink/bal 隔离 DB, +// 捕获 Deferred 事件供受理语义断言)。 +func newSvc(t *testing.T, db *gorm.DB) (*Service, *accessSinkStub) { + t.Helper() + sf, err := util.NewSnowflake(1) + if err != nil { + t.Fatal(err) + } + sink := &accessSinkStub{} + sub := send.NewSubmitService(db, sf, nil, + send.WithEventSink(sink), send.WithBalanceStore(accessBalStub{})) + api := openapi.NewService(db, sub, nil) + return New(db, api, SystemLimits{MaxConns: 50, SubmitRate: 50}), sink +} + +// authCMPP 构造客户端鉴权串(cmpp.Connect 同算法)。 +func authCMPP(sourceAddr, secret string, ts uint32) []byte { + return (&cmpp.Connect{SourceAddr: sourceAddr, Secret: secret}).Authenticator(ts) +} + +func testTimestamp() uint32 { + t := time.Now() + return uint32(t.Month())*1e8 + uint32(t.Day())*1e6 + + uint32(t.Hour())*1e4 + uint32(t.Minute())*100 + uint32(t.Second()) +} + +// TestCMPPConnect_OK 正确密钥鉴权通过。 +func TestCMPPConnect_OK(t *testing.T) { + db := newAccessDB(t) + seedAccount(t, db) + s, _ := newSvc(t, db) + if st := s.Connect("cmpp_user", testTimestamp(), authCMPP("cmpp_user", "shared-secret-32hex", testTimestamp()), "127.0.0.1"); st != cmpp.ConnectOK { + t.Fatalf("status=%d", st) + } +} + +// TestCMPPConnect_WrongSecret 错误密钥:status=2。 +func TestCMPPConnect_WrongSecret(t *testing.T) { + db := newAccessDB(t) + seedAccount(t, db) + s, _ := newSvc(t, db) + ts := testTimestamp() + if st := s.Connect("cmpp_user", ts, authCMPP("cmpp_user", "bad", ts), "127.0.0.1"); st != cmpp.ConnectBadAuth { + t.Fatalf("status=%d", st) + } +} + +// TestCMPPConnect_Disabled 停用账号:status=5。 +func TestCMPPConnect_Disabled(t *testing.T) { + db := newAccessDB(t) + seedAccount(t, db) + db.Model(&entity.AccountUser{}).Where("username = ?", "cmpp_user").Update("status", 0) + s, _ := newSvc(t, db) + ts := testTimestamp() + if st := s.Connect("cmpp_user", ts, authCMPP("cmpp_user", "shared-secret-32hex", ts), "127.0.0.1"); st != cmpp.ConnectDisabled { + t.Fatalf("status=%d", st) + } +} + +// Day62b:账号不存在与账号停用均不泄露存在性——不存在→2(与密码错同码)。 +// TestSubmitStatsRecord Day62d:接入埋点计数(快/慢阈值 200ms)。 +func TestSubmitStatsRecord(t *testing.T) { + var s submitStatsT + s.record(50 * time.Millisecond) + s.record(50 * time.Millisecond) + s.record(300 * time.Millisecond) + if c := s.count.Load(); c != 3 { + t.Fatalf("count=%d want 3", c) + } + if ms := s.ms.Load(); ms != 400 { + t.Fatalf("ms=%d want 400", ms) + } + if slow := s.slow.Load(); slow != 1 { + t.Fatalf("slow=%d want 1", slow) + } +} + +func TestCMPPConnect_NoSuchUser(t *testing.T) { + db := newAccessDB(t) + s, _ := newSvc(t, db) + ts := testTimestamp() + if st := s.Connect("ghost", ts, authCMPP("ghost", "whatever", ts), "127.0.0.1"); st != cmpp.ConnectBadAuth { + t.Fatalf("status=%d", st) + } +} + +// TestCMPPSubmit_OK 前缀匹配+快路径受理(P0-1:受理=Deferred 事件,零 DB 写; +// MsgID=DetailID 雪花,与 Deliver msg_id 同口径)。 +func TestCMPPSubmit_OK(t *testing.T) { + db := newAccessDB(t) + seedAccount(t, db) + s, sink := newSvc(t, db) + msgID, result := s.Submit("cmpp_user", "UT:001299", + []string{"13800138000", "13800138001"}, "【签名】你好", nil, 1, cmpp.MsgFmtGBK) + if result != cmpp.SubmitOK || msgID == 0 { + t.Fatalf("msgID=%d result=%d", msgID, result) + } + if len(sink.tasks) != 1 || sink.tasks[0].ID != 0 { + t.Fatalf("快路径应投 Deferred 事件(task.ID=0),got=%+v", sink.tasks) + } + if len(sink.details[0]) != 2 { + t.Fatalf("事件明细=%d/2", len(sink.details[0])) + } + if uint64(sink.details[0][0].ID) != msgID { + t.Fatalf("msgID 应=首条 DetailID(回执配对口径):%d vs %d", + msgID, sink.details[0][0].ID) + } + var cnt int64 + db.Model(&entity.MessageTask{}).Count(&cnt) + if cnt != 0 { + t.Fatalf("快路径受理零任务落库,got %d", cnt) + } +} + +// TestCMPPSubmit_PrefixMismatch 通道号前缀不匹配:result=9。 +func TestCMPPSubmit_PrefixMismatch(t *testing.T) { + db := newAccessDB(t) + seedAccount(t, db) + s, _ := newSvc(t, db) + if _, result := s.Submit("cmpp_user", "XX:9999", []string{"13800138000"}, "【签名】你好", nil, 1, cmpp.MsgFmtGBK); result != cmpp.SubmitBadCode { + t.Fatalf("result=%d", result) + } + var cnt int64 + db.Model(&entity.MessageTask{}).Count(&cnt) + if cnt != 0 { + t.Fatalf("前缀不匹配不应落库: tasks=%d", cnt) + } +} + +// TestCMPPQuotaFallback Day 62:账号级接入配额——账号级>0 覆盖系统默认, +// 0 回退系统默认;账号缺失时取系统默认(鉴权必拒,不放大窗口)。 +func TestCMPPQuotaFallback(t *testing.T) { + db := newAccessDB(t) + uid := seedAccount(t, db) + s, _ := newSvc(t, db) // SystemLimits{MaxConns:50, SubmitRate:50} + + if n := s.ConnLimit("cmpp_user"); n != 50 { + t.Fatalf("未配置应回退系统默认 50,实际 %d", n) + } + if n := s.SubmitRateLimit("cmpp_user"); n != 50 { + t.Fatalf("未配置应回退系统默认 50,实际 %d", n) + } + + db.Model(&entity.AccountConfig{}). + Where("account_id = ?", uid). + Updates(map[string]interface{}{"cmpp_max_conns": 3, "cmpp_speed": 200}) + if n := s.ConnLimit("cmpp_user"); n != 3 { + t.Fatalf("账号级覆盖应生效 3,实际 %d", n) + } + if n := s.SubmitRateLimit("cmpp_user"); n != 200 { + t.Fatalf("账号级覆盖应生效 200,实际 %d", n) + } + + if n := s.ConnLimit("nobody"); n != 50 { + t.Fatalf("账号缺失取系统默认 50,实际 %d", n) + } +} + +// TestSMPPBindAndSubmit bind 密码=ApiSecret;源地址前缀校验同口径。 +func TestSMPPBindAndSubmit(t *testing.T) { + db := newAccessDB(t) + seedAccount(t, db) + s, _ := newSvc(t, db) + if st := s.Bind("cmpp_user", "shared-secret-32hex", "127.0.0.1"); st != smpp.StatusOK { + t.Fatalf("bind status=%v", st) + } + if st := s.Bind("cmpp_user", "bad", "127.0.0.1"); st != smpp.StatusBindFail { + t.Fatalf("错误密码应拒绝: %v", st) + } + mid, st := s.SubmitSM("cmpp_user", "UT:001299", "13800138000", "【签名】hi", 1) + if st != smpp.StatusOK || mid == "" { + t.Fatalf("mid=%q status=%v", mid, st) + } + if _, st := s.SubmitSM("cmpp_user", "YY:0001", "13800138000", "【签名】hi", 1); st == smpp.StatusOK { + t.Fatal("前缀不匹配应拒绝") + } +} + +// msgAccountID 查账号 ID(测试辅助)。 +func msgAccountID(t *testing.T, db *gorm.DB) int64 { + t.Helper() + var u entity.AccountUser + if err := db.Where("username = ?", "cmpp_user").First(&u).Error; err != nil { + t.Fatal(err) + } + return u.ID +} + +var _ = context.Background // 保持 context 引用(未来扩展注入 ctx 用) diff --git a/internal/service/access/longsms.go b/internal/service/access/longsms.go new file mode 100644 index 00000000..d5b43643 --- /dev/null +++ b/internal/service/access/longsms.go @@ -0,0 +1,317 @@ +// longsms.go 入向长短信聚合(批次 2278141/2278142 修复,决策②A/③;Day 71 挂起制): +// 客户端按 CMPP 标准将超 134B 内容拆多片提交(6B 拼接 UDH:ref/total/idx, +// 与出向 split.go 同构;UCS2 客户端片首「05 00 03 02 02 01/02」即实例字节)。 +// +// 聚合语义(组键=账号|srcID|手机号|ref): +// - 每片立即回 Submit_Resp(result=0);msg_id=组ID(首片预生成雪花,N 片 +// 复用——决策③),到齐合并受理时注入为首条 DetailID,回执按整条推 1 条; +// - 到齐:按序拼接全文单次受理(1 task+1 detail,content 全文无乱码, +// fee=FeeSegments=pk_total=运营商计费依据——Day 70 计费口径); +// - 未齐(挂起窗默认 72h,Day 71):不提交上家通道、不返回终态状态、不扣费; +// 挂起组持久化 longsms_pending(首片 INSERT/续片 UPDATE/到齐 DELETE), +// 进程重启 restore 回内存继续等片——窗内补齐仍可正常受理; +// - 满 72h 仍不齐:扫描器(longsms_reaper)建失败终态(task LP+组ID/detail +// id=组ID status=3 fee=0)+UNDELIV 回执给下家在线连接——「不齐不发, +// 到期失败」制(原 10s 超时退化直发语义废除,决策反转:完整性优先); +// - 挂起组 DB 双写失败:Warn 降级继续内存聚合(主功能不受 DB 故障影响, +// 极端场景重启丢组=片已回 OK 无回执,与 Day63 快路径同风险模型)。 +package access + +import ( + "context" + "encoding/json" + "strconv" + "strings" + "sync" + "time" + + "go-sms/internal/pkg/metrics" + + "go-sms/internal/model/entity" + "go-sms/internal/pkg/logger" + "go-sms/internal/protocol/cmpp" + "go-sms/internal/service/openapi" + "go-sms/internal/service/send" + + "go.uber.org/zap" + "gorm.io/gorm" +) + +const ( + // longSmsWindow 挂起窗默认值(Day 71:10s→72h,不齐不发到期失败;config + // server.cmpp.longsms_window 可配;测试直接调 grouper.window)。 + longSmsWindow = 72 * time.Hour + // longSmsMaxGroup 并发挂起组上限(Day 71:4096→16384——72h 窗下超时组 + // 驻留 3 天,压测超时率 32% 一天残留 ~1500 组;超限新组拒绝 SubmitRejected, + // 客户端重试;防伪造 ref 碰撞 DoS 占内存)。 + longSmsMaxGroup = 16384 + // longSmsIncompleteCode 挂起组到期失败错误码(size:16 内)。 + longSmsIncompleteCode = "LSM:NOTCMPL" +) + +// longSmsAPI 聚合器出口(*openapi.Service 天然实现;测试注入桩)。 +type longSmsAPI interface { + NextMsgID() int64 + SendMassFast(ctx context.Context, auth *openapi.AuthContext, + req *openapi.MassReq, clientIP string) *openapi.Resp +} + +// pendingLong 一封待聚合长短信。 +type pendingLong struct { + groupID uint64 // 首片预生成雪花;N 片 Resp 复用;合并后=首条 DetailID + auth *openapi.AuthContext // 首片账号快照(窗内账号变更以首片为准;restore 重建) + srcID string + mobile string + extCode string + total uint8 + ref uint8 // 组键 ref(Day 71:持久化 restore 组键还原) + ucs2 bool // Day 70:首片 MsgFmt 编码快照(与 auth 快照同理,计费口径) + frags map[uint8]string // idx→剥头解码文本(CMPP 拆分按完整字符切,文本直拼安全) +} + +// longSmsGrouper 长短信聚合器(并发安全;内存+longsms_pending 双写)。 +type longSmsGrouper struct { + mu sync.Mutex + groups map[string]*pendingLong + window time.Duration // 挂起窗(默认 longSmsWindow;测试可调) + maxGroup int // 并发挂起组上限(默认 longSmsMaxGroup;测试可调) + db *gorm.DB // Day 71:挂起组持久化(nil=纯内存测试口径,零 DB) +} + +func newLongSmsGrouper(db *gorm.DB) *longSmsGrouper { + return &longSmsGrouper{groups: make(map[string]*pendingLong), + window: longSmsWindow, maxGroup: longSmsMaxGroup, db: db} +} + +// longSmsKey 组键(账号|srcID|手机号|ref;submitFragment 与 restore/reaper 共用)。 +func longSmsKey(accountID int64, srcID, mobile string, ref uint8) string { + return strconv.FormatInt(accountID, 10) + "|" + srcID + "|" + mobile + "|" + + strconv.FormatUint(uint64(ref), 10) +} + +// submitFragment 片提交:入组缓存(未齐回组ID 不发)/到齐合并单次受理。 +// precheck(账号+通道号前缀)已由调用方 Submit 完成,cfg 为验过快照。 +func (g *longSmsGrouper) submitFragment(api longSmsAPI, cfg *entity.AccountConfig, + sourceAddr, srcID, mobile, content string, udh *cmpp.UDHInfo, ucs2 bool) (uint64, byte) { + auth := &openapi.AuthContext{ + AccountID: cfg.AccountID, Username: sourceAddr, Config: cfg, + Source: send.TaskSourceCMPP, // Day 60:受理来源打标(CMPP 接入) + } + ext := strings.TrimPrefix(srcID, cfg.ExtCode) + key := longSmsKey(cfg.AccountID, srcID, mobile, udh.Ref) + + isNew := false + fragsJSON := "{}" + g.mu.Lock() + grp, ok := g.groups[key] + if ok && grp.total != udh.Total { + // 同组 ref 复用冲突(协议异常):本片退化直发,原组不受影响继续等齐。 + g.mu.Unlock() + metrics.LongSmsDegradeTotal.WithLabelValues("ref_conflict").Inc() + logger.L().Warn("cmpp_longsms_total_conflict", + zap.String("source_addr", sourceAddr), zap.String("mobile", mobile), + zap.Uint8("ref", udh.Ref), zap.Uint8("group_total", grp.total), + zap.Uint8("frag_total", udh.Total)) + return directSubmit(api, auth, mobile, ext, content, ucs2) + } + if !ok { + if len(g.groups) >= g.maxGroup { + // Day 71:超限新组拒绝(原退化直发废除——72h 挂起制下上限是 DoS + // 防线,拒绝+客户端重试优于无限挂起)。 + g.mu.Unlock() + metrics.LongSmsDegradeTotal.WithLabelValues("overflow").Inc() + logger.L().Warn("cmpp_longsms_group_overflow_reject", + zap.String("source_addr", sourceAddr), zap.String("mobile", mobile), + zap.Int("groups", len(g.groups))) + return 0, cmpp.SubmitRejected + } + grp = &pendingLong{ + groupID: uint64(api.NextMsgID()), + auth: auth, srcID: srcID, mobile: mobile, extCode: ext, + total: udh.Total, ref: udh.Ref, ucs2: ucs2, frags: make(map[uint8]string), + } + g.groups[key] = grp + isNew = true + } + if _, dup := grp.frags[udh.Idx]; dup { + metrics.LongSmsDupFragTotal.Inc() // 同 idx 重复片(客户端重发)覆盖,幂等 + } + grp.frags[udh.Idx] = content + merged := len(grp.frags) >= int(grp.total) + if merged { + delete(g.groups, key) // 与 reaper 到期处理互斥:后到片走新组 + } + fragsJSON = marshalFrags(grp.frags) // 持锁序列化(map 无并发写) + g.mu.Unlock() + + // 挂起组持久化(锁外;失败 Warn 降级继续内存聚合)。 + if g.db != nil { + if isNew { + g.persistInsert(grp, fragsJSON) + } else if !merged { + g.persistUpdate(grp.groupID, fragsJSON) + } else { + g.persistDelete(grp.groupID) + } + } + if !merged { + return grp.groupID, cmpp.SubmitOK // 未齐:仅受理确认,内容不发 + } + // 到齐:按序拼接全文单次受理(组ID 注入=首条 DetailID;fee=全文段数=上游片数)。 + var full strings.Builder + for i := uint8(1); i <= grp.total; i++ { + full.WriteString(grp.frags[i]) + } + metrics.LongSmsMergedTotal.Inc() + logger.L().Info("cmpp_longsms_merged", + zap.Uint64("group_id", grp.groupID), zap.Int("frags", int(grp.total)), + zap.Int("chars", len([]rune(full.String()))), zap.String("mobile", grp.mobile)) + resp := api.SendMassFast(context.Background(), grp.auth, &openapi.MassReq{ + PhoneList: []string{grp.mobile}, + Content: full.String(), + SignName: "", // CMPP 内容自带【签名】,与 submitDirect 同口径 + ExtCode: grp.extCode, + PresetMsgID: int64(grp.groupID), + // Day 70:计费段数=客户端 pk_total=运营商计费依据(与编码无关, + // 比任何口径重算都准);ContentEncoding 同步标注(冗余兜底)。 + FeeSegments: int(grp.total), + ContentEncoding: ucs2Encoding(grp.ucs2), + }, remoteIPPlaceholder) + if resp.Code != openapi.CodeOK { + logger.L().Warn("cmpp_submit_rejected", + zap.String("source_addr", grp.auth.Username), zap.Int("code", resp.Code), + zap.String("message", resp.Message), zap.Uint64("group_id", grp.groupID)) + return grp.groupID, cmpp.SubmitRejected + } + return grp.groupID, cmpp.SubmitOK +} + +// ---- 挂起组持久化(Day 71) ---- + +// marshalFrags frags map→JSON(持锁调用)。 +func marshalFrags(frags map[uint8]string) string { + if len(frags) == 0 { + return "{}" + } + b, err := json.Marshal(frags) + if err != nil { // map[uint8]string 不可能失败;防御 + return "{}" + } + return string(b) +} + +// unmarshalFrags JSON→frags map(restore/reaper 用;坏行=空组)。 +func unmarshalFrags(s string) map[uint8]string { + m := make(map[uint8]string) + if s != "" { + _ = json.Unmarshal([]byte(s), &m) + } + return m +} + +// persistInsert 新组落库(expire_at=created+window)。 +func (g *longSmsGrouper) persistInsert(grp *pendingLong, fragsJSON string) { + row := &entity.LongSmsPending{ + GroupID: grp.groupID, AccountID: grp.auth.AccountID, Username: grp.auth.Username, + SrcID: grp.srcID, Mobile: grp.mobile, ExtCode: grp.extCode, + Ref: grp.ref, Total: grp.total, Ucs2: grp.ucs2, Frags: fragsJSON, + ExpireAt: time.Now().Add(g.window), + } + if err := g.db.Create(row).Error; err != nil { + logger.L().Warn("cmpp_longsms_persist_insert_failed", + zap.Uint64("group_id", grp.groupID), zap.Error(err)) + } +} + +// persistUpdate 续片全量替换(同组片串行到达,无并发写冲突)。 +func (g *longSmsGrouper) persistUpdate(groupID uint64, fragsJSON string) { + if err := g.db.Model(&entity.LongSmsPending{}).Where("group_id = ?", groupID). + Update("frags", fragsJSON).Error; err != nil { + logger.L().Warn("cmpp_longsms_persist_update_failed", + zap.Uint64("group_id", groupID), zap.Error(err)) + } +} + +// persistDelete 到齐/终态后删行(g.db nil 安全)。 +func (g *longSmsGrouper) persistDelete(groupID uint64) { + if g.db == nil { + return + } + if err := g.db.Where("group_id = ?", groupID). + Delete(&entity.LongSmsPending{}).Error; err != nil { + logger.L().Warn("cmpp_longsms_persist_delete_failed", + zap.Uint64("group_id", groupID), zap.Error(err)) + } +} + +// removeGroupByKey reaper 到期处理前取走内存组(与到齐路径同互斥域; +// 后到片见不到组→按新组处理,组死亡事实由 DB 行快照决定)。 +func (g *longSmsGrouper) removeGroupByKey(key string) { + g.mu.Lock() + delete(g.groups, key) + g.mu.Unlock() +} + +// restore 进程重启:挂起组回内存继续等片(72h 内补齐仍可正常受理)。 +// auth 重建失败(账号删除/停用)的组不恢复——留 DB 行由 reaper 到期失败终态; +// 片若再来将开新组(同 ref 键,新雪花组ID)。返回恢复组数。 +func (g *longSmsGrouper) restore( + loadAuth func(username string, accountID int64) *openapi.AuthContext) int { + if g.db == nil { + return 0 + } + var rows []entity.LongSmsPending + if err := g.db.Where("expire_at > ?", time.Now()).Find(&rows).Error; err != nil { + logger.L().Warn("cmpp_longsms_restore_load_failed", zap.Error(err)) + return 0 + } + n := 0 + for _, r := range rows { + auth := loadAuth(r.Username, r.AccountID) + if auth == nil || auth.Config == nil { + continue // 账号已失效:等 reaper 到期失败终态 + } + key := longSmsKey(r.AccountID, r.SrcID, r.Mobile, r.Ref) + g.mu.Lock() + if _, ok := g.groups[key]; !ok { // 防重复 restore + g.groups[key] = &pendingLong{ + groupID: r.GroupID, auth: auth, srcID: r.SrcID, mobile: r.Mobile, + extCode: r.ExtCode, total: r.Total, ucs2: r.Ucs2, + frags: unmarshalFrags(r.Frags), + } + n++ + } + g.mu.Unlock() + } + return n +} + +// ucs2Encoding bool→计费口径编码(send.ContentEncoding*,Day 70)。 +func ucs2Encoding(ucs2 bool) int8 { + if ucs2 { + return send.ContentEncodingUCS2 + } + return send.ContentEncodingDefault +} + +// directSubmit 单片独立受理(ref 冲突异常片直发;账号已 precheck)。 +// RegisteredDelivery 与 submitDirect 同口径:回执由 Day61 push 链按明细 +// 驱动,受理参数不传递。返回值仅异常片直发路径用到。 +func directSubmit(api longSmsAPI, auth *openapi.AuthContext, + mobile, ext, content string, ucs2 bool) (uint64, byte) { + resp := api.SendMassFast(context.Background(), auth, &openapi.MassReq{ + PhoneList: []string{mobile}, + Content: content, + SignName: "", // CMPP 内容自带【签名】,与 submitDirect 同口径 + ExtCode: ext, + // Day 70:按提交编码分流计费口径(fee≡上游真实片数)。 + ContentEncoding: ucs2Encoding(ucs2), + }, remoteIPPlaceholder) + if resp.Code != openapi.CodeOK { + logger.L().Warn("cmpp_submit_rejected", + zap.String("source_addr", auth.Username), zap.Int("code", resp.Code), + zap.String("message", resp.Message)) + return 0, cmpp.SubmitRejected + } + return uint64(resp.MsgID), cmpp.SubmitOK +} diff --git a/internal/service/access/longsms_reaper.go b/internal/service/access/longsms_reaper.go new file mode 100644 index 00000000..1f479762 --- /dev/null +++ b/internal/service/access/longsms_reaper.go @@ -0,0 +1,194 @@ +// longsms_reaper.go Day 71:长短信挂起组 72h 到期扫描器(gateway 进程 1min 周期)。 +// 「不齐不发,到期失败」制的终态执行者: +// - 到期不齐→失败终态:task LP+组ID(uk 幂等锚)+detail id=组ID(status=3/ +// fee=0/ErrorCode=LSM:NOTCMPL)+UNDELIV 回执事件投 PushSink(经 Kafka +// cmpp-deliver 回环,DeliverPusher 推给下家在线连接;离线=尽力而为, +// 失败记录已落 task/detail 前端可查); +// - 到期已齐(到齐删行失败兜底/恢复组窗口内补片迟删)→detail 存在性防重 +// 后补 merged(正常 SendMassFast 受理);受理拒绝(余额不足等)→失败终态; +// - 处理完删挂起行+取走内存组(与到齐路径同互斥域,后到片开新组)。 +// +// 幂等:task_no uk/detail pk 双锚 OnConflict DoNothing——重复扫描/与片路径 +// 并发时至多一次生效(残留行不累积,扫描自清)。 +package access + +import ( + "context" + "strconv" + "time" + + "go-sms/internal/pkg/metrics" + + "go-sms/internal/model/entity" + "go-sms/internal/pkg/logger" + "go-sms/internal/service/openapi" + "go-sms/internal/service/report" + "go-sms/internal/service/send" + + "go.uber.org/zap" + "gorm.io/gorm" + "gorm.io/gorm/clause" +) + +// longSmsReaperBatch 单轮扫描上限(72h 到期组正常为慢积累,500 足够; +// 异常风暴时多轮消化,防单轮长事务)。 +const longSmsReaperBatch = 500 + +// longSmsReaper 挂起组到期扫描器。 +type longSmsReaper struct { + g *longSmsGrouper + api longSmsAPI + db *gorm.DB + push report.PushSink + loadAuth func(username string, accountID int64) *openapi.AuthContext +} + +func newLongSmsReaper(g *longSmsGrouper, api longSmsAPI, db *gorm.DB, push report.PushSink, + loadAuth func(username string, accountID int64) *openapi.AuthContext) *longSmsReaper { + return &longSmsReaper{g: g, api: api, db: db, push: push, loadAuth: loadAuth} +} + +// Run 周期扫描(启动即一轮;every<=0 默认 1min;ctx 取消退出)。 +func (r *longSmsReaper) Run(ctx context.Context, every time.Duration) { + if every <= 0 { + every = time.Minute + } + fail, merged := r.ScanOnce(ctx) + if fail > 0 || merged > 0 { + logger.L().Info("cmpp_longsms_reaper_first_round", + zap.Int("expire_fail", fail), zap.Int("remerged", merged)) + } + tk := time.NewTicker(every) + defer tk.Stop() + for { + select { + case <-ctx.Done(): + return + case <-tk.C: + r.ScanOnce(ctx) + } + } +} + +// ScanOnce 扫一轮到期行,返回 (失败终态数, 补 merged 数)。 +func (r *longSmsReaper) ScanOnce(ctx context.Context) (fail, merged int) { + var rows []entity.LongSmsPending + if err := r.db.WithContext(ctx). + Where("expire_at <= ?", time.Now()). + Limit(longSmsReaperBatch).Find(&rows).Error; err != nil { + logger.L().Warn("cmpp_longsms_reaper_scan_failed", zap.Error(err)) + return 0, 0 + } + for _, row := range rows { + // 取走内存组(互斥;片路径此后走新组)——组死亡事实以 DB 行快照为准。 + r.g.removeGroupByKey(longSmsKey(row.AccountID, row.SrcID, row.Mobile, row.Ref)) + frags := unmarshalFrags(row.Frags) + if len(frags) >= int(row.Total) { + switch r.remerge(ctx, row, frags) { + case 2: // 补受理成功 + merged++ + case 1: // detail 已存在(正常到齐路径已受理,删行失败残留):幂等清行 + default: // 受理拒绝(余额不足/账号失效):走失败终态 + r.failFinalize(ctx, row, frags) + fail++ + } + } else { + r.failFinalize(ctx, row, frags) + fail++ + } + r.g.persistDelete(row.GroupID) + } + return fail, merged +} + +// remerge 到期已齐组补受理;返回 2=补受理成功,1=detail 已存在(幂等清行), +// 0=受理拒绝/账号失效(调用方走失败终态)。 +func (r *longSmsReaper) remerge(ctx context.Context, row entity.LongSmsPending, + frags map[uint8]string) int { + // detail 存在性防重:组ID 已存在=正常到齐路径已受理(删行失败残留)。 + var cnt int64 + if err := r.db.WithContext(ctx).Table("message_detail"). + Where("id = ?", row.GroupID).Count(&cnt).Error; err == nil && cnt > 0 { + return 1 // 幂等:已受理过,仅清行 + } + auth := r.loadAuth(row.Username, row.AccountID) + if auth == nil || auth.Config == nil { + return 0 // 账号已失效:走失败终态 + } + var full string + for i := uint8(1); i <= row.Total; i++ { + full += frags[i] + } + metrics.LongSmsMergedTotal.Inc() + resp := r.api.SendMassFast(ctx, auth, &openapi.MassReq{ + PhoneList: []string{row.Mobile}, + Content: full, + SignName: "", // CMPP 内容自带【签名】,与 submitFragment 同口径 + ExtCode: row.ExtCode, + PresetMsgID: int64(row.GroupID), + // 与 submitFragment 到齐路径完全同参(Day 70 计费口径)。 + FeeSegments: int(row.Total), + ContentEncoding: ucs2Encoding(row.Ucs2), + }, remoteIPPlaceholder) + if resp.Code != openapi.CodeOK { + logger.L().Warn("cmpp_longsms_remerge_rejected", + zap.Uint64("group_id", row.GroupID), zap.Int("code", resp.Code), + zap.String("message", resp.Message)) + return 0 // 受理拒绝(余额不足等):走失败终态 + } + logger.L().Info("cmpp_longsms_remerged", + zap.Uint64("group_id", row.GroupID), zap.Int("frags", int(row.Total))) + return 2 +} + +// failFinalize 失败终态:LP task+失败 detail+UNDELIV 回执(幂等双锚)。 +func (r *longSmsReaper) failFinalize(ctx context.Context, row entity.LongSmsPending, + frags map[uint8]string) { + now := time.Now() + var full string + for i := uint8(1); i <= row.Total; i++ { // 已收片按序拼残文(缺片空串) + full += frags[i] + } + taskNo := "LP" + strconv.FormatUint(row.GroupID, 10) + task := entity.MessageTask{ + TaskNo: taskNo, AccountID: row.AccountID, + SendType: 1, Content: full, MobileCount: 1, FailCount: 1, FeeTotal: 0, + AuditStatus: 3, // 免审(未走审核链) + Status: 2, // 终态完成(taskStDone) + FinishedAt: &now, Business: "sms", Source: send.TaskSourceCMPP, + } + if err := r.db.WithContext(ctx).Clauses(clause.OnConflict{DoNothing: true}). + Create(&task).Error; err != nil && task.ID == 0 { + logger.L().Warn("cmpp_longsms_fail_task_create_failed", + zap.Uint64("group_id", row.GroupID), zap.Error(err)) + } + if task.ID == 0 { // uk 冲突(重复扫描/与片路径并发)→回读已存在行 + _ = r.db.WithContext(ctx).Table("message_task").Select("id"). + Where("task_no = ?", taskNo).Scan(&task.ID).Error + } + detail := entity.MessageDetail{ + SnowflakeModel: entity.SnowflakeModel{ID: int64(row.GroupID)}, + TaskID: task.ID, AccountID: row.AccountID, + Mobile: row.Mobile, Content: full, + Status: 3, ErrorCode: longSmsIncompleteCode, Fee: 0, + SendAt: &now, ReportAt: &now, Business: "sms", Source: send.TaskSourceCMPP, + } + if err := r.db.WithContext(ctx).Clauses(clause.OnConflict{DoNothing: true}). + Create(&detail).Error; err != nil { + logger.L().Warn("cmpp_longsms_fail_detail_create_failed", + zap.Uint64("group_id", row.GroupID), zap.Error(err)) + } + metrics.LongSmsExpireFailTotal.Inc() + logger.L().Info("cmpp_longsms_expire_fail", + zap.Uint64("group_id", row.GroupID), zap.Uint8("total", row.Total), + zap.Int("got", len(frags)), zap.String("mobile", row.Mobile), + zap.Int64("detail_id", int64(row.GroupID))) + // UNDELIV 回执(source 恒 CMPP 无需再查;时间格式=CMPP MMDDHHMMSS)。 + if r.push != nil { + ts := now.Format("0102150405") + _ = r.push.PushDeliver(ctx, &report.DeliverEvent{ + AccountID: row.AccountID, DetailID: int64(row.GroupID), Mobile: row.Mobile, + Stat: "UNDELIV", SubmitAt: ts, DoneAt: ts, + }) + } +} diff --git a/internal/service/access/longsms_test.go b/internal/service/access/longsms_test.go new file mode 100644 index 00000000..67a3de61 --- /dev/null +++ b/internal/service/access/longsms_test.go @@ -0,0 +1,360 @@ +// longsms_test.go 长短信聚合测试(批次 2278141/2278142 修复+Day 71 挂起制): +// 2 片聚 1 task(全文/计费段数=上游片数/组ID=首条 DetailID+片级 Resp 复用)、 +// 72h 到期不齐失败终态(LP task+失败 detail+UNDELIV 回执,不退化直发)、 +// 重启 restore 回内存后补片到齐正常受理、到期已齐幂等补 merged、 +// 超限新组拒绝、同 idx 重复片幂等、多目的码片不进聚合。 +// 复用 access_test 基建(sqlite+stub sink/bal+真实 openapi 链路)。 +package access + +import ( + "context" + "strconv" + "strings" + "testing" + "time" + + "go-sms/internal/model/entity" + "go-sms/internal/protocol/cmpp" + "go-sms/internal/service/report" + "gorm.io/gorm" +) + +// lsPushStub Day 71:reaper 回执出口桩(记录 DeliverEvent 供断言)。 +type lsPushStub struct{ events []*report.DeliverEvent } + +func (p *lsPushStub) PushDeliver(_ context.Context, ev *report.DeliverEvent) error { + p.events = append(p.events, ev) + return nil +} + +// newReaper 便捷:Service 同件装配 reaper+回执桩。 +func newReaper(s *Service, db *gorm.DB) (*longSmsReaper, *lsPushStub) { + push := &lsPushStub{} + return newLongSmsReaper(s.grouper, s.api, db, push, s.restoreLongSmsAuth), push +} + +// expireNow 便捷:全部挂起行置为已到期。 +func expireNow(t *testing.T, db *gorm.DB) { + t.Helper() + if err := db.Model(&entity.LongSmsPending{}).Where("1=1"). + Update("expire_at", time.Now().Add(-time.Minute)).Error; err != nil { + t.Fatal(err) + } +} + +// fragSubmit 便捷:经 Service.Submit 提交一片(UDH 已由协议层剥离)。 +func fragSubmit(s *Service, content string, ref, total, idx uint8) (uint64, byte) { + return s.Submit("cmpp_user", "UT:001299", []string{"13800138000"}, content, + &cmpp.UDHInfo{Ref: ref, Total: total, Idx: idx}, 1, cmpp.MsgFmtUCS2) +} + +// TestLongSmsMerge2Frags 2 片到齐:合并为 1 task(全文无乱码/fee=段数=上游 +// 片数/组ID=首条 DetailID);N 片 Resp msg_id 同组ID(决策③)。 +func TestLongSmsMerge2Frags(t *testing.T) { + db := newAccessDB(t) + seedAccount(t, db) + s, sink := newSvc(t, db) + s.grouper.window = 50 * time.Millisecond // 压窗:合并后超时亦不得重发 + + p1 := "【签名】" + strings.Repeat("甲", 60) // 63 字 126B + p2 := strings.Repeat("乙", 5) // 5 字 10B;全文 68 字 136B→2 条(=上游 2 片) + m1, r1 := fragSubmit(s, p1, 7, 2, 1) + m2, r2 := fragSubmit(s, p2, 7, 2, 2) + if r1 != cmpp.SubmitOK || r2 != cmpp.SubmitOK { + t.Fatalf("r1=%d r2=%d", r1, r2) + } + if m1 == 0 || m1 != m2 { + t.Fatalf("片级 Resp 应同组ID(决策③): %d vs %d", m1, m2) + } + if len(sink.tasks) != 1 { + t.Fatalf("到齐应合并单次受理(1 task): tasks=%d", len(sink.tasks)) + } + if got := sink.tasks[0].Content; got != p1+p2 { + t.Fatalf("task 内容应为全文: got %q", got) + } + if len(sink.details[0]) != 1 { + t.Fatalf("明细应 1 条: %d", len(sink.details[0])) + } + if uint64(sink.details[0][0].ID) != m1 { + t.Fatalf("组ID 应=首条 DetailID(回执同口径): %d vs %d", sink.details[0][0].ID, m1) + } + if sink.details[0][0].Fee != 2 || sink.tasks[0].FeeTotal != 2 { + t.Fatalf("fee 应=2(计费对齐上游 2 片): detail=%v task=%v", + sink.details[0][0].Fee, sink.tasks[0].FeeTotal) + } + // Day 71:到齐即删挂起行(timer 已废除,到期扫描不得重发)。 + var pend int64 + db.Model(&entity.LongSmsPending{}).Count(&pend) + if pend != 0 { + t.Fatalf("到齐后挂起行应删净: %d", pend) + } +} + +// TestLongSmsMerge3FragsUCS2Fee Day 70(批次 2344043 复刻):UCS2 客户端 +// 156 字符(90 ASCII+66 中文)拆 3 片(67+67+22)——GBK 口径全文 222B=2 条 +// 少计 1 条;修复后聚合 fee=FeeSegments=pk_total=3=运营商计费依据。 +func TestLongSmsMerge3FragsUCS2Fee(t *testing.T) { + db := newAccessDB(t) + seedAccount(t, db) + s, sink := newSvc(t, db) + s.grouper.window = 50 * time.Millisecond + + full := strings.Repeat("a", 90) + strings.Repeat("汉", 66) // 156 字符 + p1 := string([]rune(full)[:67]) + p2 := string([]rune(full)[67:134]) + p3 := string([]rune(full)[134:]) + if _, r := fragSubmit(s, p1, 9, 3, 1); r != cmpp.SubmitOK { + t.Fatalf("r1=%d", r) + } + if _, r := fragSubmit(s, p2, 9, 3, 2); r != cmpp.SubmitOK { + t.Fatalf("r2=%d", r) + } + if _, r := fragSubmit(s, p3, 9, 3, 3); r != cmpp.SubmitOK { + t.Fatalf("r3=%d", r) + } + if len(sink.tasks) != 1 { + t.Fatalf("3 片到齐应合并单次受理: tasks=%d", len(sink.tasks)) + } + if got := sink.tasks[0].Content; got != full { + t.Fatalf("task 内容应为全文: got %q", got) + } + if sink.details[0][0].Fee != 3 || sink.tasks[0].FeeTotal != 3 { + t.Fatalf("fee 应=3(=客户端 pk_total=运营商计费依据;GBK 口径少计 1 条的根修): "+ + "detail=%v task=%v", sink.details[0][0].Fee, sink.tasks[0].FeeTotal) + } +} + +// TestLongSmsExpireFailFinalize Day 71:72h 到期不齐→失败终态,不退化直发。 +// LP task(fail_count=1/fee=0)+detail id=组ID(status=3/LSM:NOTCMPL)+ +// UNDELIV 回执事件;片 Resp 已回 OK 语义=下家窗内不收齐不提交。 +func TestLongSmsExpireFailFinalize(t *testing.T) { + db := newAccessDB(t) + seedAccount(t, db) + s, sink := newSvc(t, db) + + p1 := "【签名】" + strings.Repeat("甲", 60) + m1, r1 := fragSubmit(s, p1, 9, 2, 1) + if r1 != cmpp.SubmitOK || m1 == 0 { + t.Fatalf("r1=%d m1=%d", r1, m1) + } + if len(sink.tasks) != 0 { + t.Fatal("未齐不应受理") + } + expireNow(t, db) + rp, push := newReaper(s, db) + fail, merged := rp.ScanOnce(context.Background()) + if fail != 1 || merged != 0 { + t.Fatalf("到期不齐应 1 失败终态 0 补受理: fail=%d merged=%d", fail, merged) + } + if len(sink.tasks) != 0 { + t.Fatalf("到期不齐不得退化直发: tasks=%d", len(sink.tasks)) + } + var task entity.MessageTask + if err := db.Where("task_no = ?", "LP"+u64s(m1)).First(&task).Error; err != nil { + t.Fatalf("LP task 应落库: %v", err) + } + if task.Status != 2 || task.FailCount != 1 || task.FeeTotal != 0 { + t.Fatalf("LP task 终态/计数/零费: status=%d fail=%d fee=%v", + task.Status, task.FailCount, task.FeeTotal) + } + if !strings.HasPrefix(task.Content, p1) { + t.Fatalf("LP task 内容应为已收片残文: %q", task.Content) + } + var d entity.MessageDetail + if err := db.First(&d, int64(m1)).Error; err != nil { + t.Fatalf("失败 detail(组ID 主键)应落库: %v", err) + } + if d.Status != 3 || d.ErrorCode != longSmsIncompleteCode || d.Fee != 0 { + t.Fatalf("失败 detail 终态/错误码/零费: status=%d code=%s fee=%v", + d.Status, d.ErrorCode, d.Fee) + } + if d.TaskID != task.ID { + t.Fatalf("detail 应挂 LP task: %d vs %d", d.TaskID, task.ID) + } + if len(push.events) != 1 || push.events[0].Stat != "UNDELIV" || + push.events[0].DetailID != int64(m1) { + t.Fatalf("应推 1 条 UNDELIV 回执(组ID): %+v", push.events) + } + var pend int64 + db.Model(&entity.LongSmsPending{}).Count(&pend) + if pend != 0 { + t.Fatalf("到期处理完挂起行应删净: %d", pend) + } + // 幂等:重复扫描空转(行已删)。 + if fail, merged = rp.ScanOnce(context.Background()); fail != 0 || merged != 0 { + t.Fatalf("重复扫描应空转: fail=%d merged=%d", fail, merged) + } +} + +// u64s 便捷:uint64→string(测试断言拼 LP task_no)。 +func u64s(v uint64) string { return strconv.FormatUint(v, 10) } + +// TestLongSmsRestoreThenMerge Day 71:重启恢复——挂起组回内存后补片 +// 到齐正常受理(组ID 不变=片级 Resp 语义跨重启延续)。 +func TestLongSmsRestoreThenMerge(t *testing.T) { + db := newAccessDB(t) + seedAccount(t, db) + s, _ := newSvc(t, db) // 片1 走 s(仅挂起,无受理);断言受理在重启后的 s2 + + p1, p2 := "【签名】片一", "片二" + m1, r1 := fragSubmit(s, p1, 11, 2, 1) + if r1 != cmpp.SubmitOK || m1 == 0 { + t.Fatalf("r1=%d m1=%d", r1, m1) + } + // 模拟重启:新 Service 同库装配(grouper 内存已空)→restore。 + s2, sink2 := newSvc(t, db) + if n := s2.grouper.restore(s2.restoreLongSmsAuth); n != 1 { + t.Fatalf("restore 应恢复 1 组: %d", n) + } + m2, r2 := fragSubmit(s2, p2, 11, 2, 2) + if r2 != cmpp.SubmitOK || m2 != m1 { + t.Fatalf("恢复组补片应到齐且组ID 延续: r2=%d m1=%d m2=%d", r2, m1, m2) + } + if len(sink2.tasks) != 1 || sink2.tasks[0].Content != p1+p2 { + t.Fatalf("恢复后到齐应合并全文: tasks=%d content=%q", + len(sink2.tasks), sink2.tasks[0].Content) + } + if uint64(sink2.details[0][0].ID) != m1 { + t.Fatalf("组ID=首条 DetailID 跨重启不变: %d vs %d", sink2.details[0][0].ID, m1) + } + var pend int64 + db.Model(&entity.LongSmsPending{}).Count(&pend) + if pend != 0 { + t.Fatalf("到齐后挂起行应删净: %d", pend) + } +} + +// TestLongSmsExpireMergedIdempotent Day 71:到期已齐(到齐删行失败兜底)—— +// detail 存在性防重:未受理→补 merged;已受理→仅清行零重复。 +func TestLongSmsExpireMergedIdempotent(t *testing.T) { + db := newAccessDB(t) + seedAccount(t, db) + s, sink := newSvc(t, db) + + p1, p2 := "【签名】甲", "乙" + m1, _ := fragSubmit(s, p1, 13, 2, 1) + fragSubmit(s, p2, 13, 2, 2) // 到齐受理+删行 + if len(sink.tasks) != 1 { + t.Fatalf("预置:正常到齐应 1 task: %d", len(sink.tasks)) + } + // 模拟消费侧已落明细(测试 sink 截获 Kafka 事件不落库,生产明细由消费侧落) + // +删行失败残留:手工还原一行「齐组」。 + db.Create(&entity.MessageDetail{ + SnowflakeModel: entity.SnowflakeModel{ID: int64(m1)}, AccountID: 1, Mobile: "13800138000"}) + db.Create(&entity.LongSmsPending{ + GroupID: m1, AccountID: seedAccountID(t, db), Username: "cmpp_user", + SrcID: "UT:001299", Mobile: "13800138000", Total: 2, Ucs2: true, + Frags: `{"1":"` + p1 + `","2":"` + p2 + `"}`, + ExpireAt: time.Now().Add(-time.Minute), + }) + expireNow(t, db) + rp, _ := newReaper(s, db) + fail, merged := rp.ScanOnce(context.Background()) + if fail != 0 || merged != 0 { + t.Fatalf("已受理残留应仅清行(0 失败 0 补受理): fail=%d merged=%d", fail, merged) + } + if len(sink.tasks) != 1 { + t.Fatalf("detail 防重不得重复受理: tasks=%d", len(sink.tasks)) + } + var pend int64 + db.Model(&entity.LongSmsPending{}).Count(&pend) + if pend != 0 { + t.Fatalf("残留行应清: %d", pend) + } + // 反例:齐组但未受理(如受理中途崩溃)→补 merged(明细由消费侧落库, + // 测试断言受理侧 sink)。 + db.Create(&entity.LongSmsPending{ + GroupID: m1 + 1, AccountID: seedAccountID(t, db), Username: "cmpp_user", + SrcID: "UT:001299", Mobile: "13800138001", Total: 2, Ucs2: true, + Frags: `{"1":"` + p1 + `","2":"` + p2 + `"}`, + ExpireAt: time.Now().Add(-time.Minute), + }) + if fail, merged = rp.ScanOnce(context.Background()); fail != 0 || merged != 1 { + t.Fatalf("未受理齐组应补 1 merged: fail=%d merged=%d", fail, merged) + } + if len(sink.tasks) != 2 || sink.tasks[1].Content != p1+p2 { + t.Fatalf("补受理应对齐齐组全文: tasks=%d last=%q", + len(sink.tasks), sink.tasks[len(sink.tasks)-1].Content) + } + if uint64(sink.details[1][0].ID) != m1+1 { + t.Fatalf("补受理组ID=首条 DetailID(幂等锚): %d vs %d", + sink.details[1][0].ID, m1+1) + } +} + +// seedAccountID 便捷:回查种子账号 ID。 +func seedAccountID(t *testing.T, db *gorm.DB) int64 { + t.Helper() + var u entity.AccountUser + if err := db.Where("username = ?", "cmpp_user").First(&u).Error; err != nil { + t.Fatal(err) + } + return u.ID +} + +// TestLongSmsOverflowReject Day 71:并发挂起组超限→新组拒绝 SubmitRejected +// (客户端重试;原退化直发废除)。 +func TestLongSmsOverflowReject(t *testing.T) { + db := newAccessDB(t) + seedAccount(t, db) + s, sink := newSvc(t, db) + s.grouper.maxGroup = 1 // 压限 + + if _, r := fragSubmit(s, "【签名】组一片", 15, 2, 1); r != cmpp.SubmitOK { + t.Fatalf("首组应受理: r=%d", r) + } + m2, r2 := s.Submit("cmpp_user", "UT:001299", []string{"13800138001"}, + "【签名】另一组", &cmpp.UDHInfo{Ref: 16, Total: 2, Idx: 1}, 1, cmpp.MsgFmtUCS2) + if r2 != cmpp.SubmitRejected || m2 != 0 { + t.Fatalf("超限新组应拒绝: r=%d m=%d", r2, m2) + } + if len(sink.tasks) != 0 { + t.Fatalf("超限拒绝不得受理: tasks=%d", len(sink.tasks)) + } +} + +// TestLongSmsDupFragment 同 idx 重复片(客户端重发)幂等:覆盖不重复受理。 +func TestLongSmsDupFragment(t *testing.T) { + db := newAccessDB(t) + seedAccount(t, db) + s, sink := newSvc(t, db) + + p1, p2 := "【签名】片一", "片二" + if _, r := fragSubmit(s, p1, 5, 2, 1); r != cmpp.SubmitOK { + t.Fatalf("r=%d", r) + } + if _, r := fragSubmit(s, p1, 5, 2, 1); r != cmpp.SubmitOK { // 重发片1 + t.Fatalf("r=%d", r) + } + if _, r := fragSubmit(s, p2, 5, 2, 2); r != cmpp.SubmitOK { + t.Fatalf("r=%d", r) + } + if len(sink.tasks) != 1 { + t.Fatalf("重复片幂等应仍 1 task: %d", len(sink.tasks)) + } + if sink.tasks[0].Content != p1+p2 { + t.Fatalf("全文应无重复片: got %q", sink.tasks[0].Content) + } +} + +// TestLongSmsMultiDestNotAggregated 多目的码片不进聚合(协议不允许,防御): +// 走原直发路径,1 task N 明细,msgID=首条 DetailID 口径不变。 +func TestLongSmsMultiDestNotAggregated(t *testing.T) { + db := newAccessDB(t) + seedAccount(t, db) + s, sink := newSvc(t, db) + + m, r := s.Submit("cmpp_user", "UT:001299", + []string{"13800138000", "13800138001"}, "【签名】片文本", + &cmpp.UDHInfo{Ref: 3, Total: 2, Idx: 1}, 1, cmpp.MsgFmtUCS2) + if r != cmpp.SubmitOK { + t.Fatalf("r=%d", r) + } + if len(sink.tasks) != 1 || len(sink.details[0]) != 2 { + t.Fatalf("多目的码片应走直发(1 task 2 明细): tasks=%d details=%d", + len(sink.tasks), len(sink.details[0])) + } + if uint64(sink.details[0][0].ID) != m { + t.Fatalf("直发 msgID=首条 DetailID 口径不变: %d vs %d", sink.details[0][0].ID, m) + } +} diff --git a/internal/service/access/push.go b/internal/service/access/push.go new file mode 100644 index 00000000..067811d8 --- /dev/null +++ b/internal/service/access/push.go @@ -0,0 +1,61 @@ +// push.go Day 61(P0.5):cmpp-deliver 消费桥(gateway 进程)——回执终态事件 +// →账号用户名反查→CMPP Server 会话注册表→PushDeliver 到客户活跃连接。 +package access + +import ( + "context" + "encoding/json" + + "go-sms/internal/model/entity" + "go-sms/internal/pkg/logger" + "go-sms/internal/protocol/cmpp" + "go-sms/internal/service/report" + "go.uber.org/zap" + "gorm.io/gorm" +) + +// DeliverPusher cmpp-deliver 事件→协议侧下发。 +type DeliverPusher struct { + db *gorm.DB + sv *cmpp.Server +} + +// NewDeliverPusher 构造(sv=nil 静默丢弃——CMPP 未启用场景)。 +func NewDeliverPusher(db *gorm.DB, sv *cmpp.Server) *DeliverPusher { + return &DeliverPusher{db: db, sv: sv} +} + +// HandlePayload Kafka 消费入口(载荷=report.DeliverEvent JSON)。 +// 账号离线/无会话=正常路径(Warn 观测,事件消费完成不重试——离线补推属 P1)。 +func (p *DeliverPusher) HandlePayload(_ context.Context, value []byte) error { + var ev report.DeliverEvent + if err := json.Unmarshal(value, &ev); err != nil { + return err // 非法载荷→死信(与 report 消费同口径) + } + if p.sv == nil { + return nil + } + var u entity.AccountUser + if err := p.db.WithContext(context.Background()). + Select("username").Where("id = ?", ev.AccountID).First(&u).Error; err != nil { + logger.L().Warn("cmpp_deliver_account_missing", zap.Int64("account_id", ev.AccountID), zap.Error(err)) + return nil // 账号已删:丢弃(重试无意义) + } + d := &cmpp.Deliver{ + MsgID: uint64(ev.DetailID), // 平台 MsgID 口径(=Submit_Resp 应答值) + DestID: "", ServiceID: "", MsgFmt: 8, // MsgFmt=UCS2 占位(状态报告体不涉内容编码) + SrcTerminal: ev.Mobile, + IsReport: true, + Report: &cmpp.ReportInfo{ + MsgID: uint64(ev.DetailID), Stat: ev.Stat, + SubmitTime: ev.SubmitAt, DoneTime: ev.DoneAt, + DestTerminalID: ev.Mobile, + }, + } + sent := p.sv.PushDeliver(u.Username, d) + logger.L().Info("cmpp_deliver_pushed", + zap.Int64("account_id", ev.AccountID), zap.String("username", u.Username), + zap.Int64("detail_id", ev.DetailID), zap.String("stat", ev.Stat), + zap.Int("connections", sent)) + return nil +}