From 5ce1d0940a2447004a7b32d0b2e9d1d3f0a16390 Mon Sep 17 00:00:00 2001 From: Tory Date: Fri, 13 Nov 2026 16:37:02 +0800 Subject: [PATCH] =?UTF-8?q?S1-B=20D2.5:=20B=20=E5=B1=82=E6=90=AC=E8=BF=90?= =?UTF-8?q?=20channel(=E9=80=9A=E9=81=93=E5=9F=9F=2018=20=E6=96=87?= =?UTF-8?q?=E4=BB=B6,P1=20=E7=AD=89=E4=BB=B7=E9=9B=B6=E6=94=B9=E5=8A=A8;77?= =?UTF-8?q?.8%=20=E8=A6=86=E7=9B=96;P2=20=E6=8B=86=20pool/limiter=20?= =?UTF-8?q?=E5=AD=90=E5=8C=85=E6=8C=89=E6=96=B9=E6=A1=88=E9=9A=8F=E5=90=8E?= =?UTF-8?q?)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- internal/service/channel/alert.go | 162 +++++ internal/service/channel/alert_test.go | 174 +++++ internal/service/channel/group.go | 164 +++++ internal/service/channel/group_test.go | 110 +++ internal/service/channel/link.go | 509 ++++++++++++++ internal/service/channel/link_day40_test.go | 161 +++++ internal/service/channel/link_split_test.go | 166 +++++ internal/service/channel/link_test.go | 431 ++++++++++++ internal/service/channel/log.go | 250 +++++++ internal/service/channel/log_test.go | 83 +++ internal/service/channel/monitor.go | 152 +++++ internal/service/channel/monitor_test.go | 59 ++ internal/service/channel/price.go | 82 +++ internal/service/channel/price_test.go | 91 +++ internal/service/channel/service.go | 703 ++++++++++++++++++++ internal/service/channel/service_test.go | 520 +++++++++++++++ internal/service/channel/upstream.go | 111 ++++ internal/service/channel/upstream_test.go | 80 +++ 18 files changed, 4008 insertions(+) create mode 100644 internal/service/channel/alert.go create mode 100644 internal/service/channel/alert_test.go create mode 100644 internal/service/channel/group.go create mode 100644 internal/service/channel/group_test.go create mode 100644 internal/service/channel/link.go create mode 100644 internal/service/channel/link_day40_test.go create mode 100644 internal/service/channel/link_split_test.go create mode 100644 internal/service/channel/link_test.go create mode 100644 internal/service/channel/log.go create mode 100644 internal/service/channel/log_test.go create mode 100644 internal/service/channel/monitor.go create mode 100644 internal/service/channel/monitor_test.go create mode 100644 internal/service/channel/price.go create mode 100644 internal/service/channel/price_test.go create mode 100644 internal/service/channel/service.go create mode 100644 internal/service/channel/service_test.go create mode 100644 internal/service/channel/upstream.go create mode 100644 internal/service/channel/upstream_test.go diff --git a/internal/service/channel/alert.go b/internal/service/channel/alert.go new file mode 100644 index 00000000..5e28f561 --- /dev/null +++ b/internal/service/channel/alert.go @@ -0,0 +1,162 @@ +// alert.go Day 40(A-3.12):通道告警服务。 +// 复用 Day 27 余额预警的 SystemAlertRule(target_type=channel)+notify webhook 基建: +// - metric=link_down : 应建链而全断(running 且 healthy==0,或启用中 cmpp 通道未建链)→ 触发; +// - metric=fail_rate : 60s 窗口提交失败占比 > threshold(0~1,语义固定 gt)→ 触发; +// 触发后走 NotifyType/NotifyTo webhook(企微/钉钉),CooldownMin 冷却去重(LastAlertAt 锚点)。 +package channel + +import ( + "context" + "fmt" + "time" + + "gorm.io/gorm" + + "go-sms/internal/model/entity" + "go-sms/internal/pkg/notify" +) + +// 支持的通道告警指标。 +const ( + AlertMetricLinkDown = "link_down" + AlertMetricFailRate = "fail_rate" +) + +// AlertScanResult 扫描结果(测试/验收视图)。 +type AlertScanResult struct { + Rules int // 启用中的通道规则数 + Triggered int // 触发通知数 +} + +// ChannelAlertService 通道告警(nil 安全:未注入时 Evaluate/ScanOnce 为 no-op)。 +type ChannelAlertService struct { + db *gorm.DB + mon *Monitor + links func(id int64) *LinkStatus + newNotifier func(typ, url string) notify.Notifier + onLogged func(channelID int64, kind string, level int8, msgID, detail string, latencyMs int) +} + +// NewChannelAlertService 构造;links 为链路状态读取函数(解依赖环:linkManager ↔ alert)。 +// newNotifier 为 nil 时用 notify.NewWebhook(测试注入 fake)。 +func NewChannelAlertService(db *gorm.DB, mon *Monitor, links func(id int64) *LinkStatus, + newNotifier func(typ, url string) notify.Notifier) *ChannelAlertService { + if newNotifier == nil { + newNotifier = func(typ, url string) notify.Notifier { return notify.NewWebhook(typ, url) } + } + return &ChannelAlertService{db: db, mon: mon, links: links, newNotifier: newNotifier} +} + +// EvaluateChannel 单通道即时评估(断连事件触发;冷却由规则 CooldownMin 保证)。 +func (s *ChannelAlertService) EvaluateChannel(ctx context.Context, channelID int64) { + if s == nil || s.db == nil { + return + } + s.evaluate(ctx, &entity.SystemAlertRule{TargetType: "channel", TargetID: channelID}, false) +} + +// ScanOnce 全量扫描启用中的通道规则(cron 30s;含单通道)。 +func (s *ChannelAlertService) ScanOnce(ctx context.Context) (AlertScanResult, error) { + if s == nil || s.db == nil { + return AlertScanResult{}, nil + } + var rules []entity.SystemAlertRule + if err := s.db.WithContext(ctx).Where( + "status = 1 AND target_type = ?", "channel", + ).Find(&rules).Error; err != nil { + return AlertScanResult{}, err + } + res := AlertScanResult{Rules: len(rules)} + for i := range rules { + if s.evaluate(ctx, &rules[i], true) { + res.Triggered++ + } + } + return res, nil +} + +// evaluate 单规则评估;返回是否触发。skipMissing=true 时通道不存在/停用则跳过(cron 路径), +// 事件路径(false)仍评估链路断告警(断连后通道可能被停用但事件有效)。 +func (s *ChannelAlertService) evaluate(ctx context.Context, rule *entity.SystemAlertRule, cronPath bool) bool { + var ch entity.ChannelChannel + err := s.db.WithContext(ctx).Where("id = ?", rule.TargetID).Take(&ch).Error + if err != nil { + return false + } + if cronPath && ch.Status != 1 { + return false // 停用通道不告(cron 路径) + } + + var hit bool + var cur float64 + switch rule.Metric { + case AlertMetricLinkDown: + st := s.linkStatus(ch.ID) + // 应有链路而全断:启用中 cmpp 通道(未建链或池健康数 0)。 + if ch.Protocol == "cmpp" && ch.Status == 1 { + if st == nil || !st.Running || st.Healthy == 0 { + hit, cur = true, 0 + } + } + case AlertMetricFailRate: + submit, fail, _, _, _ := s.mon.Stats(ch.ID) + if submit > 0 { + cur = float64(fail) / float64(submit) + hit = cur > rule.Threshold + } + default: + return false // 未知指标静默跳过(规则录入侧约束) + } + if !hit { + return false + } + // 冷却期内不重复通知。 + now := time.Now() + if rule.LastAlertAt != nil && now.Sub(*rule.LastAlertAt) < time.Duration(rule.CooldownMin)*time.Minute { + return false + } + n := s.newNotifier(rule.NotifyType, rule.NotifyTo) + title := "【go-sms 通道告警】" + content := s.alertContent(&ch, rule, cur) + if err := n.Send(ctx, title, content); err != nil { + return false // 通知失败不写 LastAlertAt,下轮重试 + } + _ = s.db.WithContext(ctx).Model(&entity.SystemAlertRule{}). + Where("id = ?", rule.ID).Update("last_alert_at", now).Error + // 告警留痕进通道日志(逐条)。 + if s.onLogged != nil { + s.onLogged(ch.ID, LogKindAlert, 1, "", content, 0) + } + return true +} + +// SetLogHook 注入告警留痕回调(Service 装配时指向 ChannelLogger,避免依赖环)。 +func (s *ChannelAlertService) SetLogHook(fn func(channelID int64, kind string, level int8, msgID, detail string, latencyMs int)) { + s.onLogged = fn +} + +// alertContent 组装通知文案。 +func (s *ChannelAlertService) alertContent(ch *entity.ChannelChannel, rule *entity.SystemAlertRule, cur float64) string { + switch rule.Metric { + case AlertMetricLinkDown: + st := s.linkStatus(ch.ID) + running, healthy := false, 0 + if st != nil { + running, healthy = st.Running, st.Healthy + } + return fmt.Sprintf("通道 %s(id=%d,%s)链路异常:running=%v healthy=%d,请检查网关/网络。", + ch.Name, ch.ID, ch.Protocol, running, healthy) + case AlertMetricFailRate: + return fmt.Sprintf("通道 %s(id=%d)60s 窗口失败率 %.1f%% 超阈值 %.1f%%,请关注上游状态。", + ch.Name, ch.ID, cur*100, rule.Threshold*100) + } + return "未知指标" +} + +// linkStatus 链路状态读取(links 函数可为 nil→未建链)。 +func (s *ChannelAlertService) linkStatus(id int64) *LinkStatus { + if s.links == nil { + return nil + } + return s.links(id) +} diff --git a/internal/service/channel/alert_test.go b/internal/service/channel/alert_test.go new file mode 100644 index 00000000..45026b53 --- /dev/null +++ b/internal/service/channel/alert_test.go @@ -0,0 +1,174 @@ +// alert_test.go Day 40(A-3.12):通道告警测试——link_down/fail_rate 触发、冷却去重、停用跳过。 +package channel + +import ( + "context" + "sync" + "testing" + + "go-sms/internal/model/entity" + "go-sms/internal/pkg/notify" +) + +// fakeNotifier 收集通知(实现 notify.Notifier,测试注入)。 +type fakeNotifier struct { + mu sync.Mutex + sends []string + failAll bool +} + +func (f *fakeNotifier) Send(_ context.Context, title, content string) error { + f.mu.Lock() + defer f.mu.Unlock() + if f.failAll { + return errFakeSend + } + f.sends = append(f.sends, title+"/"+content) + return nil +} + +func (f *fakeNotifier) count() int { + f.mu.Lock() + defer f.mu.Unlock() + return len(f.sends) +} + +var errFakeSend = &sendErr{} + +type sendErr struct{} + +func (*sendErr) Error() string { return "fake send failed" } + +// fakeFactory 构造注入 NewChannelAlertService 的 notifier 工厂。 +func fakeFactory(fake *fakeNotifier) func(string, string) notify.Notifier { + return func(_, _ string) notify.Notifier { return fake } +} + +// TestChannelAlert_LinkDownAndCooldown 验收:启用中 cmpp 通道未建链 → link_down 触发一次; +// 冷却期内重复扫描/事件路径均不重复通知。 +func TestChannelAlert_LinkDownAndCooldown(t *testing.T) { + s := newSvc35(t) + ctx := context.Background() + ch, err := s.Create(ctx, &CreateReq{ + Name: "down", Code: "al-down", Protocol: "cmpp", + Host: "127.0.0.1", Port: 1, Username: "u", Password: "pw"}) + if err != nil { + t.Fatal(err) + } + rule := &entity.SystemAlertRule{ + TargetType: "channel", TargetID: ch.ID, Metric: AlertMetricLinkDown, + Op: "lt", Threshold: 1, NotifyType: "wechat", NotifyTo: "http://fake", + CooldownMin: 30, Status: 1, + } + if err := s.db.Create(rule).Error; err != nil { + t.Fatal(err) + } + fake := &fakeNotifier{} + svc := NewChannelAlertService(s.db, s.mon, s.links.Status, fakeFactory(fake)) + + res, err := svc.ScanOnce(ctx) + if err != nil { + t.Fatal(err) + } + if res.Rules != 1 || res.Triggered != 1 { + t.Fatalf("首扫: %+v 期望 rules=1 triggered=1", res) + } + if fake.count() != 1 { + t.Fatalf("通知数=%d 期望 1", fake.count()) + } + // 冷却:LastAlertAt 刚写 → CooldownMin 内不再通知(cron + 事件路径)。 + res2, _ := svc.ScanOnce(ctx) + if res2.Triggered != 0 || fake.count() != 1 { + t.Fatalf("冷却失效: %+v notified=%d", res2, fake.count()) + } + svc.EvaluateChannel(ctx, ch.ID) + if fake.count() != 1 { + t.Fatalf("事件路径冷却失效: notified=%d", fake.count()) + } +} + +// TestChannelAlert_NotifyRetry 通知失败不写 LastAlertAt(下轮重试)。 +func TestChannelAlert_NotifyRetry(t *testing.T) { + s := newSvc35(t) + ctx := context.Background() + ch, _ := s.Create(ctx, &CreateReq{ + Name: "retry", Code: "al-retry", Protocol: "cmpp", + Host: "127.0.0.1", Port: 1, Username: "u", Password: "pw"}) + if err := s.db.Create(&entity.SystemAlertRule{ + TargetType: "channel", TargetID: ch.ID, Metric: AlertMetricLinkDown, + NotifyType: "wechat", NotifyTo: "http://fake", CooldownMin: 30, Status: 1, + }).Error; err != nil { + t.Fatal(err) + } + fake := &fakeNotifier{failAll: true} + svc := NewChannelAlertService(s.db, s.mon, s.links.Status, fakeFactory(fake)) + if res, _ := svc.ScanOnce(ctx); res.Triggered != 0 { + t.Fatalf("失败通知不应计入触发: %+v", res) + } + var rule entity.SystemAlertRule + s.db.First(&rule) + if rule.LastAlertAt != nil { + t.Fatal("通知失败不应写 LastAlertAt") + } + // 恢复通知后重试成功。 + fake.mu.Lock() + fake.failAll = false + fake.mu.Unlock() + if res, _ := svc.ScanOnce(ctx); res.Triggered != 1 { + t.Fatalf("重试未触发: %+v", res) + } +} + +// TestChannelAlert_FailRate 验收:60s 窗口失败率超阈值触发。 +func TestChannelAlert_FailRate(t *testing.T) { + s := newSvc35(t) + ctx := context.Background() + ch, err := s.Create(ctx, &CreateReq{Name: "fr", Code: "al-fr", Protocol: "http", Host: "http://up"}) + if err != nil { + t.Fatal(err) + } + // 2 成 1 败(33%)> 阈值 30%。 + s.mon.ReportSubmit(ch.ID, true, 5) + s.mon.ReportSubmit(ch.ID, true, 5) + s.mon.ReportSubmit(ch.ID, false, 0) + if err := s.db.Create(&entity.SystemAlertRule{ + TargetType: "channel", TargetID: ch.ID, Metric: AlertMetricFailRate, + Op: "gt", Threshold: 0.3, NotifyType: "wechat", NotifyTo: "http://fake", + CooldownMin: 30, Status: 1, + }).Error; err != nil { + t.Fatal(err) + } + fake := &fakeNotifier{} + svc := NewChannelAlertService(s.db, s.mon, s.links.Status, fakeFactory(fake)) + res, err := svc.ScanOnce(ctx) + if err != nil { + t.Fatal(err) + } + if res.Triggered != 1 { + t.Fatalf("fail_rate 未触发: %+v", res) + } +} + +// TestChannelAlert_DisabledChannelSkipped 停用通道 cron 路径跳过。 +func TestChannelAlert_DisabledChannelSkipped(t *testing.T) { + s := newSvc35(t) + ctx := context.Background() + ch, _ := s.Create(ctx, &CreateReq{ + Name: "off", Code: "al-off", Protocol: "cmpp", + Host: "127.0.0.1", Port: 1, Username: "u", Password: "pw"}) + if err := s.SetStatus(ctx, ch.ID, 0); err != nil { + t.Fatal(err) + } + if err := s.db.Create(&entity.SystemAlertRule{ + TargetType: "channel", TargetID: ch.ID, Metric: AlertMetricLinkDown, + NotifyType: "wechat", NotifyTo: "http://fake", CooldownMin: 30, Status: 1, + }).Error; err != nil { + t.Fatal(err) + } + fake := &fakeNotifier{} + svc := NewChannelAlertService(s.db, s.mon, s.links.Status, fakeFactory(fake)) + if res, _ := svc.ScanOnce(ctx); res.Triggered != 0 { + t.Fatalf("停用通道不应告: %+v", res) + } +} + diff --git a/internal/service/channel/group.go b/internal/service/channel/group.go new file mode 100644 index 00000000..920e077d --- /dev/null +++ b/internal/service/channel/group.go @@ -0,0 +1,164 @@ +// group.go Day 36:通道组 CRUD 与成员管理。 +package channel + +import ( + "context" + "fmt" + + "go-sms/internal/model/entity" + errs "go-sms/internal/pkg/errors" +) + +// CreateGroup 创建通道组。 +func (s *Service) CreateGroup(ctx context.Context, name string) (*entity.ChannelGroup, error) { + g := &entity.ChannelGroup{Name: name, Status: 1} + if err := s.db.WithContext(ctx).Create(g).Error; err != nil { + return nil, err + } + return g, nil +} + +// GroupDetail 组详情(含成员+通道摘要)。 +type GroupDetail struct { + entity.ChannelGroup + Items []GroupItemView `json:"items"` +} + +// GroupItemView 成员视图。 +type GroupItemView struct { + entity.ChannelGroupItem + ChannelName string `json:"channel_name"` + ChannelCode string `json:"channel_code"` + ChannelStatus int8 `json:"channel_status"` +} + +// GetGroup 组详情(成员按 step,priority 排序)。 +func (s *Service) GetGroup(ctx context.Context, id int64) (*GroupDetail, error) { + var g entity.ChannelGroup + if err := s.db.WithContext(ctx).Where("id = ?", id).Take(&g).Error; err != nil { + return nil, errs.NotFound.WithMsg("通道组不存在") + } + var items []entity.ChannelGroupItem + if err := s.db.WithContext(ctx).Where("group_id = ?", id). + Order("step ASC, priority DESC").Find(&items).Error; err != nil { + return nil, err + } + d := &GroupDetail{ChannelGroup: g, Items: make([]GroupItemView, 0, len(items))} + for _, it := range items { + v := GroupItemView{ChannelGroupItem: it} + var ch entity.ChannelChannel + if err := s.db.WithContext(ctx).Select("id, name, code, status"). + Where("id = ?", it.ChannelID).Take(&ch).Error; err == nil { + v.ChannelName, v.ChannelCode, v.ChannelStatus = ch.Name, ch.Code, ch.Status + } + d.Items = append(d.Items, v) + } + return d, nil +} + +// ListGroups 组列表。 +func (s *Service) ListGroups(ctx context.Context) ([]entity.ChannelGroup, error) { + var out []entity.ChannelGroup + err := s.db.WithContext(ctx).Order("id DESC").Find(&out).Error + return out, err +} + +// UpdateGroup 更新组(name/remark/status)。 +func (s *Service) UpdateGroup(ctx context.Context, id int64, fields map[string]any) error { + for k := range fields { + if k != "name" && k != "remark" && k != "status" { + return errs.InvalidParam.WithMsg(fmt.Sprintf("不允许更新字段 %q", k)) + } + } + res := s.db.WithContext(ctx).Model(&entity.ChannelGroup{}).Where("id = ?", id).Updates(fields) + if res.Error != nil { + return res.Error + } + if res.RowsAffected == 0 { + return errs.NotFound.WithMsg("通道组不存在") + } + return nil +} + +// DeleteGroup 删除组(须先清空成员)。 +func (s *Service) DeleteGroup(ctx context.Context, id int64) error { + var n int64 + s.db.WithContext(ctx).Model(&entity.ChannelGroupItem{}).Where("group_id = ?", id).Count(&n) + if n > 0 { + return errs.InvalidParam.WithMsg(fmt.Sprintf("组内仍有 %d 个成员,须先移除", n)) + } + res := s.db.WithContext(ctx).Delete(&entity.ChannelGroup{}, id) + if res.Error != nil { + return res.Error + } + if res.RowsAffected == 0 { + return errs.NotFound.WithMsg("通道组不存在") + } + return nil +} + +// AddItemReq 添加成员请求。 +type AddItemReq struct { + ChannelID int64 `json:"channel_id" binding:"required"` + Step int8 `json:"step"` // 1 过滤 2 优先 3 权重 4 兜底 + Priority int `json:"priority"` + Weight int `json:"weight"` + Region string `json:"region"` + Carrier string `json:"carrier"` + Keyword string `json:"keyword"` +} + +// AddItem 添加组成员(校验:组/通道存在;step 2-4;step3 权重>0;重复成员拒)。 +func (s *Service) AddItem(ctx context.Context, groupID int64, req *AddItemReq) (*entity.ChannelGroupItem, error) { + var g entity.ChannelGroup + if err := s.db.WithContext(ctx).Where("id = ?", groupID).Take(&g).Error; err != nil { + return nil, errs.NotFound.WithMsg("通道组不存在") + } + if _, err := s.Get(ctx, req.ChannelID); err != nil { + return nil, errs.NotFound.WithMsg("通道不存在") + } + if req.Step < 2 || req.Step > 4 { + return nil, errs.InvalidParam.WithMsg("step 须为 2 优先/3 权重/4 兜底") + } + if req.Step == 3 && req.Weight <= 0 { + return nil, errs.InvalidParam.WithMsg("权重分发成员 weight 必须 >0") + } + if req.Step == 3 && req.Weight > 100 { + return nil, errs.InvalidParam.WithMsg("weight 上限 100") + } + var n int64 + s.db.WithContext(ctx).Model(&entity.ChannelGroupItem{}). + Where("group_id = ? AND channel_id = ?", groupID, req.ChannelID).Count(&n) + if n > 0 { + return nil, errs.InvalidParam.WithMsg("该通道已在组内(同组同通道仅一个角色)") + } + it := &entity.ChannelGroupItem{ + GroupID: groupID, ChannelID: req.ChannelID, Step: req.Step, + Priority: req.Priority, Weight: req.Weight, + Region: req.Region, Carrier: req.Carrier, Keyword: req.Keyword, + } + if err := s.db.WithContext(ctx).Create(it).Error; err != nil { + return nil, err + } + return it, nil +} + +// RemoveItem 移除成员。 +func (s *Service) RemoveItem(ctx context.Context, groupID, itemID int64) error { + res := s.db.WithContext(ctx).Where("id = ? AND group_id = ?", itemID, groupID). + Delete(&entity.ChannelGroupItem{}) + if res.Error != nil { + return res.Error + } + if res.RowsAffected == 0 { + return errs.NotFound.WithMsg("成员不存在") + } + return nil +} + +// channelInUse 通道被组引用数(Day 35 删除守卫扩展)。 +func (s *Service) channelInUse(ctx context.Context, channelID int64) int64 { + var n int64 + s.db.WithContext(ctx).Model(&entity.ChannelGroupItem{}).Where("channel_id = ?", channelID).Count(&n) + return n +} diff --git a/internal/service/channel/group_test.go b/internal/service/channel/group_test.go new file mode 100644 index 00000000..9ed48522 --- /dev/null +++ b/internal/service/channel/group_test.go @@ -0,0 +1,110 @@ +// group_test.go Day 36:通道组 service 层(校验/守卫/详情)。 +package channel + +import ( + "context" + "testing" + + "go-sms/internal/model/entity" +) + +// TestGroupCRUD 组 CRUD/成员校验/删除守卫。 +func TestGroupCRUD(t *testing.T) { + s := newSvc35g(t) + ctx := context.Background() + chA := mustCreateCh(t, s, "ga") + chB := mustCreateCh(t, s, "gb") + + g, err := s.CreateGroup(ctx, "组1") + if err != nil { + t.Fatal(err) + } + // 成员校验 + if _, err := s.AddItem(ctx, g.ID, &AddItemReq{ChannelID: chA.ID, Step: 1}); err == nil { + t.Fatal("step=1 应拒") + } + if _, err := s.AddItem(ctx, g.ID, &AddItemReq{ChannelID: chA.ID, Step: 3, Weight: 0}); err == nil { + t.Fatal("weight=0 应拒") + } + if _, err := s.AddItem(ctx, g.ID, &AddItemReq{ChannelID: chA.ID, Step: 3, Weight: 101}); err == nil { + t.Fatal("weight>100 应拒") + } + if _, err := s.AddItem(ctx, 99, &AddItemReq{ChannelID: chA.ID, Step: 3, Weight: 1}); err == nil { + t.Fatal("组不存在应 404") + } + if _, err := s.AddItem(ctx, g.ID, &AddItemReq{ChannelID: 99, Step: 3, Weight: 1}); err == nil { + t.Fatal("通道不存在应 404") + } + itA, err := s.AddItem(ctx, g.ID, &AddItemReq{ChannelID: chA.ID, Step: 3, Weight: 7}) + if err != nil { + t.Fatal(err) + } + if _, err := s.AddItem(ctx, g.ID, &AddItemReq{ChannelID: chA.ID, Step: 4}); err == nil { + t.Fatal("重复成员应拒") + } + if _, err := s.AddItem(ctx, g.ID, &AddItemReq{ChannelID: chB.ID, Step: 2, Priority: 5, Keyword: "验证码"}); err != nil { + t.Fatal(err) + } + // 详情(step 排序+通道摘要) + d, err := s.GetGroup(ctx, g.ID) + if err != nil || len(d.Items) != 2 { + t.Fatalf("详情: %+v err=%v", d, err) + } + if d.Items[0].Step != 2 || d.Items[0].ChannelCode != "gb" { + t.Fatalf("排序/摘要: %+v", d.Items) + } + // 列表/更新 + if gs, _ := s.ListGroups(ctx); len(gs) != 1 { + t.Fatalf("列表 = %d", len(gs)) + } + if err := s.UpdateGroup(ctx, g.ID, map[string]any{"name": "组1改"}); err != nil { + t.Fatal(err) + } + if err := s.UpdateGroup(ctx, g.ID, map[string]any{"id": 1}); err == nil { + t.Fatal("id 不可更新") + } + // 删除守卫:组内有成员拒删;通道被引用拒删 + if err := s.DeleteGroup(ctx, g.ID); err == nil { + t.Fatal("非空组应拒删") + } + _ = s.SetStatus(ctx, chA.ID, 0) + if err := s.Delete(ctx, chA.ID); err == nil { + t.Fatal("被引用通道应拒删") + } + // 清空成员 → 组可删 → 通道可删 + if err := s.RemoveItem(ctx, g.ID, itA.ID); err != nil { + t.Fatal(err) + } + if err := s.RemoveItem(ctx, g.ID, 999); err == nil { + t.Fatal("不存在成员应 404") + } + // chB 的 step2 成员仍在 → 再移除 + dg, _ := s.GetGroup(ctx, g.ID) + for _, it := range dg.Items { + if err := s.RemoveItem(ctx, g.ID, it.ID); err != nil { + t.Fatal(err) + } + } + if err := s.DeleteGroup(ctx, g.ID); err != nil { + t.Fatal(err) + } + if err := s.Delete(ctx, chA.ID); err != nil { + t.Fatal(err) + } + if _, err := s.GetGroup(ctx, 99); err == nil { + t.Fatal("组 404") + } + if err := s.DeleteGroup(ctx, 99); err == nil { + t.Fatal("组删除 404") + } +} + +// newSvc35g 建库(含组表)。 +func newSvc35g(t *testing.T) *Service { + t.Helper() + s := newSvc35(t) + if err := s.db.AutoMigrate(&entity.ChannelGroup{}, &entity.ChannelGroupItem{}); err != nil { + t.Fatal(err) + } + return s +} diff --git a/internal/service/channel/link.go b/internal/service/channel/link.go new file mode 100644 index 00000000..35a477e0 --- /dev/null +++ b/internal/service/channel/link.go @@ -0,0 +1,509 @@ +// link.go Day 31+:通道常驻链路管理(Day 32 cmpp.Pool 的业务挂载)。 +// 每通道一池常驻长连接(登录+心跳+断线指数退避重连);提交走池化连接; +// Deliver 回执结构化日志+环形缓冲(入库留待阶段 5 Day 51 message_report)。 +// 为阶段 4 发送主路径(路由引擎经链路提交)与阶段 5 回执落地奠基。 +package channel + +import ( + "context" + "errors" + "fmt" + "sync" + "sync/atomic" + "time" + + "go-sms/internal/model/entity" + "go-sms/internal/pkg/logger" + "go-sms/internal/protocol/cmpp" + + "go.uber.org/zap" +) + +// deliverLogSample 回执日志采样计数器(P1:1/100 采样,DELIVRD 之外全量)。 +var deliverLogSample atomic.Uint64 + +// 链路域错误。 +var ( + ErrLinkUnavailable = errors.New("通道链路不可用") + ErrChannelDisabled = errors.New("通道已停用,无法建立链路") + errCMPPOnly = errors.New("常驻链路当前仅支持 cmpp 通道(sgip/smpp 后续任务)") + errCMPP30 = errors.New("CMPP 3.0 协议栈未实现(当前仅支持 2.0)") +) + +// Receipt 一条网关回执/上行(内存视图)。 +type Receipt struct { + ChannelID int64 `json:"channel_id"` + MsgID string `json:"msg_id"` + IsReport bool `json:"is_report"` // true=状态报告 false=上行短信 + Stat string `json:"stat,omitempty"` + SubmitTime string `json:"submit_time,omitempty"` + DoneTime string `json:"done_time,omitempty"` + Dest string `json:"dest,omitempty"` + Src string `json:"src,omitempty"` // 上行来源号码 + Content string `json:"content,omitempty"` + At string `json:"at"` +} + +// LinkStatus 链路状态视图。 +type LinkStatus struct { + ChannelID int64 `json:"channel_id"` + Running bool `json:"running"` + Total int `json:"total"` // 池内连接总数 + Healthy int `json:"healthy"` // 当前已连接数 + StartedAt string `json:"started_at,omitempty"` +} + +// link 一条通道的常驻链路(池 + 根 context 取消)。 +type link struct { + pool *cmpp.Pool + cancel context.CancelFunc + startedAt time.Time +} + +// linkManager 链路管理器(Service 内嵌单例)。 +type linkManager struct { + svc *Service + mu sync.RWMutex + links map[int64]*link + rmu sync.Mutex + reports []Receipt // 环形缓冲(全通道最近 receiptCap 条) + uplink UplinkSink // Day 49:上行出口(码号分配+落库+sms-up;nil=仅日志) + report ReportSink // Day 56:回执出口(sms-report 投递;nil=仅日志/环形) +} + +const receiptCap = 100 + +// linkReady 链路就绪等待上限(首次建链/断线重连窗口)。 +const linkReady = 5 * time.Second + +func newLinkManager(svc *Service) *linkManager { + return &linkManager{svc: svc, links: map[int64]*link{}} +} + +// SetUplinkSink 注入上行处理器(Day 49;装配层调用,须在 StartLink 前)。 +func (m *linkManager) SetUplinkSink(u UplinkSink) { + m.mu.Lock() + m.uplink = u + m.mu.Unlock() +} + +// ReportSink 回执出口(Day 56):状态报告经 Kafka sms-report 异步归一化 +// (消费者按 msg_id+mobile 段级配对→聚合判 detail 终态)。 +type ReportSink interface { + IngestReport(ctx context.Context, channelID int64, msgID, stat, dest, doneTime string) +} + +// SetReportSink 注入回执出口(Day 56;装配层调用;nil=维持 Day55 前行为)。 +func (m *linkManager) SetReportSink(r ReportSink) { + m.mu.Lock() + m.report = r + m.mu.Unlock() +} + +// BatchAck 一次批量提交的「包×片」级回执(Day 56):CMPP 合包下一个 +// Submit 包共享一个 msg_id;长短信每片独立成包独立 msg_id——段级配对 +// 按 (msg_id, mobile) 精确定位,PkNumber/PkTotal 描述该片在整信中的位置。 +type BatchAck struct { + MsgID string + Mobiles []string // 该包内号码(与提交顺序一致) + PkNumber int // 片序(1 起) + PkTotal int // 该内容总片数(单条=1,长短信 1~9) +} + +// observe 便捷埋点:通道日志 + 监控统计(失败时)。 +func (m *linkManager) observe(channelID int64, kind string, level int8, msgID, detail string, latencyMs int) { + m.svc.logs.Log(channelID, kind, level, msgID, detail, latencyMs) +} + +// onDrop 断连事件:日志 + 告警即时评估(异步,不阻塞重连路径)。 +func (m *linkManager) onDrop(channelID int64, idx int, err error) { + detail := fmt.Sprintf("conn#%d: %v", idx, err) + m.observe(channelID, LogKindDisconnect, 2, "", detail, 0) + go m.svc.alerts.EvaluateChannel(context.Background(), channelID) +} + +// Bootstrap 启动时为全部「启用中的 cmpp 通道」建链(异步;单通道失败仅告警)。 +func (m *linkManager) Bootstrap(ctx context.Context) { + list, _, err := m.svc.List(ctx, &ListQuery{Page: 1, PageSize: 100, Protocol: "cmpp", Status: 1}) + if err != nil { + logger.L().Warn("link_bootstrap_list_failed", zap.Error(err)) + return + } + for _, ch := range list { + if _, err := m.StartLink(ctx, ch.ID); err != nil { + logger.L().Warn("link_bootstrap_channel_failed", zap.Int64("channel_id", ch.ID), zap.Error(err)) + } else { + logger.L().Info("link_bootstrap_channel_started", zap.Int64("channel_id", ch.ID), zap.String("name", ch.Name)) + } + } +} + +// poolConfig 通道实体 → CMPP 客户端配置(sp_id 优先,回退 username 兼容)。 +func poolConfig(ch *entity.ChannelChannel) cmpp.Config { + sourceAddr := ch.SpID + if sourceAddr == "" { + sourceAddr = ch.Username + } + return cmpp.Config{ + Addr: fmt.Sprintf("%s:%d", ch.Host, ch.Port), + SourceAddr: sourceAddr, + Secret: ch.Password, + HeartbeatInterval: time.Duration(ch.HeartbeatInterval) * time.Second, + ReconnectMax: time.Duration(ch.ReconnectMax) * time.Second, + LoginTimeout: 10 * time.Second, + } +} + +// Shutdown 全部拆除(进程退出)。 +func (m *linkManager) Shutdown() { + m.mu.Lock() + ids := make([]int64, 0, len(m.links)) + for id := range m.links { + ids = append(ids, id) + } + m.mu.Unlock() + for _, id := range ids { + m.StopLink(id) + } +} + +// StartLink 为通道建立常驻链路(已存在则幂等返回)。 +func (m *linkManager) StartLink(ctx context.Context, id int64) (*LinkStatus, error) { + m.mu.Lock() + if _, ok := m.links[id]; ok { + m.mu.Unlock() + return m.Status(id), nil + } + m.mu.Unlock() + + ch, err := m.svc.Get(context.Background(), id) + if err != nil { + return nil, err + } + if ch.Protocol != "cmpp" { + return nil, errCMPPOnly + } + if ch.Status != 1 { + return nil, ErrChannelDisabled + } + if ch.ProtocolVersion == 30 { + return nil, errCMPP30 + } + + size := ch.ConnCount + if size < 1 { + size = 1 + } + pool := cmpp.NewPool(poolConfig(ch), size) + pool.OnDeliver(func(d *cmpp.Deliver) { m.handleDeliver(id, d) }) + pool.OnDisconnected(func(i int, err error) { m.onDrop(id, i, err) }) + runCtx, cancel := context.WithCancel(context.Background()) + pool.Start(runCtx) + + m.mu.Lock() + // 并发双检:后到者拆除重复池。 + if _, ok := m.links[id]; ok { + m.mu.Unlock() + cancel() + pool.Stop() + return m.Status(id), nil + } + m.links[id] = &link{pool: pool, cancel: cancel, startedAt: time.Now()} + m.mu.Unlock() + m.observe(id, LogKindConnect, 0, "", fmt.Sprintf("pool started(size=%d host=%s:%d)", size, ch.Host, ch.Port), 0) + logger.L().Info("link_started", zap.Int64("channel_id", id), zap.String("name", ch.Name), zap.Int("size", size)) + return m.Status(id), nil +} + +// StopLink 拆除链路(不存在则幂等)。 +func (m *linkManager) StopLink(id int64) { + m.mu.Lock() + l, ok := m.links[id] + if ok { + delete(m.links, id) + } + m.mu.Unlock() + if ok { + l.cancel() + l.pool.Stop() + m.observe(id, LogKindStop, 0, "", "link stopped", 0) + logger.L().Info("link_stopped", zap.Int64("channel_id", id)) + } +} + +// RestartLink 参数变更后重建。 +func (m *linkManager) RestartLink(ctx context.Context, id int64) (*LinkStatus, error) { + m.StopLink(id) + return m.StartLink(ctx, id) +} + +// Status 查询链路状态(未建链返回 Running=false)。 +func (m *linkManager) Status(id int64) *LinkStatus { + m.mu.RLock() + l, ok := m.links[id] + m.mu.RUnlock() + if !ok { + return &LinkStatus{ChannelID: id} + } + return &LinkStatus{ + ChannelID: id, Running: true, + Total: l.pool.Size(), Healthy: l.pool.Healthy(), + StartedAt: l.startedAt.Format("2006-01-02 15:04:05"), + } +} + +// SubmitViaLink 经常驻链路提交(未建链自动建立);返回上游 MsgID。 +// SubmitViaLink 单号提交;返回各段 msg_id(顺序=PkNumber 1..N,单条=1 个; +// Day 56 段级回执配对:每片独立 msg_id,提交侧据此逐段登记 message_report_seg)。 +func (m *linkManager) SubmitViaLink(ctx context.Context, id int64, mobile, content string) ([]string, error) { + m.mu.RLock() + l, ok := m.links[id] + m.mu.RUnlock() + if !ok { + if _, err := m.StartLink(ctx, id); err != nil { + return nil, err + } + m.mu.RLock() + l, ok = m.links[id] + m.mu.RUnlock() + if !ok { + return nil, ErrLinkUnavailable + } + } + // 链路就绪窗口:池刚启动/断线重连期,有界等待至少一条健康连接(超时报不可用)。 + ready := time.Now().Add(linkReady) + for l.pool.Healthy() == 0 && time.Now().Before(ready) { + time.Sleep(20 * time.Millisecond) + } + if l.pool.Healthy() == 0 { + return nil, ErrLinkUnavailable + } + ch, err := m.svc.Get(context.Background(), id) + if err != nil { + return nil, err + } + sourceAddr := ch.SpID + if sourceAddr == "" { + sourceAddr = ch.Username + } + srcID := ch.Code + if srcID == "" { + srcID = sourceAddr + } + svcID := ch.ServiceID + if svcID == "" { + svcID = "TEST" + } + // 内容编码+长短信分片(Day 39:ASCII 原样/中文 GBK;超 134B 拆 UDH 片)。 + frags, err := cmpp.SplitContent(content) + if err != nil { + return nil, err + } + if len(frags) > 1 { + logger.L().Info("submit_split_long_sms", + zap.Int64("channel_id", id), zap.Int("frags", len(frags)), zap.Int("bytes", len(content))) + } + msgIDs := make([]string, 0, len(frags)) + var lastOK string + for _, f := range frags { + t0 := time.Now() + resp, err := l.pool.Submit(&cmpp.SubmitReq{ + ServiceID: svcID, MsgFmt: f.MsgFmt, TPUdhi: f.TPUdhi, + PkTotal: f.PkTotal, PkNumber: f.PkNumber, + MsgSrc: sourceAddr, FeeType: "01", SrcID: srcID, + DestTerminalIDs: []string{mobile}, + Content: f.Content, RegisteredDelivery: 1, + }) + lat := int(time.Since(t0).Milliseconds()) + if err != nil { + m.svc.mon.ReportSubmit(id, false, 0) + m.observe(id, LogKindSubmitFail, 2, lastOK, fmt.Sprintf("%v", err), lat) + return msgIDs, err + } + if resp.Result != 0 { + m.svc.mon.ReportSubmit(id, false, 0) + m.observe(id, LogKindSubmitFail, 2, lastOK, fmt.Sprintf("上游拒绝: result=%d", resp.Result), lat) + return msgIDs, fmt.Errorf("上游拒绝: result=%d", resp.Result) + } + m.svc.mon.ReportSubmit(id, true, lat) + m.observe(id, LogKindSubmit, 0, fmt.Sprintf("%d", resp.MsgID), "", lat) + msgIDs = append(msgIDs, fmt.Sprintf("%d", resp.MsgID)) + lastOK = msgIDs[len(msgIDs)-1] + } + return msgIDs, nil +} + +// SubmitBatchViaLink Day47 合包批量提交:同内容多号码合入 CMPP Submit 包 +// (规范单包 ≤100 号码,超量自动切包),一次批量调用替代 N 次单号调用—— +// 提交调用次数 ÷100(合包聚合器出口;错误语义:任一包失败返回聚合错误, +// 调用方可回退逐号保送达)。 +// Day 56:返回包级回执 acks(每包 msg_id+包内号码+总片数)——提交侧据此 +// 逐段登记 message_report_seg,长短信每片独立成包独立 msg_id。 +func (m *linkManager) SubmitBatchViaLink(ctx context.Context, id int64, + mobiles []string, content string) ([]BatchAck, error) { + if len(mobiles) == 0 { + return nil, nil + } + m.mu.RLock() + l, ok := m.links[id] + m.mu.RUnlock() + if !ok { + if _, err := m.StartLink(ctx, id); err != nil { + return nil, err + } + m.mu.RLock() + l, ok = m.links[id] + m.mu.RUnlock() + if !ok { + return nil, ErrLinkUnavailable + } + } + ready := time.Now().Add(linkReady) + for l.pool.Healthy() == 0 && time.Now().Before(ready) { + time.Sleep(20 * time.Millisecond) + } + if l.pool.Healthy() == 0 { + return nil, ErrLinkUnavailable + } + ch, err := m.svc.Get(context.Background(), id) + if err != nil { + return nil, err + } + sourceAddr := ch.SpID + if sourceAddr == "" { + sourceAddr = ch.Username + } + srcID := ch.Code + if srcID == "" { + srcID = sourceAddr + } + svcID := ch.ServiceID + if svcID == "" { + svcID = "TEST" + } + frags, err := cmpp.SplitContent(content) + if err != nil { + return nil, err + } + var acks []BatchAck + var firstErr error + for start := 0; start < len(mobiles); start += cmpp.MaxDestPerSubmit { + end := start + cmpp.MaxDestPerSubmit + if end > len(mobiles) { + end = len(mobiles) + } + dest := mobiles[start:end] + for pn, f := range frags { + t0 := time.Now() + resp, serr := l.pool.Submit(&cmpp.SubmitReq{ + ServiceID: svcID, MsgFmt: f.MsgFmt, TPUdhi: f.TPUdhi, + PkTotal: f.PkTotal, PkNumber: f.PkNumber, + MsgSrc: sourceAddr, FeeType: "01", SrcID: srcID, + DestTerminalIDs: dest, + Content: f.Content, RegisteredDelivery: 1, + }) + lat := int(time.Since(t0).Milliseconds()) + if serr != nil { + m.svc.mon.ReportSubmit(id, false, 0) + m.observe(id, LogKindSubmitFail, 2, "", fmt.Sprintf("batch: %v", serr), lat) + if firstErr == nil { + firstErr = serr + } + continue + } + if resp.Result != 0 { + m.svc.mon.ReportSubmit(id, false, 0) + m.observe(id, LogKindSubmitFail, 2, fmt.Sprintf("%d", resp.MsgID), + fmt.Sprintf("batch 上游拒绝: result=%d", resp.Result), lat) + if firstErr == nil { + firstErr = fmt.Errorf("上游拒绝: result=%d", resp.Result) + } + continue + } + m.svc.mon.ReportSubmit(id, true, lat) + m.observe(id, LogKindSubmit, 0, fmt.Sprintf("%d×%d", resp.MsgID, len(dest)), "", lat) + acks = append(acks, BatchAck{ + MsgID: fmt.Sprintf("%d", resp.MsgID), + Mobiles: dest, + PkNumber: pn + 1, + PkTotal: len(frags), + }) + } + } + return acks, firstErr +} +func (m *linkManager) Receipts(channelID int64, n int) []Receipt { + m.rmu.Lock() + defer m.rmu.Unlock() + var out []Receipt + for i := len(m.reports) - 1; i >= 0 && len(out) < n; i-- { + if channelID == 0 || m.reports[i].ChannelID == channelID { + out = append(out, m.reports[i]) + } + } + return out +} + +// decodeMOContent 上行短消息内容按 Msg_Fmt 解码为 UTF-8;失败降级原样并告警(不丢消息)。 +func decodeMOContent(content []byte, msgFmt uint8) string { + if text, err := cmpp.DecodeContent(content, msgFmt); err == nil { + return text + } + logger.L().Warn("deliver_mo_decode_fallback", + zap.Uint8("msg_fmt", msgFmt), zap.Int("bytes", len(content))) + return string(content) +} + +// handleDeliver 回执/上行处理:结构化日志 + 环形缓冲 + 监控/通道日志(Day 40)。 +func (m *linkManager) handleDeliver(channelID int64, d *cmpp.Deliver) { + r := Receipt{ChannelID: channelID, IsReport: d.IsReport, At: time.Now().Format("2006-01-02 15:04:05")} + if d.IsReport && d.Report != nil { + r.MsgID = fmt.Sprintf("%d", d.Report.MsgID) + r.Stat, r.SubmitTime, r.DoneTime, r.Dest = d.Report.Stat, d.Report.SubmitTime, d.Report.DoneTime, d.Report.DestTerminalID + ok := d.Report.Stat == "DELIVRD" + m.svc.mon.ReportDeliver(channelID, ok) + if ok { + m.observe(channelID, LogKindDeliver, 0, r.MsgID, r.Stat, 0) + } else { + m.observe(channelID, LogKindDeliverFail, 1, r.MsgID, r.Stat, 0) + } + // P1 压测优化(09-27):逐条 info 在回执洪峰下 5000 行/分钟打爆 HDD + // (与 DB 写同盘竞争);降为 1/100 采样观测,非 DELIVRD 全量保留(异常可观测)。 + if !ok || deliverLogSample.Add(1)%100 == 1 { + logger.L().Info("deliver_report", + zap.Int64("channel_id", channelID), zap.String("msg_id", r.MsgID), + zap.String("stat", r.Stat), zap.String("done_time", r.DoneTime), zap.String("dest", r.Dest)) + } + // Day 56:回执进回执域(sms-report→消费者归一化+段级配对→detail 终态)。 + // 读循环严禁阻塞(Kafka 投递与读解耦),goroutine 派发;失败在 Ingest 内记日志。 + m.mu.RLock() + rp := m.report + m.mu.RUnlock() + if rp != nil { + go rp.IngestReport(context.Background(), channelID, r.MsgID, r.Stat, r.Dest, r.DoneTime) + } + } else { + // 上行内容按 Msg_Fmt 解码为 UTF-8(Day52 乱码复盘补齐): + // 此前 string(d.Content) 原样直灌,真实上游 GBK(15)/UCS2(8) 中文上行必乱码 + // 入库(channel_log/message_uplink→sms-up);解码失败降级原样+Warn 不丢消息。 + r.Src = d.SrcTerminal + r.Content = decodeMOContent(d.Content, d.MsgFmt) + m.observe(channelID, LogKindDeliverMO, 0, "", fmt.Sprintf("src=%s %s", r.Src, r.Content), 0) + logger.L().Info("deliver_mo", + zap.Int64("channel_id", channelID), zap.String("src", r.Src), zap.String("content", r.Content)) + // Day 49:上行进上行域(码号分配→message_uplink→sms-up)。读循环严禁 + // 阻塞(DB/Kafka 延迟与通道读解耦),goroutine 派发;失败在 Ingest 内部记日志。 + m.mu.RLock() + u := m.uplink + m.mu.RUnlock() + if u != nil { + go u.Ingest(context.Background(), channelID, d.DestID, d.SrcTerminal, r.Content) + } + } + m.rmu.Lock() + m.reports = append(m.reports, r) + if len(m.reports) > receiptCap { + m.reports = m.reports[len(m.reports)-receiptCap:] + } + m.rmu.Unlock() +} diff --git a/internal/service/channel/link_day40_test.go b/internal/service/channel/link_day40_test.go new file mode 100644 index 00000000..78d139db --- /dev/null +++ b/internal/service/channel/link_day40_test.go @@ -0,0 +1,161 @@ +// link_day40_test.go Day 40(A-3.5):真网断线重连演练——网关进程消失→心跳断链→ +// 同端口复活→指数退避重连→提交恢复。断言全程远小于 30s 重连上限,并留痕 channel_log。 +package channel + +import ( + "context" + "net" + "sync" + "testing" + "time" + + "go-sms/internal/model/entity" +) + +// waitLinkFor 限期等待健康连接数(演练用:期限可调)。 +func waitLinkFor(t *testing.T, s *Service, id int64, want int, d time.Duration) bool { + t.Helper() + deadline := time.Now().Add(d) + for time.Now().Before(deadline) { + if st := s.LinkStatus(id); st.Running && st.Healthy >= want { + return true + } + time.Sleep(20 * time.Millisecond) + } + return false +} + +// killableGW 可杀网关:追踪全部已建立连接,kill() 等价「网关进程消失」 +// (listener 关闭 + 已 accept 连接全部 RST——TCP 语义上 listener 关闭不影响存量连接,须显式掐断)。 +type killableGW struct { + ln net.Listener + mu sync.Mutex + conns map[net.Conn]struct{} +} + +func newKillableGW(t *testing.T) *killableGW { + t.Helper() + ln, err := netListen() + if err != nil { + t.Fatal(err) + } + g := &killableGW{ln: ln, conns: map[net.Conn]struct{}{}} + go g.serve() + return g +} + +func (g *killableGW) serve() { + for { + conn, err := g.ln.Accept() + if err != nil { + return + } + g.mu.Lock() + g.conns[conn] = struct{}{} + g.mu.Unlock() + go func() { + defer func() { + g.mu.Lock() + delete(g.conns, conn) + g.mu.Unlock() + _ = conn.Close() + }() + serveMiniConn(conn) + }() + } +} + +// kill 网关宕机:关 listener 并掐断全部存量连接(进程消失等价)。 +func (g *killableGW) kill() { + _ = g.ln.Close() + g.mu.Lock() + for c := range g.conns { + _ = c.Close() + } + g.mu.Unlock() +} + +// restart 同端口复活网关(TIME_WAIT 竞争重试)。 +func (g *killableGW) restart(t *testing.T) { + t.Helper() + addr := g.ln.Addr().String() + var ln net.Listener + var err error + for i := 0; i < 20; i++ { + ln, err = net.Listen("tcp", addr) + if err == nil { + break + } + time.Sleep(100 * time.Millisecond) + } + if err != nil { + t.Fatalf("网关复活失败: %v", err) + } + g.ln = ln + go g.serve() +} + +// TestLinkReconnectAfterGatewayRestart A-3.5 演练: +// ①建链健康 → ②网关进程消失(listener+存量连接全掐) → ③client 立即感知断链 +// → ④同端口复活 → ⑤退避重连恢复健康(断言 <10s,验收线 30s) → ⑥提交恢复 +// → ⑦channel_log 留痕 disconnect。 +func TestLinkReconnectAfterGatewayRestart(t *testing.T) { + s := newSvc35(t) + t.Cleanup(func() { s.ShutdownLinks() }) + ctx := context.Background() + + gw := newKillableGW(t) + // 借 mustCreateLinkable 的建通道参数(用 gw.ln 地址)。 + ch := mustCreateLinkable(t, s, "d40-rc", gw.ln) + if _, err := s.StartLink(ctx, ch.ID); err != nil { + t.Fatal(err) + } + if !waitLink(t, s, ch.ID, 1) { + t.Fatalf("初始建链失败: %+v", s.LinkStatus(ch.ID)) + } + + // ②③网关宕机 → client 读 EOF 即刻 fail(OnDisconnected 触发,无需等心跳)。 + t0 := time.Now() + gw.kill() + downBy := time.Now().Add(3 * time.Second) + for time.Now().Before(downBy) { + if st := s.LinkStatus(ch.ID); st.Healthy == 0 { + break + } + time.Sleep(20 * time.Millisecond) + } + if st := s.LinkStatus(ch.ID); st.Healthy != 0 { + t.Fatalf("断链未被发现: %+v", st) + } + + // ④⑤同端口复活 → 退避重连(远小于 30s 验收线)。 + gw.restart(t) + if !waitLinkFor(t, s, ch.ID, 1, 10*time.Second) { + t.Fatalf("10s 内未重连: %+v", s.LinkStatus(ch.ID)) + } + reconnectIn := time.Since(t0) + + // ⑥提交链路恢复(TestChannel cmpp 分支经 SubmitViaLink,上行 MsgID=777)。 + res, err := s.TestChannel(ctx, ch.ID, "13800138000", "重连演练") + if err != nil || res.MessageID == "" { + t.Fatalf("重连后提交: res=%+v err=%v", res, err) + } + + // ⑦通道日志留痕 disconnect(A-3.14 联合验收)。 + // 时序:fail() 先置 conn=nil(Healthy=0 可观测)后回调 OnDisconnected——留痕需轮询等待事件落库。 + var disConns int64 + by := time.Now().Add(2 * time.Second) + for time.Now().Before(by) { + s.logs.FlushNow() + s.db.Model(&entity.ChannelLog{}).Where("channel_id = ? AND kind = ?", ch.ID, LogKindDisconnect).Count(&disConns) + if disConns > 0 { + break + } + time.Sleep(50 * time.Millisecond) + } + if disConns == 0 { + t.Fatal("channel_log 缺 disconnect 留痕") + } + t.Logf("A-3.5 演练通过: 断链发现+重连耗时 %v(验收线 30s), 提交恢复 msgID=%s, disconnect 留痕 %d 条", + reconnectIn, res.MessageID, disConns) +} diff --git a/internal/service/channel/link_split_test.go b/internal/service/channel/link_split_test.go new file mode 100644 index 00000000..21a79a77 --- /dev/null +++ b/internal/service/channel/link_split_test.go @@ -0,0 +1,166 @@ +// link_split_test.go Day 39 验收:常驻链路提交中文 → GBK(0x0F);超长 → UDH 分片多笔提交。 +// recordingMini 在迷你网关基础上记录收到的 Submit(PkTotal/PkNumber/TP_udhi/MsgFmt/Content)。 +package channel + +import ( + "context" + "net" + "strings" + "sync" + "testing" + "time" + + "go-sms/internal/protocol/cmpp" + "golang.org/x/text/encoding/simplifiedchinese" +) + +// decodeGBK GBK 字节还原为 UTF-8。 +func decodeGBK(b []byte) (string, error) { + out, err := simplifiedchinese.GBK.NewDecoder().Bytes(b) + return string(out), err +} + +// submitCapture 一笔 Submit 的关键 PDU 字段。 +type submitCapture struct { + PkTotal, PkNumber, TPUdhi, MsgFmt uint8 + Content []byte +} + +// parseSubmitBody 按编码布局提取(纯 CMPP 2.0,与 cmpp.SubmitReq.Marshal 对应)。 +func parseSubmitBody(body []byte) submitCapture { + n := int(body[116]) // Dest_usr 前偏移 116 + p := 116 + 1 + 21*n + msgLen := int(body[p]) // Msg_Length:CMPP 2.0 为 1B + return submitCapture{ + PkTotal: body[8], PkNumber: body[9], + TPUdhi: body[45], MsgFmt: body[46], + Content: body[p+1 : p+1+msgLen], + } +} + +// listenRecordingMini 迷你网关 + Submit 收包记录。 +func listenRecordingMini(t *testing.T) (net.Listener, *[]submitCapture) { + t.Helper() + ln, err := netListen() + if err != nil { + t.Fatal(err) + } + var mu sync.Mutex + caps := &[]submitCapture{} + go func() { + for { + conn, err := ln.Accept() + if err != nil { + return + } + go func() { + defer func() { _ = conn.Close() }() + for { + h, body, err := cmpp.ReadPacket(conn) + if err != nil { + return + } + switch h.CommandID { + case cmpp.CmdConnect: + addr, auth, ts, _ := cmpp.ParseConnect(body) + st := byte(0) + if !cmpp.VerifyAuth(addr, "pw", ts, auth) { + st = 1 + } + _ = cmpp.WritePacket(conn, &cmpp.Header{CommandID: cmpp.CmdConnectResp, SequenceID: h.SequenceID}, + (&cmpp.ConnectResp{Status: st, Secret: "pw", AuthenticatorClient: auth}).Marshal()) + case cmpp.CmdSubmit: + mu.Lock() + *caps = append(*caps, parseSubmitBody(body)) + mu.Unlock() + _ = cmpp.WritePacket(conn, &cmpp.Header{CommandID: cmpp.CmdSubmitResp, SequenceID: h.SequenceID}, + (&cmpp.SubmitResp{MsgID: 777, Result: 0}).Marshal()) + case cmpp.CmdActiveTest: + _ = cmpp.WritePacket(conn, &cmpp.Header{CommandID: cmpp.CmdActiveTestResp, SequenceID: h.SequenceID}, + cmpp.ActiveTestResp(0)) + } + } + }() + } + }() + t.Cleanup(func() { _ = ln.Close() }) + return ln, caps +} + +// waitSubmits 等够 n 笔 Submit 落账(建链+提交异步)。 +func waitSubmits(t *testing.T, caps *[]submitCapture, n int) []submitCapture { + t.Helper() + deadline := time.Now().Add(5 * time.Second) + for time.Now().Before(deadline) { + if len(*caps) >= n { + return *caps + } + time.Sleep(20 * time.Millisecond) + } + t.Fatalf("等待 %d 笔 Submit 超时(实收 %d)", n, len(*caps)) + return nil +} + +// TestSubmitViaLinkChinese 中文提交:Msg_Fmt=0x0F(15) + GBK 内容可还原。 +func TestSubmitViaLinkChinese(t *testing.T) { + s := newSvc35(t) + t.Cleanup(func() { s.ShutdownLinks() }) + ln, caps := listenRecordingMini(t) + ctx := context.Background() + ch := mustCreateLinkable(t, s, "cn", ln) + if _, err := s.StartLink(ctx, ch.ID); err != nil { + t.Fatal(err) + } + if _, err := s.links.SubmitViaLink(ctx, ch.ID, "13800001111", "验证码9527,请勿泄露"); err != nil { + t.Fatal(err) + } + got := waitSubmits(t, caps, 1) + if got[0].MsgFmt != cmpp.MsgFmtGBK || got[0].TPUdhi != 0 || got[0].PkTotal != 1 { + t.Fatalf("PDU 属性: %+v", got[0]) + } + dec, err := decodeGBK(got[0].Content) + if err != nil || dec != "验证码9527,请勿泄露" { + t.Fatalf("GBK 内容: %q err=%v", dec, err) + } +} + +// TestSubmitViaLinkLongSMS 超长中文:拆 2 片,UDH 头/TP_udhi=1/序号连续,去头拼接还原。 +func TestSubmitViaLinkLongSMS(t *testing.T) { + s := newSvc35(t) + t.Cleanup(func() { s.ShutdownLinks() }) + ln, caps := listenRecordingMini(t) + ctx := context.Background() + ch := mustCreateLinkable(t, s, "lg", ln) + if _, err := s.StartLink(ctx, ch.ID); err != nil { + t.Fatal(err) + } + content := strings.Repeat("长短信测试", 17) // 85 汉字=170B → 2 片 + if _, err := s.links.SubmitViaLink(ctx, ch.ID, "13800001111", content); err != nil { + t.Fatal(err) + } + got := waitSubmits(t, caps, 2) + if len(got) != 2 { + t.Fatalf("应收 2 笔: %d", len(got)) + } + var rebuilt []byte + for i, g := range got { + if g.TPUdhi != 1 || g.MsgFmt != cmpp.MsgFmtGBK || g.PkTotal != 2 || g.PkNumber != uint8(i+1) { + t.Fatalf("片 %d 属性: %+v", i, g) + } + if g.Content[0] != 0x05 || g.Content[1] != 0x00 || g.Content[2] != 0x03 { + t.Fatalf("片 %d UDH 头: % x", i, g.Content[:3]) + } + if i == 0 { + rebuilt = append(rebuilt, g.Content[6:]...) + } else { + if g.Content[3] != got[0].Content[3] || g.Content[4] != got[0].Content[4] { + t.Fatalf("片 %d 参考号不同源", i) + } + rebuilt = append(rebuilt, g.Content[6:]...) + } + } + dec, err := decodeGBK(rebuilt) + if err != nil || dec != content { + t.Fatalf("拼接还原: err=%v equal=%v", err, dec == content) + } +} diff --git a/internal/service/channel/link_test.go b/internal/service/channel/link_test.go new file mode 100644 index 00000000..3e7439a2 --- /dev/null +++ b/internal/service/channel/link_test.go @@ -0,0 +1,431 @@ +// link_test.go Day 31+:通道常驻链路管理测试——建链/守卫/提交/回执缓冲/引导/拆除。 +// 链路经真实 TCP 连接 service_test.go 的迷你 CMPP 网关(listenMiniCMPP:密钥 pw,Submit 固定 MsgID=777)。 +package channel + +import ( + "context" + "fmt" + "net" + "strings" + "testing" + "time" + + "go-sms/internal/model/entity" + "go-sms/internal/protocol/cmpp" +) + +// TestLinkStartStop 验收:建链(池连通)→ 状态视图 → 幂等 → 拆除(重复幂等)。 +func TestLinkStartStop(t *testing.T) { + s := newSvc35(t) + t.Cleanup(func() { s.ShutdownLinks() }) + ln, _ := listenMiniCMPP(t) + ctx := context.Background() + ch := mustCreateLinkable(t, s, "lk-1", ln) + + st, err := s.StartLink(ctx, ch.ID) + if err != nil { + t.Fatal(err) + } + if !st.Running || st.Total != 1 || st.ChannelID != ch.ID { + t.Fatalf("初始状态: %+v", st) + } + if !waitLink(t, s, ch.ID, 1) { + t.Fatalf("链路未就绪: %+v", s.LinkStatus(ch.ID)) + } + if st := s.LinkStatus(ch.ID); st.StartedAt == "" { + t.Fatal("started_at 应非空") + } + // 幂等:重复 StartLink 不翻倍 + st, err = s.StartLink(ctx, ch.ID) + if err != nil || st.Total != 1 { + t.Fatalf("幂等: st=%+v err=%v", st, err) + } + // 拆除 + s.StopLink(ch.ID) + if st := s.LinkStatus(ch.ID); st.Running || st.Total != 0 { + t.Fatalf("停止后: %+v", st) + } + // 重复拆除幂等 + s.StopLink(ch.ID) +} + +// TestLinkGuard 验收:协议/状态/版本/不存在守卫。 +func TestLinkGuard(t *testing.T) { + s := newSvc35(t) + t.Cleanup(func() { s.ShutdownLinks() }) + ctx := context.Background() + + // 非 cmpp 通道 + httpCh := mustCreateCh(t, s, "lg-http") + if _, err := s.StartLink(ctx, httpCh.ID); err == nil { + t.Fatal("非 cmpp 应拒") + } + // 不存在的通道 + if _, err := s.StartLink(ctx, 999); err == nil { + t.Fatal("不存在应报错") + } + // 停用通道 + ln, _ := listenMiniCMPP(t) + chOff := mustCreateLinkable(t, s, "lg-off", ln) + _ = s.SetStatus(ctx, chOff.ID, 0) + if _, err := s.StartLink(ctx, chOff.ID); err == nil { + t.Fatal("停用应拒") + } + // CMPP 3.0(Create 已拒 30,直接改库构造纵深防御场景) + ln30, _ := netListen() + t.Cleanup(func() { _ = ln30.Close() }) + ch30 := mustCreateLinkable(t, s, "lg-30", ln30) + if res := s.db.WithContext(ctx).Model(&entity.ChannelChannel{}).Where("id = ?", ch30.ID).Update("protocol_version", int8(30)); res.Error != nil { + t.Fatal(res.Error) + } + if _, err := s.StartLink(ctx, ch30.ID); err == nil || !strings.Contains(err.Error(), "CMPP 3.0") { + t.Fatalf("CMPP3.0 应拒: %v", err) + } +} + +// TestSubmitViaLink 验收:经常驻链路提交返回上游 MsgID(迷你网关固定 777)。 +func TestSubmitViaLink(t *testing.T) { + s := newSvc35(t) + t.Cleanup(func() { s.ShutdownLinks() }) + ln, _ := listenMiniCMPP(t) + ctx := context.Background() + ch := mustCreateLinkable(t, s, "svl", ln) + if st, err := s.StartLink(ctx, ch.ID); err != nil || !st.Running { + t.Fatalf("初始建链: st=%+v err=%v", st, err) + } + if !waitLink(t, s, ch.ID, 1) { + st := s.LinkStatus(ch.ID) + t.Fatalf("建链失败: status=%+v", st) + } + msgIDs, err := s.links.SubmitViaLink(ctx, ch.ID, "13800001111", "hello") + if err != nil { + t.Fatal(err) + } + if len(msgIDs) != 1 || msgIDs[0] != "777" { + t.Fatalf("msg_ids = %v, 期望 [777]", msgIDs) + } +} + +// TestLinkReceiptsPersist Day 56:持久化回执查询——seg(状态报告)与 +// message_uplink(上行)按时间倒序归并;channel 过滤与 limit 截断。 +func TestLinkReceiptsPersist(t *testing.T) { + s := newSvc35(t) + if err := s.db.AutoMigrate(&entity.MessageReportSeg{}, &entity.MessageUplink{}); err != nil { + t.Fatal(err) + } + base := time.Now().Add(-time.Hour) + mk := func(mins int) time.Time { return base.Add(time.Duration(mins) * time.Minute) } + // 通道 7:两份状态报告+一条上行;通道 8:一条(过滤用)。 + segs := []entity.MessageReportSeg{ + {DetailID: 1, ChannelID: 7, MsgID: "a1", Mobile: "13800001111", PkTotal: 1, ReportAt: ptrTime(mk(10))}, + {DetailID: 2, ChannelID: 7, MsgID: "a2", Mobile: "13900002222", PkTotal: 1, ReportAt: ptrTime(mk(30))}, + {DetailID: 3, ChannelID: 8, MsgID: "a3", Mobile: "13700003333", PkTotal: 1, ReportAt: ptrTime(mk(5))}, + } + for i := range segs { + if err := s.db.Create(&segs[i]).Error; err != nil { + t.Fatal(err) + } + } + mos := []entity.MessageUplink{ + {DestCode: "10086", SrcMobile: "13511112222", Content: "TD退订", AccountID: 1, ChannelID: 7, RecvAt: mk(20)}, + {DestCode: "10086", SrcMobile: "13611113333", Content: "hi", AccountID: 1, ChannelID: 9, RecvAt: mk(15)}, + } + for i := range mos { + if err := s.db.Create(&mos[i]).Error; err != nil { + t.Fatal(err) + } + } + + out, err := s.LinkReceiptsPersist(context.Background(), 7, 50) + if err != nil { + t.Fatal(err) + } + if len(out) != 3 { // 通道 7:报告×2+上行×1 + t.Fatalf("行数=%d 期望 3", len(out)) + } + // 倒序归并:mk(30) 最晚——a2(报告)→上行(20 分)→a1(10 分,报告)。 + if !out[0].IsReport || out[0].MsgID != "a2" { + t.Fatalf("最新应为报告 a2: %+v", out[0]) + } + if out[1].IsReport || out[1].Src != "13511112222" { + t.Fatalf("次新应为上行: %+v", out[1]) + } + if !out[2].IsReport || out[2].MsgID != "a1" { + t.Fatalf("最旧应为报告 a1: %+v", out[2]) + } + // limit 截断。 + out2, _ := s.LinkReceiptsPersist(context.Background(), 7, 2) + if len(out2) != 2 || out2[0].MsgID != "a2" { + t.Fatalf("limit=2 截断: %+v", out2) + } +} + +// ptrTime 便捷取址。 +func ptrTime(t time.Time) *time.Time { return &t } + +// TestDeliverReportSink Day 56:状态报告注入 ReportSink(goroutine 派发, +// 读循环零阻塞红线);上行不派发;未注入维持旧行为(nil 安全)。 +func TestDeliverReportSink(t *testing.T) { + s := newSvc35(t) + ch1 := mustCreateCh(t, s, "rs-1") + got := make(chan []string, 4) + s.links.SetReportSink(sinkFunc(func(channelID int64, msgID, stat, dest, doneTime string) { + got <- []string{msgID, stat, dest, doneTime} + })) + defer s.links.SetReportSink(nil) + + s.links.handleDeliver(ch1.ID, &cmpp.Deliver{ + MsgID: 9, DestID: "10086", MsgFmt: cmpp.MsgFmtASCII, + IsReport: true, + Report: &cmpp.ReportInfo{MsgID: 9, Stat: "DELIVRD", + DoneTime: "0913113005", DestTerminalID: "13800009999"}}) + select { + case v := <-got: + if v[0] != "9" || v[1] != "DELIVRD" || v[2] != "13800009999" || v[3] != "0913113005" { + t.Fatalf("派发参数: %v", v) + } + case <-time.After(2 * time.Second): + t.Fatal("状态报告未派发 ReportSink") + } + + // 上行不派发。 + s.links.handleDeliver(ch1.ID, &cmpp.Deliver{ + MsgID: 10, DestID: "10086", MsgFmt: cmpp.MsgFmtASCII, + SrcTerminal: "13700008888", Content: []byte("MO")}) + select { + case v := <-got: + t.Fatalf("上行不应派发: %v", v) + case <-time.After(150 * time.Millisecond): + } +} + +// sinkFunc 适配器(测试注入)。 +type sinkFunc func(channelID int64, msgID, stat, dest, doneTime string) + +func (f sinkFunc) IngestReport(_ context.Context, channelID int64, msgID, stat, dest, doneTime string) { + f(channelID, msgID, stat, dest, doneTime) +} + +// TestDeliverReceipts 验收:回执/上行注入环形缓冲,查询倒序 + 按通道过滤。 +func TestDeliverReceipts(t *testing.T) { + s := newSvc35(t) + ch1 := mustCreateCh(t, s, "rc-1") // http 通道亦可(handleDeliver 只消费 id) + ch2 := mustCreateCh(t, s, "rc-2") + // 状态报告 + s.links.handleDeliver(ch1.ID, &cmpp.Deliver{ + MsgID: 1, DestID: "10086", MsgFmt: cmpp.MsgFmtASCII, SrcTerminal: "13800001111", + IsReport: true, + Report: &cmpp.ReportInfo{MsgID: 1, Stat: "DELIVRD", SubmitTime: "0904113001", + DoneTime: "0904113005", DestTerminalID: "13800001111", SMSCSequence: 7}}) + // 上行(通道2) + s.links.handleDeliver(ch2.ID, &cmpp.Deliver{ + MsgID: 2, DestID: "10086", MsgFmt: cmpp.MsgFmtASCII, SrcTerminal: "13900002222", + Content: []byte("TD")}) + // 上行(通道1) + s.links.handleDeliver(ch1.ID, &cmpp.Deliver{ + MsgID: 3, DestID: "10086", MsgFmt: cmpp.MsgFmtASCII, SrcTerminal: "13700003333", + Content: []byte("hi")}) + + all := s.LinkReceipts(0, 10) + if len(all) != 3 { + t.Fatalf("total = %d", len(all)) + } + if all[0].IsReport || all[0].Content != "hi" || all[0].Src != "13700003333" { + t.Fatalf("倒序最近(上行): %+v", all[0]) + } + if !all[2].IsReport || all[2].MsgID != "1" || all[2].Stat != "DELIVRD" || all[2].Dest != "13800001111" { + t.Fatalf("最旧(报告): %+v", all[2]) + } + // 按通道过滤(倒序) + one := s.LinkReceipts(ch1.ID, 10) + if len(one) != 2 || one[0].Content != "hi" || one[1].MsgID != "1" { + t.Fatalf("ch1 过滤: %+v", one) + } + // n 截断 + if two := s.LinkReceipts(0, 2); len(two) != 2 || two[0].Content != "hi" { + t.Fatalf("n 截断: %+v", two) + } +} + +// TestDeliverMODecode 上行按 Msg_Fmt 解码(Day52 编码复盘补齐):GBK(0x0F)/UCS2(0x08) +// 注入 → 环形缓冲还原 UTF-8 中文;此前 string(d.Content) 原样直灌致真实上游中文上行乱码。 +func TestDeliverMODecode(t *testing.T) { + s := newSvc35(t) + ch := mustCreateCh(t, s, "mo-dec") + // GBK 上行:复用 EncodeContent 编码「退订」 + gbk, fmtGbk, err := cmpp.EncodeContent("退订") + if err != nil { + t.Fatal(err) + } + s.links.handleDeliver(ch.ID, &cmpp.Deliver{ + MsgID: 1, DestID: "10086", MsgFmt: fmtGbk, SrcTerminal: "13800001111", Content: gbk}) + // UCS2 上行:「停」U+505C + s.links.handleDeliver(ch.ID, &cmpp.Deliver{ + MsgID: 2, DestID: "10086", MsgFmt: cmpp.MsgFmtUCS2, SrcTerminal: "13900002222", + Content: []byte{0x50, 0x5C}}) + all := s.LinkReceipts(0, 10) + if len(all) != 2 { + t.Fatalf("total = %d", len(all)) + } + if all[0].Content != "停" || all[0].Src != "13900002222" { + t.Fatalf("UCS2 上行解码: %+v", all[0]) + } + if all[1].Content != "退订" || all[1].Src != "13800001111" { + t.Fatalf("GBK 上行解码: %+v", all[1]) + } +} + +// TestReceiptsCap 验收:环形缓冲上限(最近 100 条)。 +func TestReceiptsCap(t *testing.T) { + s := newSvc35(t) + ch := mustCreateCh(t, s, "cap") + for i := 0; i < 120; i++ { + s.links.handleDeliver(ch.ID, &cmpp.Deliver{ + MsgID: uint64(i), DestID: "10086", MsgFmt: cmpp.MsgFmtASCII, + SrcTerminal: "13800001111", Content: fmt.Appendf(nil, "c%d", i)}) + } + all := s.LinkReceipts(0, 200) + if len(all) != 100 { + t.Fatalf("缓冲上限 = %d, 期望 100", len(all)) + } + if all[0].Content != "c119" || all[99].Content != "c20" { + t.Fatalf("保留最新: all[0]=%q all[99]=%q", all[0].Content, all[99].Content) + } +} + +// TestBootstrapLinks 验收:启动引导仅对启用中 cmpp 建链(禁用/他协议跳过);Shutdown 全拆。 +func TestBootstrapLinks(t *testing.T) { + s := newSvc35(t) + t.Cleanup(func() { s.ShutdownLinks() }) + ln, _ := listenMiniCMPP(t) + ctx := context.Background() + ch1 := mustCreateLinkable(t, s, "bt-1", ln) + ch2 := mustCreateLinkable(t, s, "bt-2", ln) + ch3 := mustCreateLinkable(t, s, "bt-3", ln) + _ = s.SetStatus(ctx, ch3.ID, 0) + _ = mustCreateCh(t, s, "bt-http") + + s.BootstrapLinks(ctx) + deadline := time.Now().Add(3 * time.Second) + ok1, ok2 := false, false + for time.Now().Before(deadline) { + ok1 = s.LinkStatus(ch1.ID).Running + ok2 = s.LinkStatus(ch2.ID).Running + if ok1 && ok2 { + break + } + time.Sleep(20 * time.Millisecond) + } + if !ok1 || !ok2 { + t.Fatalf("bootstrap: ch1=%v ch2=%v", s.LinkStatus(ch1.ID), s.LinkStatus(ch2.ID)) + } + if s.LinkStatus(ch3.ID).Running { + t.Fatal("禁用通道不应建链") + } + // Shutdown 全拆 + s.ShutdownLinks() + if s.LinkStatus(ch1.ID).Running || s.LinkStatus(ch2.ID).Running { + t.Fatal("shutdown 后仍在运行") + } +} + +// TestRestartLink 验收:参数变更重建(Stop+Start)后链路可用。 +func TestRestartLink(t *testing.T) { + s := newSvc35(t) + t.Cleanup(func() { s.ShutdownLinks() }) + ln, _ := listenMiniCMPP(t) + ctx := context.Background() + ch := mustCreateLinkable(t, s, "rs", ln) + if st, err := s.StartLink(ctx, ch.ID); err != nil || !st.Running { + t.Fatalf("初始建链: st=%+v err=%v", st, err) + } + if !waitLink(t, s, ch.ID, 1) { + t.Fatal("初始建链失败") + } + st, err := s.links.RestartLink(ctx, ch.ID) + if err != nil { + t.Fatal(err) + } + if !st.Running { + t.Fatalf("restart 应 Running: %+v", st) + } + if !waitLink(t, s, ch.ID, 1) { + t.Fatalf("restart 后链路未就绪: %+v", s.LinkStatus(ch.ID)) + } + msgIDs, err := s.links.SubmitViaLink(ctx, ch.ID, "13800001111", "again") + if err != nil || len(msgIDs) != 1 || msgIDs[0] != "777" { + t.Fatalf("restart 后提交: msg=%v err=%v", msgIDs, err) + } +} + +// mustCreateLinkable 建一条可建链的 cmpp 通道(密码与迷你网关密钥 pw 校准)。 +func mustCreateLinkable(t *testing.T, s *Service, code string, ln net.Listener) *entity.ChannelChannel { + t.Helper() + ch, err := s.Create(context.Background(), &CreateReq{ + Name: code, Code: code, Protocol: "cmpp", + Host: "127.0.0.1", Port: portOf(ln), Username: "901234", Password: "pw", + ConnCount: 1, HeartbeatInterval: 1}) + if err != nil { + t.Fatal(err) + } + return ch +} + +// waitLink 轮询等待链路健康连接达到期望值(t 预留测试上下文)。 +func waitLink(_ *testing.T, s *Service, id int64, want int) bool { + deadline := time.Now().Add(3 * time.Second) + for time.Now().Before(deadline) { + if st := s.LinkStatus(id); st.Running && st.Healthy >= want { + return true + } + time.Sleep(20 * time.Millisecond) + } + return false +} + +// uplinkCapture Day 49:上行出口捕获。 +type uplinkCapture struct { + ch chan [4]any // channelID/destCode/srcMobile/content +} + +func newUplinkCapture() *uplinkCapture { + return &uplinkCapture{ch: make(chan [4]any, 4)} +} + +func (u *uplinkCapture) Ingest(_ context.Context, channelID int64, destCode, srcMobile, content string) (int64, error) { + u.ch <- [4]any{channelID, destCode, srcMobile, content} + return 0, nil +} + +// TestHandleDeliverUplinkSink Day 49 验收:Deliver MO 派发上行出口 +// (码号/手机号/内容透传);状态报告不派发;未注入(nil)不派发维持旧行为。 +func TestHandleDeliverUplinkSink(t *testing.T) { + s := newSvc35(t) + ch1 := mustCreateCh(t, s, "up-1") + + // 未注入:无 panic 无派发。 + s.links.handleDeliver(ch1.ID, &cmpp.Deliver{ + MsgID: 1, DestID: "10690001", SrcTerminal: "13800001111", Content: []byte("TD")}) + + cap := newUplinkCapture() + s.SetUplinkSink(cap) + // 上行 MO:派发(异步 goroutine)。 + s.links.handleDeliver(ch1.ID, &cmpp.Deliver{ + MsgID: 2, DestID: "10690001", SrcTerminal: "13800001111", Content: []byte("TD")}) + select { + case got := <-cap.ch: + if got[0] != ch1.ID || got[1] != "10690001" || got[2] != "13800001111" || got[3] != "TD" { + t.Fatalf("派发字段: %v", got) + } + case <-time.After(2 * time.Second): + t.Fatal("MO 未派发上行出口") + } + // 状态报告:不派发。 + s.links.handleDeliver(ch1.ID, &cmpp.Deliver{ + MsgID: 3, IsReport: true, Report: &cmpp.ReportInfo{MsgID: 3, Stat: "DELIVRD"}}) + select { + case got := <-cap.ch: + t.Fatalf("状态报告不应派发上行: %v", got) + case <-time.After(150 * time.Millisecond): + } +} \ No newline at end of file diff --git a/internal/service/channel/log.go b/internal/service/channel/log.go new file mode 100644 index 00000000..067da4f2 --- /dev/null +++ b/internal/service/channel/log.go @@ -0,0 +1,250 @@ +// log.go Day 40(A-3.14):通道日志异步落库器。 +// 设计要点(遵循 Day 39.6 容量规划,MySQL 严禁阻塞发送主链路): +// - 提交/回执海量事件 → 内存队列(非阻塞投递,满则丢弃计数)+ 单 writer 批量落库; +// - submit/deliver 成功事件按 10s 窗口聚合成行(count/latency 均值),失败类逐条(量低+排障价值); +// - connect/disconnect/stop/alert 逐条。 +package channel + +import ( + "sync" + "sync/atomic" + "time" + + "go-sms/internal/model/entity" + "go-sms/internal/pkg/logger" + + "go.uber.org/zap" + + "gorm.io/gorm" +) + +// 日志 kind 常量。 +const ( + LogKindConnect = "connect" // 建链成功 + LogKindDisconnect = "disconnect" // 连接断开(重连前) + LogKindStop = "stop" // 主动拆除 + LogKindSubmit = "submit" // 提交成功(窗口聚合) + LogKindSubmitFail = "submit_fail" // 提交失败(逐条) + LogKindDeliver = "deliver" // 回执 DELIVRD(窗口聚合) + LogKindDeliverFail = "deliver_fail" // 回执非成功态(逐条) + LogKindDeliverMO = "deliver_mo" // 上行短信(逐条) + LogKindAlert = "alert" // 告警留痕 +) + +const ( + logQueueCap = 2048 // 内存队列容量(满则丢弃,绝不阻塞提交) + logFlushBatch = 200 // 批量落库条数 + logFlushEvery = 2 * time.Second // 刷库周期 + logAggWindow = 10 * time.Second // submit/deliver 聚合窗口 +) + +// logEvent 单条内存事件(聚合前)。 +type logEvent struct { + ChannelID int64 + Kind string + Level int8 + MsgID string + Detail string + LatencyMs int + At time.Time +} + +// aggKey 聚合桶键。 +type aggKey struct { + ChannelID int64 + Kind string + Bucket int64 // logAggWindow 对齐的窗口起点 unix 秒 +} + +// aggVal 聚合累计值。 +type aggVal struct { + count int + latSum int + firstAt time.Time +} + +// ChannelLogger 通道日志落库器(nil 安全:未注入时全部 no-op)。 +type ChannelLogger struct { + db *gorm.DB + ch chan logEvent + done chan struct{} + wg sync.WaitGroup + dropped atomic.Int64 + + mu sync.Mutex + agg map[aggKey]*aggVal +} + +// NewChannelLogger 构造并启动后台 writer goroutine。 +func NewChannelLogger(db *gorm.DB) *ChannelLogger { + l := &ChannelLogger{ + db: db, ch: make(chan logEvent, logQueueCap), + done: make(chan struct{}), agg: map[aggKey]*aggVal{}, + } + l.wg.Add(1) + go l.run() + return l +} + +// Log 非阻塞投递(nil 安全;队列满丢弃计数——监控链路不背发送链路的锅)。 +func (l *ChannelLogger) Log(channelID int64, kind string, level int8, msgID, detail string, latencyMs int) { + if l == nil { + return + } + select { + case l.ch <- logEvent{ChannelID: channelID, Kind: kind, Level: level, MsgID: msgID, + Detail: detail, LatencyMs: latencyMs, At: time.Now()}: + default: + n := l.dropped.Add(1) + if n%1000 == 1 { // 限频告警:首个与每千次 + logger.L().Warn("channel_log_dropped", zap.Int64("dropped", n)) + } + } +} + +// FlushNow 立即冲刷聚合桶与队列(测试/优雅停机用)。 +func (l *ChannelLogger) FlushNow() { + if l == nil { + return + } + // 排空队列:直写行先收集,聚合事件进桶。 + var direct []entity.ChannelLog + for { + select { + case e := <-l.ch: + direct = append(direct, l.ingest(e)...) + continue + default: + } + break + } + l.writeRows(direct) + l.flushAgg(time.Now()) +} + +// Close 冲刷并停止(幂等)。 +func (l *ChannelLogger) Close() { + if l == nil { + return + } + select { + case <-l.done: + return // 已关闭 + default: + close(l.done) + } + l.wg.Wait() +} + +// run 后台循环:收事件→聚合/缓冲→周期批量落库。 +func (l *ChannelLogger) run() { + defer l.wg.Done() + tick := time.NewTicker(logFlushEvery) + defer tick.Stop() + var aggBuf []entity.ChannelLog + for { + select { + case e := <-l.ch: + l.writeRows(l.ingest(e)) // 直写行(连接事件/失败)即时落库(低频,时序确定);submit/deliver 只进聚合桶 + case <-tick.C: + aggBuf = l.flushAggTo(aggBuf, time.Now()) + if len(aggBuf) > 0 { + aggBuf = l.writeRows(aggBuf) + } + case <-l.done: + // 终态冲刷:排空队列+聚合桶后退出。 + for { + select { + case e := <-l.ch: + l.writeRows(l.ingest(e)) + continue + default: + } + break + } + l.flushAgg(time.Now()) + return + } + } +} + +// ingest 单事件处理:可聚合 kind 进桶(返回空),其余返回待写行。 +func (l *ChannelLogger) ingest(e logEvent) []entity.ChannelLog { + switch e.Kind { + case LogKindSubmit, LogKindDeliver: + k := aggKey{ChannelID: e.ChannelID, Kind: e.Kind, Bucket: e.At.Unix() / int64(logAggWindow/time.Second)} + l.mu.Lock() + v, ok := l.agg[k] + if !ok { + v = &aggVal{firstAt: e.At} + l.agg[k] = v + } + v.count++ + v.latSum += e.LatencyMs + l.mu.Unlock() + return nil + default: + return []entity.ChannelLog{e.row()} + } +} + +// flushAgg 冲刷全部聚合桶(当前窗口一并落库,快照语义;now 预留快照时刻)。 +func (l *ChannelLogger) flushAgg(_ time.Time) { + l.mu.Lock() + rows := make([]entity.ChannelLog, 0, len(l.agg)) + for k, v := range l.agg { + rows = append(rows, entity.ChannelLog{ + ChannelID: k.ChannelID, Kind: k.Kind, + Detail: "窗口聚合", + Count: v.count, + LatencyMs: avgLat(v.latSum, v.count), + }) + delete(l.agg, k) + } + l.mu.Unlock() + l.writeRows(rows) +} + +// flushAggTo 把过期聚合桶(窗口已闭合)转为待写行,追加到 buf。 +func (l *ChannelLogger) flushAggTo(buf []entity.ChannelLog, now time.Time) []entity.ChannelLog { + cur := now.Unix() / int64(logAggWindow/time.Second) + l.mu.Lock() + for k, v := range l.agg { + if k.Bucket >= cur { + continue // 当前窗口未闭合 + } + buf = append(buf, entity.ChannelLog{ + ChannelID: k.ChannelID, Kind: k.Kind, + Detail: "窗口聚合", Count: v.count, LatencyMs: avgLat(v.latSum, v.count), + }) + delete(l.agg, k) + } + l.mu.Unlock() + return buf +} + +// writeRows 批量落库(失败仅告警,不中断 writer)。 +func (l *ChannelLogger) writeRows(rows []entity.ChannelLog) []entity.ChannelLog { + if len(rows) == 0 { + return rows[:0] + } + if err := l.db.CreateInBatches(rows, logFlushBatch).Error; err != nil { + logger.L().Warn("channel_log_write_failed", zap.Int64("rows", int64(len(rows)))) + } + return rows[:0] +} + +// row 内存事件转实体行。 +func (e logEvent) row() entity.ChannelLog { + return entity.ChannelLog{ + ChannelID: e.ChannelID, Kind: e.Kind, Level: e.Level, + MsgID: e.MsgID, Detail: e.Detail, Count: 1, LatencyMs: e.LatencyMs, + } +} + +func avgLat(sum, n int) int { + if n == 0 { + return 0 + } + return sum / n +} diff --git a/internal/service/channel/log_test.go b/internal/service/channel/log_test.go new file mode 100644 index 00000000..92c240bb --- /dev/null +++ b/internal/service/channel/log_test.go @@ -0,0 +1,83 @@ +// log_test.go Day 40(A-3.14):通道日志落库器测试——聚合/逐条/nil 安全。 +package channel + +import ( + "testing" + + "go-sms/internal/model/entity" + + "github.com/glebarez/sqlite" + "gorm.io/gorm" +) + +func newLogDB(t *testing.T) *gorm.DB { + t.Helper() + db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{}) + if err != nil { + t.Fatal(err) + } + if err := db.AutoMigrate(&entity.ChannelLog{}); err != nil { + t.Fatal(err) + } + return db +} + +// TestChannelLogger_AggregateAndPersist 验收:submit 窗口聚合成行(count/延迟均值), +// submit_fail/disconnect 逐条;FlushNow 全部落库。 +func TestChannelLogger_AggregateAndPersist(t *testing.T) { + db := newLogDB(t) + l := NewChannelLogger(db) + defer l.Close() + + // 3 条成功提交(延迟 10/20/30 → 均值 20)+1 条失败+1 条断连。 + l.Log(7, LogKindSubmit, 0, "m1", "", 10) + l.Log(7, LogKindSubmit, 0, "m2", "", 20) + l.Log(7, LogKindSubmit, 0, "m3", "", 30) + l.Log(7, LogKindSubmitFail, 2, "", "上游拒绝: result=8", 5) + l.Log(7, LogKindDisconnect, 2, "", "conn#0: read eof", 0) + l.FlushNow() + + var rows []entity.ChannelLog + if err := db.Order("kind").Find(&rows).Error; err != nil { + t.Fatal(err) + } + if len(rows) != 3 { + t.Fatalf("行数=%d 期望 3: %+v", len(rows), rows) + } + byKind := map[string]entity.ChannelLog{} + for _, r := range rows { + byKind[r.Kind] = r + } + if s := byKind[LogKindSubmit]; s.Count != 3 || s.LatencyMs != 20 { + t.Fatalf("submit 聚合行: %+v", s) + } + if f := byKind[LogKindSubmitFail]; f.Count != 1 || f.Level != 2 || f.Detail == "" { + t.Fatalf("submit_fail 逐条行: %+v", f) + } + if d := byKind[LogKindDisconnect]; d.Level != 2 || d.ChannelID != 7 { + t.Fatalf("disconnect 逐条行: %+v", d) + } +} + +// TestChannelLogger_CloseFlush 冲刷语义:Close 前未 FlushNow 的事件在 Close 时落库。 +func TestChannelLogger_CloseFlush(t *testing.T) { + db := newLogDB(t) + l := NewChannelLogger(db) + l.Log(9, LogKindConnect, 0, "", "pool started", 0) + l.Close() + var n int64 + db.Model(&entity.ChannelLog{}).Count(&n) + if n != 1 { + t.Fatalf("Close 冲刷行数=%d 期望 1", n) + } + // 幂等 Close。 + l.Close() +} + +// TestChannelLogger_NilSafe nil 接收者全部 no-op(不 panic)。 +func TestChannelLogger_NilSafe(t *testing.T) { + var l *ChannelLogger + l.Log(1, LogKindSubmit, 0, "", "", 1) + l.FlushNow() + l.Close() +} diff --git a/internal/service/channel/monitor.go b/internal/service/channel/monitor.go new file mode 100644 index 00000000..78505f1e --- /dev/null +++ b/internal/service/channel/monitor.go @@ -0,0 +1,152 @@ +// monitor.go Day 40(A-3.13):通道实时监控统计(WS 2s 推送数据源)。 +// 每通道 60s 滑动窗口(1s 桶)统计提交/回执速率、失败率与延迟 p50 近似 +// (最近 256 个样本环形中位数)——内存 O(通道数×60) 极轻,读写均锁内 O(1)。 +package channel + +import ( + "sort" + "sync" + "time" +) + +const ( + monWindowSec = 60 // 统计滑窗(秒) + monLatCap = 256 // 延迟样本环形容量 +) + +// bucket 单秒桶。 +type bucket struct { + sec int64 + submit int + fail int + deliver int + deliverFail int +} + +// chanStat 单通道统计。 +type chanStat struct { + buckets []bucket // 环形 monWindowSec 格 + bi int // 当前桶游标 + lats []int // 延迟样本环形 + li int +} + +// ChannelSnapshot 单通道实时快照(WS/轮询视图)。 +type ChannelSnapshot struct { + ChannelID int64 `json:"channel_id"` + Name string `json:"name"` + Protocol string `json:"protocol"` + Status int8 `json:"status"` + Running bool `json:"running"` + Total int `json:"total"` + Healthy int `json:"healthy"` + SubmitPs float64 `json:"submit_ps"` // 60s 窗口均值(条/秒) + DeliverPs float64 `json:"deliver_ps"` // 60s 窗口均值(条/秒) + FailRate float64 `json:"fail_rate"` // 60s 窗口失败占比(0~1;无提交=0) + LatencyP50 int `json:"latency_p50_ms"` // 最近样本中位数 + UpdatedAt string `json:"updated_at"` +} + +// Monitor 通道统计中心(Service 内嵌单例;线程安全)。 +type Monitor struct { + mu sync.Mutex + stat map[int64]*chanStat +} + +// NewMonitor 构造。 +func NewMonitor() *Monitor { + return &Monitor{stat: map[int64]*chanStat{}} +} + +// ReportSubmit 记录一次提交(ok=是否成功;latencyMs 成功时延迟)。 +func (m *Monitor) ReportSubmit(channelID int64, ok bool, latencyMs int) { + if m == nil { + return + } + m.mu.Lock() + defer m.mu.Unlock() + s := m.statOf(channelID) + b := s.curBucket() + if ok { + b.submit++ + s.pushLat(latencyMs) + } else { + b.submit++ + b.fail++ + } +} + +// ReportDeliver 记录一条回执/上行(ok=是否成功态报告)。 +func (m *Monitor) ReportDeliver(channelID int64, ok bool) { + if m == nil { + return + } + m.mu.Lock() + defer m.mu.Unlock() + b := m.statOf(channelID).curBucket() + if ok { + b.deliver++ + } else { + b.deliver++ + b.deliverFail++ + } +} + +// Stats 读取通道窗口统计(WS 快照/告警评估共用)。 +func (m *Monitor) Stats(channelID int64) (submit, fail, deliver, deliverFail int, latP50 int) { + if m == nil { + return + } + m.mu.Lock() + defer m.mu.Unlock() + s, ok := m.stat[channelID] + if !ok { + return + } + now := time.Now().Unix() + for _, b := range s.buckets { + if now-b.sec >= monWindowSec { + continue // 过期桶 + } + submit += b.submit + fail += b.fail + deliver += b.deliver + deliverFail += b.deliverFail + } + lats := append([]int(nil), s.lats...) + if len(lats) > 0 { + sort.Ints(lats) + latP50 = lats[len(lats)/2] + } + return +} + +// ---- 内部 ---- + +func (m *Monitor) statOf(id int64) *chanStat { + s, ok := m.stat[id] + if !ok { + s = &chanStat{buckets: make([]bucket, monWindowSec)} + m.stat[id] = s + } + return s +} + +// curBucket 取当前秒桶(跨秒推进游标,旧桶自动失效)。 +func (s *chanStat) curBucket() *bucket { + sec := time.Now().Unix() + if s.buckets[s.bi].sec != sec { + s.bi = (s.bi + 1) % monWindowSec + s.buckets[s.bi] = bucket{sec: sec} // 新秒清零(环形覆盖旧桶) + } + return &s.buckets[s.bi] +} + +func (s *chanStat) pushLat(ms int) { + if len(s.lats) < monLatCap { + s.lats = append(s.lats, ms) + return + } + s.lats[s.li] = ms + s.li = (s.li + 1) % monLatCap +} diff --git a/internal/service/channel/monitor_test.go b/internal/service/channel/monitor_test.go new file mode 100644 index 00000000..d7d91e62 --- /dev/null +++ b/internal/service/channel/monitor_test.go @@ -0,0 +1,59 @@ +// monitor_test.go Day 40(A-3.13):通道监控统计测试——滑窗累计/失败率/延迟 p50。 +package channel + +import ( + "testing" + "time" +) + +// TestMonitor_Stats 验收:提交/失败/回执计数与延迟中位数正确。 +func TestMonitor_Stats(t *testing.T) { + m := NewMonitor() + for _, lat := range []int{10, 20, 30, 40, 50} { + m.ReportSubmit(1, true, lat) + } + m.ReportSubmit(1, false, 0) + m.ReportDeliver(1, true) + m.ReportDeliver(1, false) + + submit, fail, deliver, deliverFail, p50 := m.Stats(1) + if submit != 6 || fail != 1 { + t.Fatalf("submit=%d fail=%d 期望 6/1", submit, fail) + } + if deliver != 2 || deliverFail != 1 { + t.Fatalf("deliver=%d fail=%d 期望 2/1", deliver, deliverFail) + } + // 中位数:样本 10..50 排序中位 30。 + if p50 != 30 { + t.Fatalf("p50=%d 期望 30", p50) + } + // 未统计通道全零。 + if s, f, d, df, p := m.Stats(2); s != 0 || f != 0 || d != 0 || df != 0 || p != 0 { + t.Fatalf("空通道应全零: %d %d %d %d %d", s, f, d, df, p) + } +} + +// TestMonitor_CrossSecond 跨秒桶累计(同通道事件跨秒仍聚合在 60s 窗口内)。 +func TestMonitor_CrossSecond(t *testing.T) { + m := NewMonitor() + m.ReportSubmit(3, true, 5) + time.Sleep(1100 * time.Millisecond) + m.ReportSubmit(3, true, 15) + submit, _, _, _, p50 := m.Stats(3) + if submit != 2 { + t.Fatalf("跨秒累计 submit=%d 期望 2", submit) + } + if p50 != 15 { // 两个样本排序 [5,15] 中位 index=1 → 15 + t.Fatalf("p50=%d 期望 15", p50) + } +} + +// TestMonitor_NilSafe nil 接收者 no-op。 +func TestMonitor_NilSafe(t *testing.T) { + var m *Monitor + m.ReportSubmit(1, true, 1) + m.ReportDeliver(1, true) + if s, f, d, df, p := m.Stats(1); s != 0 || f != 0 || d != 0 || df != 0 || p != 0 { + t.Fatal("nil Stats 应全零") + } +} diff --git a/internal/service/channel/price.go b/internal/service/channel/price.go new file mode 100644 index 00000000..7689ba0c --- /dev/null +++ b/internal/service/channel/price.go @@ -0,0 +1,82 @@ +// price.go Day 38:通道分时成本价(price_timeline)—— +// 写入时间线记录,查询按生效时间点取最新一条;无时间线记录回退通道实体 Price。 +package channel + +import ( + "context" + stderrors "errors" + "time" + + "gorm.io/gorm" + + "go-sms/internal/model/entity" + errs "go-sms/internal/pkg/errors" +) + +// SetPriceReq 设置价格请求。 +type SetPriceReq struct { + Price float64 `json:"price"` // 元/条(≥0) + EffectiveAt string `json:"effective_at"` // RFC3339;空=立即生效 +} + +// SetPrice 写入一条价格时间线(通道存在校验 + 价格非负)。 +func (s *Service) SetPrice(ctx context.Context, chID int64, req *SetPriceReq) (*entity.ChannelPrice, error) { + if _, err := s.Get(ctx, chID); err != nil { + return nil, err + } + if req.Price < 0 { + return nil, errs.InvalidParam.WithMsg("价格不能为负") + } + at := time.Now() + if req.EffectiveAt != "" { + var err error + at, err = time.Parse(time.RFC3339, req.EffectiveAt) + if err != nil { + return nil, errs.InvalidParam.WithMsg("effective_at 须为 RFC3339 格式") + } + } + p := &entity.ChannelPrice{ChannelID: chID, Price: req.Price, EffectiveAt: at} + if err := s.db.WithContext(ctx).Create(p).Error; err != nil { + return nil, err + } + return p, nil +} + +// ListPrices 价格时间线(生效时间升序)。 +func (s *Service) ListPrices(ctx context.Context, chID int64) ([]entity.ChannelPrice, error) { + var out []entity.ChannelPrice + if err := s.db.WithContext(ctx).Where("channel_id = ?", chID).Order("effective_at ASC").Find(&out).Error; err != nil { + return nil, err + } + return out, nil +} + +// DeletePrice 删除时间线记录(须归属该通道)。 +func (s *Service) DeletePrice(ctx context.Context, chID, priceID int64) error { + res := s.db.WithContext(ctx).Where("id = ? AND channel_id = ?", priceID, chID).Delete(&entity.ChannelPrice{}) + if res.Error != nil { + return res.Error + } + if res.RowsAffected == 0 { + return errs.NotFound.WithMsg("价格记录不存在") + } + return nil +} + +// CurrentPrice 按时间点取单价:EffectiveAt<=t 的最新一条;无时间线记录回退通道实体 Price。 +func (s *Service) CurrentPrice(ctx context.Context, chID int64, t time.Time) (float64, error) { + ch, err := s.Get(ctx, chID) + if err != nil { + return 0, err + } + var p entity.ChannelPrice + err = s.db.WithContext(ctx).Where("channel_id = ? AND effective_at <= ?", chID, t). + Order("effective_at DESC").First(&p).Error + if err == nil { + return p.Price, nil + } + if !stderrors.Is(err, gorm.ErrRecordNotFound) { + return 0, err + } + return ch.Price, nil // 回退实体默认价 +} \ No newline at end of file diff --git a/internal/service/channel/price_test.go b/internal/service/channel/price_test.go new file mode 100644 index 00000000..6ef2aa3b --- /dev/null +++ b/internal/service/channel/price_test.go @@ -0,0 +1,91 @@ +// price_test.go Day 38 验收:通道分时成本价——时间线 CRUD + 当前时间点单价(无记录回退实体价)。 +package channel + +import ( + "context" + "testing" + "time" + + "go-sms/internal/model/entity" +) + +// TestPriceTimeline 验收:价格时间线按当前时间返回正确单价。 +func TestPriceTimeline(t *testing.T) { + s := newSvcPrice(t) + ctx := context.Background() + ch, err := s.Create(ctx, &CreateReq{Name: "价", Code: "pr-1", Protocol: "http", + Host: "http://p", Price: 0.05}) + if err != nil { + t.Fatal(err) + } + // 无时间线记录 → 回退实体 Price + if v, err := s.CurrentPrice(ctx, ch.ID, time.Now()); err != nil || v != 0.05 { + t.Fatalf("回退实体价: %v err=%v", v, err) + } + // 过去 0.04 / 未来 0.06 + past := time.Now().Add(-time.Hour) + future := time.Now().Add(time.Hour) + if _, err := s.SetPrice(ctx, ch.ID, &SetPriceReq{ + Price: 0.04, EffectiveAt: past.Format(time.RFC3339)}); err != nil { + t.Fatal(err) + } + p2, err := s.SetPrice(ctx, ch.ID, &SetPriceReq{ + Price: 0.06, EffectiveAt: future.Format(time.RFC3339)}) + if err != nil { + t.Fatal(err) + } + // 当前 → 0.04(过去生效) + if v, err := s.CurrentPrice(ctx, ch.ID, time.Now()); err != nil || v != 0.04 { + t.Fatalf("当前价: %v err=%v", v, err) + } + // 未来时点 → 0.06 + if v, err := s.CurrentPrice(ctx, ch.ID, future.Add(time.Minute)); err != nil || v != 0.06 { + t.Fatalf("未来价: %v err=%v", v, err) + } + // 边界:恰在生效时刻 → 该条生效(<=) + if v, err := s.CurrentPrice(ctx, ch.ID, past); err != nil || v != 0.04 { + t.Fatalf("生效边界: %v err=%v", v, err) + } + // 列表(升序) + list, err := s.ListPrices(ctx, ch.ID) + if err != nil || len(list) != 2 || list[0].Price != 0.04 { + t.Fatalf("列表: %+v err=%v", list, err) + } + // 删除未来条目 → 当前价仍 0.04 + if err := s.DeletePrice(ctx, ch.ID, p2.ID); err != nil { + t.Fatal(err) + } + if v, _ := s.CurrentPrice(ctx, ch.ID, time.Now()); v != 0.04 { + t.Fatalf("删除后当前价: %v", v) + } + // 守卫:负价格/坏时间格式/通道不存在/跨通道删除 + if _, err := s.SetPrice(ctx, ch.ID, &SetPriceReq{Price: -0.1}); err == nil { + t.Fatal("负价格应拒") + } + if _, err := s.SetPrice(ctx, ch.ID, &SetPriceReq{Price: 0.1, EffectiveAt: "not-rfc3339"}); err == nil { + t.Fatal("坏时间格式应拒") + } + if _, err := s.SetPrice(ctx, 999, &SetPriceReq{Price: 0.1}); err == nil { + t.Fatal("通道不存在应拒") + } + if _, err := s.SetPrice(ctx, ch.ID, &SetPriceReq{Price: 0.1}); err != nil { + t.Fatal(err) + } + if err := s.DeletePrice(ctx, 999, 1); err == nil { + t.Fatal("跨通道删除应 404") + } + // 列表 2 条(0.04 + 立即生效 0.1) + if list, _ := s.ListPrices(ctx, ch.ID); len(list) != 2 { + t.Fatalf("最终列表 = %d", len(list)) + } +} + +// newSvcPrice 建库(含价格时间线表)。 +func newSvcPrice(t *testing.T) *Service { + t.Helper() + s := newSvc35(t) + if err := s.db.AutoMigrate(&entity.ChannelPrice{}); err != nil { + t.Fatal(err) + } + return s +} \ No newline at end of file diff --git a/internal/service/channel/service.go b/internal/service/channel/service.go new file mode 100644 index 00000000..ebe5b03a --- /dev/null +++ b/internal/service/channel/service.go @@ -0,0 +1,703 @@ +// Package channel 通道领域服务(Day 35):CRUD、测试工具(单条测试短信验证连通性)、 +// 拦截配置(夜发/日限/屏蔽地区)与当日计数。 +package channel + +import ( + "context" + stderrors "errors" + "fmt" + "sort" + "strings" + "sync" + "time" + + "gorm.io/gorm" + + "go-sms/internal/model/entity" + errs "go-sms/internal/pkg/errors" + "go-sms/internal/protocol/httpadapter" + "go-sms/internal/protocol/sgip" + "go-sms/internal/protocol/smpp" + "go-sms/internal/repository/mysql" +) + +// 支持的接入协议。 +var validProtocols = map[string]bool{"cmpp": true, "http": true, "sgip": true, "smpp": true} + +// 拦截结果码(CheckIntercept 返回)。 +const ( + ResultPass int8 = 0 // 放行 + ResultNightBlock int8 = -1 // 夜发拦截 + ResultRegionHit int8 = -2 // 屏蔽地区命中 + ResultDayLimit int8 = -3 // 日限超出(计划验收:-3) +) + +// Service 通道服务。 +type Service struct { + db *gorm.DB + dao *mysql.BaseDAO[*entity.ChannelChannel] + + mu sync.Mutex + dayCnt map[int64]*dayCounter // 通道当日计数(单实例;生产切 Redis) + + links *linkManager // 常驻链路(Day 31+:cmpp.Pool 业务挂载) + logs *ChannelLogger // 通道日志(Day 40 · A-3.14;db nil 时为 nil=no-op) + mon *Monitor // 实时统计(Day 40 · A-3.13;WS 2s 推送源) + alerts *ChannelAlertService // 通道告警(Day 40 · A-3.12) +} + +// dayCounter 当日计数(跨日自动清零)。 +type dayCounter struct { + date string + n int +} + +// NewService 构造(db 为 nil 时日志/告警降级 no-op,监控统计仍可用)。 +func NewService(db *gorm.DB) *Service { + s := &Service{db: db, dao: mysql.NewBaseDAO[*entity.ChannelChannel](db), dayCnt: map[int64]*dayCounter{}, mon: NewMonitor()} + if db != nil { + s.logs = NewChannelLogger(db) + } + s.links = newLinkManager(s) + s.alerts = NewChannelAlertService(db, s.mon, s.links.Status, nil) + s.alerts.SetLogHook(func(channelID int64, kind string, level int8, msgID, detail string, latencyMs int) { + s.logs.Log(channelID, kind, level, msgID, detail, latencyMs) + }) + return s +} + +// UplinkSink 上行处理出口(Day 49:Deliver MO→码号分配+落库+sms-up 投递; +// 由 service/uplink.Service 实现,channel 只依赖接口避免包循环)。 +type UplinkSink interface { + Ingest(ctx context.Context, channelID int64, destCode, srcMobile, content string) (int64, error) +} + +// SetUplinkSink 注入上行处理器(nil=维持 Day48 前仅日志/环形缓冲行为)。 +func (s *Service) SetUplinkSink(u UplinkSink) { s.links.SetUplinkSink(u) } + +// SetReportSink 注入回执出口(Day 56;nil=维持 Day55 前仅日志/环形缓冲行为)。 +func (s *Service) SetReportSink(r ReportSink) { s.links.SetReportSink(r) } + +// LinkReceiptsPersist 持久化回执查询(Day 56):状态报告=message_report_seg +// (report_at 非空行),上行=message_uplink;按时间倒序归并截取 n 条。 +// 重启后回执可查(环形缓冲 100 条/进程内,本方法为持久层真源); +// 查询失败返回 error(调用方降级内存环形)。 +func (s *Service) LinkReceiptsPersist(ctx context.Context, channelID int64, n int) ([]Receipt, error) { + if s.db == nil || n <= 0 { + return []Receipt{}, nil + } + var segs []entity.MessageReportSeg + if err := s.db.WithContext(ctx). + Where("channel_id = ? AND report_at IS NOT NULL", channelID). + Order("report_at DESC").Limit(n).Find(&segs).Error; err != nil { + return nil, err + } + var mos []entity.MessageUplink + if err := s.db.WithContext(ctx). + Where("channel_id = ?", channelID). + Order("recv_at DESC").Limit(n).Find(&mos).Error; err != nil { + return nil, err + } + out := make([]Receipt, 0, len(segs)+len(mos)) + for _, sg := range segs { + at := sg.ReportAt.Format("2006-01-02 15:04:05") + out = append(out, Receipt{ + ChannelID: channelID, IsReport: true, MsgID: sg.MsgID, + Stat: sg.RawCode, Dest: sg.Mobile, At: at, + }) + } + for _, mo := range mos { + out = append(out, Receipt{ + ChannelID: channelID, IsReport: false, + Src: mo.SrcMobile, Content: mo.Content, + At: mo.RecvAt.Format("2006-01-02 15:04:05"), + }) + } + // 归并倒序截 n(两路各自倒序,线性归并)。 + sort.Slice(out, func(i, j int) bool { return out[i].At > out[j].At }) + if len(out) > n { + out = out[:n] + } + return out, nil +} + +// Close 优雅收尾:冲刷通道日志落库并停止 writer(进程退出/测试 Cleanup 调用)。 +func (s *Service) Close() { + if s.logs != nil { + s.logs.Close() + } +} + +// AlertService 暴露告警服务(gateway cron 装配扫描任务)。 +func (s *Service) AlertService() *ChannelAlertService { return s.alerts } + +// MonitorSnapshot 全通道实时快照(A-3.13:WS 2s 推送/HTTP 轮询共用)。 +func (s *Service) MonitorSnapshot(ctx context.Context) ([]ChannelSnapshot, error) { + list, _, err := s.List(ctx, &ListQuery{Page: 1, PageSize: 100, Status: -1}) // Status=-1 全量(含停用,运维视图) + if err != nil { + return nil, err + } + out := make([]ChannelSnapshot, 0, len(list)) + now := time.Now().Format("2006-01-02 15:04:05") + for _, ch := range list { + st := s.links.Status(ch.ID) + submit, fail, deliver, _, latP50 := s.mon.Stats(ch.ID) + snap := ChannelSnapshot{ + ChannelID: ch.ID, Name: ch.Name, Protocol: ch.Protocol, Status: ch.Status, + SubmitPs: float64(submit) / float64(monWindowSec), + DeliverPs: float64(deliver) / float64(monWindowSec), + LatencyP50: latP50, UpdatedAt: now, + } + if submit > 0 { + snap.FailRate = float64(fail) / float64(submit) + } + if st != nil { + snap.Running, snap.Total, snap.Healthy = st.Running, st.Total, st.Healthy + } + out = append(out, snap) + } + return out, nil +} + +// ListLogs 通道日志查询(A-3.14:连接/提交/回执完整记录;倒序分页)。 +func (s *Service) ListLogs(ctx context.Context, channelID int64, kind string, page, pageSize int) ([]entity.ChannelLog, int64, error) { + if s.db == nil { + return nil, 0, ErrLinkUnavailable + } + q := s.db.WithContext(ctx).Model(&entity.ChannelLog{}).Where("channel_id = ?", channelID) + if kind != "" { + q = q.Where("kind = ?", kind) + } + var total int64 + if err := q.Count(&total).Error; err != nil { + return nil, 0, err + } + if page < 1 { + page = 1 + } + if pageSize < 1 || pageSize > 100 { + pageSize = 20 + } + var list []entity.ChannelLog + if err := q.Order("id DESC").Offset((page - 1) * pageSize).Limit(pageSize).Find(&list).Error; err != nil { + return nil, 0, err + } + return list, total, nil +} + +// ---- 常驻链路(Day 31+):导出包装 ---- + +// StartLink 为通道建立常驻长连接(幂等)。 +func (s *Service) StartLink(ctx context.Context, id int64) (*LinkStatus, error) { return s.links.StartLink(ctx, id) } + +// StopLink 拆除链路(幂等)。 +func (s *Service) StopLink(id int64) { s.links.StopLink(id) } + +// LinkStatus 链路状态。 +func (s *Service) LinkStatus(id int64) *LinkStatus { return s.links.Status(id) } + +// LinkReceipts 最近 n 条回执(倒序;channelID 过滤)。 +func (s *Service) LinkReceipts(channelID int64, n int) []Receipt { return s.links.Receipts(channelID, n) } + +// BootstrapLinks 启动时为启用中的 cmpp 通道建链。 +func (s *Service) BootstrapLinks(ctx context.Context) { go s.links.Bootstrap(ctx) } + +// ShutdownLinks 拆除全部链路。 +func (s *Service) ShutdownLinks() { s.links.Shutdown() } + +// CreateReq 创建通道请求。 +type CreateReq struct { + Name string `json:"name" binding:"required"` + Code string `json:"code" binding:"required"` + Protocol string `json:"protocol" binding:"required"` + Host string `json:"host" binding:"required"` + Port int `json:"port"` + Username string `json:"username"` + Password string `json:"password"` + Speed int `json:"speed"` + ConnCount int `json:"conn_count"` // Day 31 联调补:此前缺失导致提交值被忽略(落默认 1) + UpstreamID int64 `json:"upstream_id"` + Priority int `json:"priority"` + Weight int `json:"weight"` + IsDefault int8 `json:"is_default"` + Remark string `json:"remark"` + + // 协议接入参数(Day 31)。 + SpID string `json:"sp_id"` // 企业代码(cmpp/sgip;cmpp ≤6B) + ProtocolVersion int8 `json:"protocol_version"` // cmpp:20|30 sgip:12 smpp:34(缺省按协议填充) + HeartbeatInterval int `json:"heartbeat_interval"` + ReconnectMax int `json:"reconnect_max"` + ServiceID string `json:"service_id"` + + // 运营属性(Day 31)。 + Carrier string `json:"carrier"` // 逗号分隔 cmcc,cucc,ctcc + BillingLength int `json:"billing_length"` + PaymentType string `json:"payment_type"` + BillingMode string `json:"billing_mode"` + Price float64 `json:"price"` + Category string `json:"category"` + MOForwardChannelID int64 `json:"mo_forward_channel_id"` + NumberRule int8 `json:"number_rule"` + CodeTruncate int8 `json:"code_truncate"` + ExtParams string `json:"ext_params"` + ServiceRemark string `json:"service_remark"` +} + +// 合法运营属性白名单。 +var ( + validCarriers = map[string]bool{"cmcc": true, "cucc": true, "ctcc": true} + validPaymentType = map[string]bool{"": true, "prepay_monthly": true, "postpaid_monthly": true, "prepay_realtime": true} + validBillingMode = map[string]bool{"": true, "success_unknown": true, "success": true, "all": true} +) + +// validateExt 校验 Day 31 扩展字段(返回规范化后的值)。 +func (s *Service) validateExt(req *CreateReq) error { + req.SpID = strings.TrimSpace(req.SpID) + if len(req.SpID) > 6 { + return errs.InvalidParam.WithMsg("企业代码(sp_id)不得超过 6 字节") + } + // 版本:缺省按协议填充;cmpp 显式拒绝 3.0(协议栈未实现)。 + switch req.Protocol { + case "cmpp": + if req.ProtocolVersion == 0 { + req.ProtocolVersion = 20 + } + if req.ProtocolVersion == 30 { + return errs.InvalidParam.WithMsg("CMPP 3.0 协议栈未实现(当前仅支持 2.0)") + } + if req.ProtocolVersion != 20 { + return errs.InvalidParam.WithMsg("CMPP 版本仅支持 2.0") + } + case "sgip": + req.ProtocolVersion = 12 + case "smpp": + req.ProtocolVersion = 34 + default: // http + req.ProtocolVersion = 0 + } + if req.HeartbeatInterval < 0 || req.HeartbeatInterval > 600 { + return errs.InvalidParam.WithMsg("心跳周期须在 0~600 秒(0 取默认 30)") + } + if req.HeartbeatInterval == 0 { + req.HeartbeatInterval = 30 + } + if req.ReconnectMax < 0 || req.ReconnectMax > 3600 { + return errs.InvalidParam.WithMsg("重连上限须在 0~3600 秒(0 取默认 30)") + } + if req.ReconnectMax == 0 { + req.ReconnectMax = 30 + } + // 运营商:每项须合法。 + for _, c := range strings.Split(req.Carrier, ",") { + c = strings.TrimSpace(c) + if c != "" && !validCarriers[c] { + return errs.InvalidParam.WithMsg("运营商仅支持 cmcc/cucc/ctcc: " + c) + } + } + if !validPaymentType[req.PaymentType] { + return errs.InvalidParam.WithMsg("付款方式非法(仅 prepay_monthly/postpaid_monthly/prepay_realtime)") + } + if !validBillingMode[req.BillingMode] { + return errs.InvalidParam.WithMsg("计费方式非法(仅 success_unknown/success/all)") + } + if req.BillingLength < 0 || req.BillingLength > 1000 { + return errs.InvalidParam.WithMsg("计费长度须在 0~1000 字(0 取默认 70)") + } + if req.BillingLength == 0 { + req.BillingLength = 70 + } + if req.Price < 0 { + return errs.InvalidParam.WithMsg("通道价格不能为负") + } + if req.NumberRule < 0 || req.NumberRule > 3 { + return errs.InvalidParam.WithMsg("号码组装规则仅 0~3") + } + if req.CodeTruncate < 0 || req.CodeTruncate > 20 { + return errs.InvalidParam.WithMsg("通道号截断位数须在 0~20") + } + if len(req.ExtParams) > 255 || len(req.ServiceRemark) > 255 { + return errs.InvalidParam.WithMsg("扩展参数/客服备注不得超过 255 字") + } + return nil +} + +// Create 创建通道(协议白名单 + code 唯一)。 +func (s *Service) Create(ctx context.Context, req *CreateReq) (*entity.ChannelChannel, error) { + req.Code = strings.TrimSpace(req.Code) + req.Protocol = strings.ToLower(strings.TrimSpace(req.Protocol)) + if !validProtocols[req.Protocol] { + return nil, errs.InvalidParam.WithMsg("协议仅支持 cmpp/http/sgip/smpp") + } + if err := s.validateExt(req); err != nil { + return nil, err + } + var n int64 + s.db.WithContext(ctx).Model(&entity.ChannelChannel{}).Where("code = ?", req.Code).Count(&n) + if n > 0 { + return nil, errs.InvalidParam.WithMsg(fmt.Sprintf("通道编码 %s 已存在", req.Code)) + } + if req.Weight <= 0 { + req.Weight = 1 + } + ch := &entity.ChannelChannel{ + Name: req.Name, Code: req.Code, Protocol: req.Protocol, + Host: req.Host, Port: req.Port, Username: req.Username, Password: req.Password, + Speed: req.Speed, ConnCount: req.ConnCount, UpstreamID: req.UpstreamID, + Priority: req.Priority, Weight: req.Weight, + IsDefault: req.IsDefault, Status: 1, Remark: req.Remark, + SpID: req.SpID, ProtocolVersion: req.ProtocolVersion, + HeartbeatInterval: req.HeartbeatInterval, ReconnectMax: req.ReconnectMax, + ServiceID: req.ServiceID, Carrier: req.Carrier, BillingLength: req.BillingLength, + PaymentType: req.PaymentType, BillingMode: req.BillingMode, Price: req.Price, + Category: req.Category, MOForwardChannelID: req.MOForwardChannelID, + NumberRule: req.NumberRule, CodeTruncate: req.CodeTruncate, + ExtParams: req.ExtParams, ServiceRemark: req.ServiceRemark, + } + if err := s.dao.Create(ctx, ch); err != nil { + return nil, err + } + return ch, nil +} + +// Update 白名单字段更新(code/protocol/status 不可改;status 走独立端点)。 +func (s *Service) Update(ctx context.Context, id int64, fields map[string]any) error { + allowed := map[string]bool{ + "name": true, "host": true, "port": true, "username": true, "password": true, + "speed": true, "priority": true, "weight": true, "remark": true, "is_default": true, + // 连接/拦截(Day 31 补:此前缺失导致前端表单全量提交被拒)。 + "conn_count": true, "upstream_id": true, "ext_length": true, "sign_mode": true, + "template_mode": true, "day_limit": true, "night_limit": true, + "black_keywords": true, "block_regions": true, + // 协议接入参数(Day 31)。 + "sp_id": true, "protocol_version": true, "heartbeat_interval": true, + "reconnect_max": true, "service_id": true, + // 运营属性(Day 31)。 + "carrier": true, "billing_length": true, "payment_type": true, "billing_mode": true, + "price": true, "category": true, "mo_forward_channel_id": true, "number_rule": true, + "code_truncate": true, "ext_params": true, "service_remark": true, + } + for k := range fields { + if !allowed[k] { + return errs.InvalidParam.WithMsg(fmt.Sprintf("不允许更新字段 %q", k)) + } + } + if v, ok := fields["sp_id"].(string); ok && len(strings.TrimSpace(v)) > 6 { + return errs.InvalidParam.WithMsg("企业代码(sp_id)不得超过 6 字节") + } + // 数值经 JSON 绑定为 float64,Go 调用方可能传 int/int64——统一归一化后校验。 + if v, ok := numField(fields, "protocol_version"); ok && v == 30 { + return errs.InvalidParam.WithMsg("CMPP 3.0 协议栈未实现(当前仅支持 2.0)") + } + res := s.db.WithContext(ctx).Model(&entity.ChannelChannel{}).Where("id = ?", id).Updates(fields) + if res.Error != nil { + return res.Error + } + if res.RowsAffected == 0 { + return errs.NotFound.WithMsg("通道不存在") + } + return nil +} + +// numField 归一化读取数值字段(float64/int/int64;JSON 与 Go 调用方两种来源)。 +func numField(fields map[string]any, key string) (float64, bool) { + switch v := fields[key].(type) { + case float64: + return v, true + case int: + return float64(v), true + case int64: + return float64(v), true + case int8: + return float64(v), true + default: + return 0, false + } +} + +// SetStatus 启用/停用。 +func (s *Service) SetStatus(ctx context.Context, id int64, status int8) error { + if status != 0 && status != 1 { + return errs.InvalidParam.WithMsg("状态仅 0/1") + } + res := s.db.WithContext(ctx).Model(&entity.ChannelChannel{}).Where("id = ?", id).Update("status", status) + if res.Error != nil { + return res.Error + } + if res.RowsAffected == 0 { + return errs.NotFound.WithMsg("通道不存在") + } + return nil +} + +// Get 详情(NotFound 语义化)。 +func (s *Service) Get(ctx context.Context, id int64) (*entity.ChannelChannel, error) { + ch, err := s.dao.GetByID(ctx, id) + if err != nil { + if stderrors.Is(err, mysql.ErrNotFound) { + return nil, errs.NotFound.WithMsg("通道不存在") + } + return nil, err + } + return ch, nil +} + +// ListQuery 列表过滤。 +type ListQuery struct { + Page, PageSize int + Name string + Protocol string + Status int8 // -1 不过滤 +} + +// List 分页列表(优先级倒序+id 倒序)。 +func (s *Service) List(ctx context.Context, q *ListQuery) ([]entity.ChannelChannel, int64, error) { + if q.Page <= 0 { + q.Page = 1 + } + if q.PageSize <= 0 || q.PageSize > 100 { + q.PageSize = 20 + } + tx := s.db.WithContext(ctx).Model(&entity.ChannelChannel{}) + if q.Name != "" { + tx = tx.Where("name LIKE ?", "%"+q.Name+"%") + } + if q.Protocol != "" { + tx = tx.Where("protocol = ?", q.Protocol) + } + if q.Status >= 0 { + tx = tx.Where("status = ?", q.Status) + } + var total int64 + if err := tx.Count(&total).Error; err != nil { + return nil, 0, err + } + var out []entity.ChannelChannel + if err := tx.Order("priority DESC").Order("id DESC"). + Offset((q.Page - 1) * q.PageSize).Limit(q.PageSize).Find(&out).Error; err != nil { + return nil, 0, err + } + return out, total, nil +} + +// Delete 删除(需先停用且不被组引用;Day 36 扩展引用守卫)。 +func (s *Service) Delete(ctx context.Context, id int64) error { + ch, err := s.Get(ctx, id) + if err != nil { + return err + } + if ch.Status != 0 { + return errs.InvalidParam.WithMsg("通道启用中,须先停用再删除") + } + if n := s.channelInUse(ctx, id); n > 0 { + return errs.InvalidParam.WithMsg(fmt.Sprintf("通道被 %d 个通道组引用,须先移除组成员", n)) + } + return s.dao.Delete(ctx, id) +} + +// ---- 测试工具(Day 35):发送单条测试短信验证连通性 ---- + +// TestResult 测试工具结果。 +type TestResult struct { + MessageID string `json:"message_id"` + Protocol string `json:"protocol"` + ElapsedMS int64 `json:"elapsed_ms"` +} + +// TestChannel 用指定通道真实发送一条测试短信,返回上游 MsgID。 +// 验收:测试工具发送通道返回正确 MsgID。 +// SubmitViaLink 单号链路提交(Day56 起返回各段 msg_id;兼容旧调用取 [0])。 +func (s *Service) SubmitViaLink(ctx context.Context, id int64, mobile, content string) ([]string, error) { + return s.links.SubmitViaLink(ctx, id, mobile, content) +} + +func (s *Service) TestChannel(ctx context.Context, id int64, mobile, content string) (*TestResult, error) { + ch, err := s.Get(ctx, id) + if err != nil { + return nil, err + } + if ch.Status != 1 { + return nil, errs.InvalidParam.WithMsg("通道已停用,无法测试") + } + start := time.Now() + var messageID string + switch ch.Protocol { + case "http": + resp, err := httpadapter.New(httpadapter.Config{ + Endpoint: ch.Host, AuthType: httpadapter.AuthNone, Timeout: 5 * time.Second, + }).Send(ctx, &httpadapter.SendReq{Mobile: mobile, Content: content}) + if err != nil { + return nil, err + } + messageID = resp.MessageID + case "cmpp": + // Day 31+:经常驻链路提交(未建链自动建立,连接保持——网关生成下发记录的必要条件; + // 回执经 OnDeliver 进环形缓冲/结构化日志)。原短连接工具逻辑由 linkManager 承接。 + mids, err := s.links.SubmitViaLink(ctx, id, mobile, content) + if err != nil { + return nil, err + } + if len(mids) > 0 { + messageID = mids[0] // 测试工具视图取首段(与历史展示口径一致) + } + case "sgip": + corpID := ch.SpID // 企业代码:优先 sp_id;空回退 username(历史兼容) + if corpID == "" { + corpID = ch.Username + } + spNumber := ch.Code // SP 接入码=通道号;空回退 username + if spNumber == "" { + spNumber = ch.Username + } + c := sgip.NewClient(sgip.Config{ + Addr: fmt.Sprintf("%s:%d", ch.Host, ch.Port), Name: ch.Username, Password: ch.Password, + NodeID: 1, Timeout: 5 * time.Second, + }) + if err := c.Connect(ctx); err != nil { + return nil, err + } + defer func() { _ = c.Close() }() + result, err := c.Submit(&sgip.SubmitReq{ + SPNumber: spNumber, UserNumbers: []string{mobile}, CorpID: corpID, + ServiceType: "TEST", Content: []byte(content), ReportFlag: 1, + }) + if err != nil { + return nil, err + } + if result != 0 { + return nil, errs.SendLimited.WithMsg(fmt.Sprintf("上游拒绝: result=%d", result)) + } + messageID = "sgip-ok" + case "smpp": + // 心跳周期映射 enquire_link(0 值由 smpp.Config.withDefaults 兜底 30s)。 + c := smpp.NewClient(smpp.Config{ + Addr: fmt.Sprintf("%s:%d", ch.Host, ch.Port), SystemID: ch.Username, Password: ch.Password, + WindowSize: 1, Timeout: 5 * time.Second, + HeartbeatInterval: time.Duration(ch.HeartbeatInterval) * time.Second, + }) + if err := c.Connect(ctx); err != nil { + return nil, err + } + defer func() { _ = c.Close() }() + srcAddr := ch.Code // 源地址=接入码;空回退 system_id + if srcAddr == "" { + srcAddr = ch.Username + } + mid, st, err := c.Submit(&smpp.SubmitReq{ + Source: smpp.Addr{Ton: 1, Npi: 1, Address: srcAddr}, + Dest: smpp.Addr{Ton: 1, Npi: 1, Address: mobile}, + ShortMessage: []byte(content), RegisteredDelivery: 1, + }) + if err != nil { + return nil, err + } + if st != smpp.StatusOK { + return nil, errs.SendLimited.WithMsg(fmt.Sprintf("上游拒绝: status=0x%08x", uint32(st))) + } + messageID = mid + default: + return nil, errs.InvalidParam.WithMsg("未知协议 " + ch.Protocol) + } + return &TestResult{MessageID: messageID, Protocol: ch.Protocol, ElapsedMS: time.Since(start).Milliseconds()}, nil +} + +// ---- 拦截配置(Day 35):夜发/日限/屏蔽地区 ---- + +// InterceptConfig 拦截配置视图。 +type InterceptConfig struct { + NightLimit int `json:"night_limit"` // >0 开启夜发拦截(22:00-08:00 禁发) + DayLimit int `json:"day_limit"` // >0 每日上限;超出 result=-3 + BlockRegions string `json:"block_regions"` // 逗号分隔地区(前缀命中) + BlackKeywords string `json:"black_keywords"` // 展示(命中逻辑在 Day 42 拦截器链) +} + +// GetIntercept 查询拦截配置。 +func (s *Service) GetIntercept(ctx context.Context, id int64) (*InterceptConfig, error) { + ch, err := s.Get(ctx, id) + if err != nil { + return nil, err + } + return &InterceptConfig{ + NightLimit: ch.NightLimit, DayLimit: ch.DayLimit, + BlockRegions: ch.BlockRegions, BlackKeywords: ch.BlackKeywords, + }, nil +} + +// SetIntercept 设置拦截配置。 +func (s *Service) SetIntercept(ctx context.Context, id int64, cfg *InterceptConfig) error { + if len(cfg.BlockRegions) > 512 { + return errs.InvalidParam.WithMsg("屏蔽地区列表过长(≤512)") + } + res := s.db.WithContext(ctx).Model(&entity.ChannelChannel{}).Where("id = ?", id).Updates(map[string]any{ + "night_limit": cfg.NightLimit, "day_limit": cfg.DayLimit, "block_regions": cfg.BlockRegions, + }) + if res.Error != nil { + return res.Error + } + if res.RowsAffected == 0 { + return errs.NotFound.WithMsg("通道不存在") + } + return nil +} + +// InterceptVerdict 拦截判定。 +type InterceptVerdict struct { + Blocked bool + Result int8 // 见 Result* 常量 + Reason string +} + +// CheckIntercept 判定是否拦截(顺序:夜发→地区→日限;now 注入便于测试)。 +// 验收:拦截三配置生效;日限超出返回 -3。 +func (s *Service) CheckIntercept(ch *entity.ChannelChannel, region string, now time.Time) InterceptVerdict { + if ch.NightLimit > 0 && isNight(now) { + return InterceptVerdict{Blocked: true, Result: ResultNightBlock, + Reason: "夜发时段禁止发送(22:00-08:00)"} + } + if region != "" && ch.BlockRegions != "" { + for _, r := range strings.Split(ch.BlockRegions, ",") { + r = strings.TrimSpace(r) + if r != "" && (r == region || strings.HasPrefix(region, r)) { + return InterceptVerdict{Blocked: true, Result: ResultRegionHit, + Reason: "命中屏蔽地区: " + region} + } + } + } + if ch.DayLimit > 0 { + if s.TodayCount(ch.ID) >= ch.DayLimit { + return InterceptVerdict{Blocked: true, Result: ResultDayLimit, + Reason: fmt.Sprintf("超出日限 %d(今日已发 %d)", ch.DayLimit, s.TodayCount(ch.ID))} + } + } + return InterceptVerdict{} +} + +// IncrDayCount 放行后计数。 +func (s *Service) IncrDayCount(channelID int64) int { + s.mu.Lock() + defer s.mu.Unlock() + today := time.Now().Format("2006-01-02") + c, ok := s.dayCnt[channelID] + if !ok || c.date != today { + c = &dayCounter{date: today} + s.dayCnt[channelID] = c + } + c.n++ + return c.n +} + +// TodayCount 当日已发数。 +func (s *Service) TodayCount(channelID int64) int { + s.mu.Lock() + defer s.mu.Unlock() + today := time.Now().Format("2006-01-02") + if c, ok := s.dayCnt[channelID]; ok && c.date == today { + return c.n + } + return 0 +} + +// isNight 夜间时段判定(22:00-08:00,跨越零点)。 +func isNight(t time.Time) bool { + h := t.Hour() + return h >= 22 || h < 8 +} diff --git a/internal/service/channel/service_test.go b/internal/service/channel/service_test.go new file mode 100644 index 00000000..875576af --- /dev/null +++ b/internal/service/channel/service_test.go @@ -0,0 +1,520 @@ +// service_test.go Day 35:通道 CRUD/拦截三配置/测试工具。 +package channel + +import ( + "context" + "encoding/json" + "net" + "net/http" + "net/http/httptest" + "testing" + "time" + + "github.com/glebarez/sqlite" + "gorm.io/gorm" + + "go-sms/internal/model/entity" + "go-sms/internal/protocol/cmpp" + "go-sms/internal/protocol/sgip" + "go-sms/internal/protocol/smpp" +) + +func newSvc35(t *testing.T) *Service { + 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) + } + if err := db.AutoMigrate(&entity.ChannelChannel{}, &entity.ChannelLog{}, &entity.SystemAlertRule{}); err != nil { + t.Fatal(err) + } + s := NewService(db) + t.Cleanup(s.Close) // Day 40:冲刷通道日志 writer,防 goroutine/连接泄漏 + return s +} + +// TestChannelCRUD 验收:CRUD 全量(协议白名单/code 唯一/白名单更新/启停/删除守卫/过滤)。 +func TestChannelCRUD(t *testing.T) { + s := newSvc35(t) + ctx := context.Background() + // 非法协议拒绝 + if _, err := s.Create(ctx, &CreateReq{Name: "x", Code: "c1", Protocol: "ftp", Host: "h"}); err == nil { + t.Fatal("非法协议应拒绝") + } + ch, err := s.Create(ctx, &CreateReq{Name: "移动一", Code: "cmpp-1", Protocol: "CMPP", + Host: "127.0.0.1", Port: 7890, Username: "901234", Password: "pw", Weight: 3}) + if err != nil { + t.Fatal(err) + } + if ch.Status != 1 || ch.Protocol != "cmpp" || ch.Weight != 3 { + t.Fatalf("创建字段: %+v", ch) + } + // 重复 code + if _, err := s.Create(ctx, &CreateReq{Name: "y", Code: "cmpp-1", Protocol: "http", Host: "h"}); err == nil { + t.Fatal("重复 code 应拒绝") + } + // 更新白名单与越权字段 + if err := s.Update(ctx, ch.ID, map[string]any{"name": "移动一改", "speed": 100}); err != nil { + t.Fatal(err) + } + if err := s.Update(ctx, ch.ID, map[string]any{"code": "hack"}); err == nil { + t.Fatal("code 不可更新") + } + // 列表过滤 + ch2, _ := s.Create(ctx, &CreateReq{Name: "联通 HTTP", Code: "http-1", Protocol: "http", Host: "http://x"}) + list, total, err := s.List(ctx, &ListQuery{Protocol: "http", Status: -1}) + if err != nil || total != 1 || list[0].ID != ch2.ID { + t.Fatalf("过滤: total=%d err=%v", total, err) + } + // 删除守卫:启用中拒删 + if err := s.Delete(ctx, ch.ID); err == nil { + t.Fatal("启用中应拒删") + } + if err := s.SetStatus(ctx, ch.ID, 0); err != nil { + t.Fatal(err) + } + if err := s.Delete(ctx, ch.ID); err != nil { + t.Fatal(err) + } + if _, err := s.Get(ctx, ch.ID); err == nil { + t.Fatal("删除后应 404") + } + if err := s.SetStatus(ctx, 999, 1); err == nil { + t.Fatal("不存在应 404") + } +} + +// mustCreateCh 建通道并断言。 +func mustCreateCh(t *testing.T, s *Service, code string) *entity.ChannelChannel { + t.Helper() + ch, err := s.Create(context.Background(), &CreateReq{ + Name: code, Code: code, Protocol: "http", Host: "http://upstream", Weight: 1}) + if err != nil { + t.Fatal(err) + } + return ch +} + +// TestIntercept 验收:拦截三配置生效(夜发/日限 -3/屏蔽地区)。 +func TestIntercept(t *testing.T) { + s := newSvc35(t) + ctx := context.Background() + ch := mustCreateCh(t, s, "ic-1") + // 配置:夜发开/日限 2/屏蔽 新疆,西藏 + if err := s.SetIntercept(ctx, ch.ID, &InterceptConfig{ + NightLimit: 1, DayLimit: 2, BlockRegions: "新疆,西藏"}); err != nil { + t.Fatal(err) + } + cfg, _ := s.GetIntercept(ctx, ch.ID) + if cfg.DayLimit != 2 || cfg.BlockRegions != "新疆,西藏" { + t.Fatalf("配置回读: %+v", cfg) + } + ch, _ = s.Get(ctx, ch.ID) // 刷新实体(CheckIntercept 读内存快照) + noon := time.Date(2026, 9, 4, 12, 0, 0, 0, time.Local) + night := time.Date(2026, 9, 4, 23, 0, 0, 0, time.Local) + // ① 夜发拦截(23:00) + if v := s.CheckIntercept(ch, "北京", night); !v.Blocked || v.Result != ResultNightBlock { + t.Fatalf("夜发: %+v", v) + } + // ② 屏蔽地区(正午,新疆命中) + if v := s.CheckIntercept(ch, "新疆", noon); !v.Blocked || v.Result != ResultRegionHit { + t.Fatalf("地区: %+v", v) + } + if v := s.CheckIntercept(ch, "西藏拉萨", noon); !v.Blocked { // 前缀命中 + t.Fatalf("前缀地区: %+v", v) + } + // ③ 日限:放行计数 2 次后第 3 次 -3 + if v := s.CheckIntercept(ch, "北京", noon); v.Blocked { + t.Fatalf("未超限应放行: %+v", v) + } + s.IncrDayCount(ch.ID) + s.IncrDayCount(ch.ID) + v := s.CheckIntercept(ch, "北京", noon) + if !v.Blocked || v.Result != ResultDayLimit || v.Reason == "" { + t.Fatalf("日限应 -3: %+v", v) + } + // 未配置(新通道)全部放行 + ch2 := mustCreateCh(t, s, "ic-2") + if v := s.CheckIntercept(ch2, "新疆", night); v.Blocked { + t.Fatalf("未配置应放行: %+v", v) + } + if err := s.SetIntercept(ctx, ch2.ID, &InterceptConfig{BlockRegions: string(make([]byte, 600))}); err == nil { + t.Fatal("超长应拒绝") + } +} + +// TestTestChannelHTTP 验收:测试工具经 http 通道返回正确 MsgID。 +func TestTestChannelHTTP(t *testing.T) { + up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + _ = json.NewEncoder(w).Encode(map[string]any{"code": 0, "msg": "ok", + "data": map[string]string{"message_id": "up-88"}}) + })) + defer up.Close() + s := newSvc35(t) + ctx := context.Background() + ch, _ := s.Create(ctx, &CreateReq{Name: "t", Code: "http-t", Protocol: "http", Host: up.URL}) + res, err := s.TestChannel(ctx, ch.ID, "13800001111", "测试短信") + if err != nil { + t.Fatal(err) + } + if res.MessageID != "up-88" || res.Protocol != "http" || res.ElapsedMS < 0 { + t.Fatalf("测试工具: %+v", res) + } + // 停用通道不可测 + _ = s.SetStatus(ctx, ch.ID, 0) + if _, err := s.TestChannel(ctx, ch.ID, "1", "x"); err == nil { + t.Fatal("停用应拒") + } + if _, err := s.TestChannel(ctx, 99, "1", "x"); err == nil { + t.Fatal("不存在应 404") + } +} + +// netListen/portOf mini 网关辅助。 +func netListen() (net.Listener, error) { return net.Listen("tcp", "127.0.0.1:0") } +func portOf(ln net.Listener) int { return ln.Addr().(*net.TCPAddr).Port } + +// listenMiniCMPP 起一个仅处理 connect/submit/active 的迷你网关(复用 cmpp 编解码)。 +// serveMiniConn 单连接处理循环(connect/submit/active_test 三响应)。 +func serveMiniConn(conn net.Conn) { + defer func() { _ = conn.Close() }() + for { + h, body, err := cmpp.ReadPacket(conn) + if err != nil { + return + } + switch h.CommandID { + case cmpp.CmdConnect: + addr, auth, ts, _ := cmpp.ParseConnect(body) + st := byte(0) + if !cmpp.VerifyAuth(addr, "pw", ts, auth) { + st = 1 + } + resp := &cmpp.ConnectResp{Status: st, Secret: "pw", AuthenticatorClient: auth} + _ = cmpp.WritePacket(conn, &cmpp.Header{CommandID: cmpp.CmdConnectResp, SequenceID: h.SequenceID}, resp.Marshal()) + case cmpp.CmdSubmit: + _ = cmpp.WritePacket(conn, &cmpp.Header{CommandID: cmpp.CmdSubmitResp, SequenceID: h.SequenceID}, + (&cmpp.SubmitResp{MsgID: 777, Result: 0}).Marshal()) + case cmpp.CmdActiveTest: + _ = cmpp.WritePacket(conn, &cmpp.Header{CommandID: cmpp.CmdActiveTestResp, SequenceID: h.SequenceID}, cmpp.ActiveTestResp(0)) + } + } +} + +// serveMiniCMPP 在给定 listener 上跑迷你 CMPP 网关 accept 循环 +// (Day 40 抽出:断线重连演练需在「同端口」重启网关复用此循环)。 +func serveMiniCMPP(ln net.Listener) { + for { + conn, err := ln.Accept() + if err != nil { + return + } + go serveMiniConn(conn) + } +} + +func listenMiniCMPP(t *testing.T) (net.Listener, error) { + t.Helper() + ln, err := netListen() + if err != nil { + return nil, err + } + go serveMiniCMPP(ln) + t.Cleanup(func() { _ = ln.Close() }) + return ln, nil +} + +// TestTestChannelFailures 失败分支(http 上游 5xx/协议连接失败)。 +func TestTestChannelFailures(t *testing.T) { + up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusInternalServerError) + })) + defer up.Close() + s := newSvc35(t) + ctx := context.Background() + // http 5xx + ch, _ := s.Create(ctx, &CreateReq{Name: "e", Code: "http-e", Protocol: "http", Host: up.URL}) + if _, err := s.TestChannel(ctx, ch.ID, "1", "x"); err == nil { + t.Fatal("上游 5xx 应报错") + } + // sgip 连接失败(端口不可达) + sg, _ := s.Create(ctx, &CreateReq{Name: "s", Code: "sgip-e", Protocol: "sgip", Host: "127.0.0.1", Port: 1}) + if _, err := s.TestChannel(ctx, sg.ID, "1", "x"); err == nil { + t.Fatal("sgip 连接失败应报错") + } + // smpp 连接失败 + sm, _ := s.Create(ctx, &CreateReq{Name: "m", Code: "smpp-e", Protocol: "smpp", Host: "127.0.0.1", Port: 1}) + if _, err := s.TestChannel(ctx, sm.ID, "1", "x"); err == nil { + t.Fatal("smpp 连接失败应报错") + } + // cmpp 连接失败 + cp, _ := s.Create(ctx, &CreateReq{Name: "c", Code: "cmpp-e", Protocol: "cmpp", Host: "127.0.0.1", Port: 1}) + if _, err := s.TestChannel(ctx, cp.ID, "1", "x"); err == nil { + t.Fatal("cmpp 连接失败应报错") + } +} + +// TestTestChannelSGIPAndSMPP 测试工具经 sgip/smpp 通道连迷你网关。 +func TestTestChannelSGIPAndSMPP(t *testing.T) { + s := newSvc35(t) + ctx := context.Background() + // mini SGIP 网关(bind/submit) + lnS, _ := net.Listen("tcp", "127.0.0.1:0") + go serveSGIP(lnS) + t.Cleanup(func() { _ = lnS.Close() }) + sg, _ := s.Create(ctx, &CreateReq{Name: "sg", Code: "sgip-t", Protocol: "sgip", + Host: "127.0.0.1", Port: portOf(lnS), Username: "sp001", Password: "pw123"}) + if res, err := s.TestChannel(ctx, sg.ID, "13100002222", "x"); err != nil || res.MessageID == "" { + t.Fatalf("sgip: res=%+v err=%v", res, err) + } + // mini SMPP 网关(bind/submit) + lnM, _ := net.Listen("tcp", "127.0.0.1:0") + go serveSMPP(lnM) + t.Cleanup(func() { _ = lnM.Close() }) + sm, _ := s.Create(ctx, &CreateReq{Name: "sm", Code: "smpp-t", Protocol: "smpp", + Host: "127.0.0.1", Port: portOf(lnM), Username: "esme1", Password: "pw123"}) + if res, err := s.TestChannel(ctx, sm.ID, "13100002222", "x"); err != nil || res.MessageID == "" { + t.Fatalf("smpp: res=%+v err=%v", res, err) + } +} + +// serveSGIP 迷你 SGIP 网关。 +func serveSGIP(ln net.Listener) { + for { + conn, err := ln.Accept() + if err != nil { + return + } + go func() { + defer func() { _ = conn.Close() }() + for { + h, body, err := sgip.ReadPacket(conn) + if err != nil { + return + } + switch h.CommandID { + case sgip.CmdBind: + name, pw, _ := sgip.ParseBind(body) + r := uint8(0) + if name != "sp001" || pw != "pw123" { + r = 1 + } + _ = sgip.WritePacket(conn, &sgip.Header{CommandID: sgip.CmdBindResp, Sequence: h.Sequence}, sgip.MakeResultBody(r)) + case sgip.CmdSubmit: + _ = sgip.WritePacket(conn, &sgip.Header{CommandID: sgip.CmdSubmitResp, Sequence: h.Sequence}, sgip.MakeResultBody(0)) + } + } + }() + } +} + +// serveSMPP 迷你 SMPP 网关。 +func serveSMPP(ln net.Listener) { + for { + conn, err := ln.Accept() + if err != nil { + return + } + go func() { + defer func() { _ = conn.Close() }() + for { + h, body, err := smpp.ReadPDU(conn) + if err != nil { + return + } + switch h.CommandID { + case smpp.CmdBindTransceiver: + sid, pw, _, _ := smpp.ParseBind(body) + st := smpp.StatusOK + if sid != "esme1" || pw != "pw123" { + st = smpp.StatusBindFail + } + _ = smpp.WritePDU(conn, &smpp.Header{CommandID: smpp.CmdBindTransceiverResp, SequenceNo: h.SequenceNo, Status: st}, smpp.BindResp("mini")) + case smpp.CmdSubmitSM: + _ = smpp.WritePDU(conn, &smpp.Header{CommandID: smpp.CmdSubmitSMResp, SequenceNo: h.SequenceNo, Status: smpp.StatusOK}, smpp.SubmitResp("mini-1")) + case smpp.CmdEnquireLink: + _ = smpp.WritePDU(conn, &smpp.Header{CommandID: smpp.CmdEnquireLinkResp, SequenceNo: h.SequenceNo, Status: smpp.StatusOK}, nil) + } + } + }() + } +} + +// TestTestChannelCMPP 测试工具经 cmpp 通道连模拟网关,返回上游 MsgID。 +func TestTestChannelCMPP(t *testing.T) { + ln, err := listenMiniCMPP(t) + if err != nil { + t.Fatal(err) + } + s := newSvc35(t) + ctx := context.Background() + ch, _ := s.Create(ctx, &CreateReq{Name: "c", Code: "cmpp-t", Protocol: "cmpp", + Host: "127.0.0.1", Port: portOf(ln), Username: "901234", Password: "pw"}) + res, err := s.TestChannel(ctx, ch.ID, "13800001111", "hi") + if err != nil { + t.Fatal(err) + } + if res.MessageID == "" || res.Protocol != "cmpp" { + t.Fatalf("cmpp 测试: %+v", res) + } +} + +// TestCreateExtValidation Day 31:扩展字段校验(sp_id 长度/CMPP3.0 拒绝/版本缺省填充/运营属性白名单)。 +func TestCreateExtValidation(t *testing.T) { + s := newSvc35(t) + ctx := context.Background() + base := func() *CreateReq { + return &CreateReq{Name: "x", Code: "ext-", Protocol: "cmpp", Host: "127.0.0.1"} + } + // sp_id > 6 字节拒绝。 + r := base() + r.Code = "ext-sp" + r.SpID = "1234567" + if _, err := s.Create(ctx, r); err == nil { + t.Fatal("sp_id 超 6 字节应拒绝") + } + // CMPP 3.0 拒绝(协议栈未实现)。 + r = base() + r.Code = "ext-v30" + r.ProtocolVersion = 30 + if _, err := s.Create(ctx, r); err == nil { + t.Fatal("CMPP 3.0 应拒绝") + } + // 运营商非法。 + r = base() + r.Code = "ext-carrier" + r.Carrier = "cmcc,telecom" + if _, err := s.Create(ctx, r); err == nil { + t.Fatal("非法运营商应拒绝") + } + // 付款/计费方式白名单。 + r = base() + r.Code = "ext-pay" + r.PaymentType = "free" + if _, err := s.Create(ctx, r); err == nil { + t.Fatal("非法付款方式应拒绝") + } + r = base() + r.Code = "ext-mode" + r.BillingMode = "half" + if _, err := s.Create(ctx, r); err == nil { + t.Fatal("非法计费方式应拒绝") + } + // 负价格。 + r = base() + r.Code = "ext-price" + r.Price = -0.01 + if _, err := s.Create(ctx, r); err == nil { + t.Fatal("负价格应拒绝") + } +} + +// TestCreateExtPersist Day 31:扩展字段持久化与回显 + 版本/心跳/计费长度缺省填充。 +func TestCreateExtPersist(t *testing.T) { + s := newSvc35(t) + ctx := context.Background() + ch, err := s.Create(ctx, &CreateReq{ + Name: "全字段", Code: "ext-full", Protocol: "cmpp", Host: "10.0.0.1", Port: 7890, + SpID: "901234", ServiceID: "SVC01", Speed: 200, + Carrier: "cmcc,cucc", PaymentType: "prepay_monthly", BillingMode: "success_unknown", + Price: 0.05, Category: "验证码", MOForwardChannelID: 0, NumberRule: 1, CodeTruncate: 3, + ExtParams: "k=v", ServiceRemark: "客服", + }) + if err != nil { + t.Fatal(err) + } + got, _ := s.Get(ctx, ch.ID) + if got.SpID != "901234" || got.ProtocolVersion != 20 || got.HeartbeatInterval != 30 || + got.ReconnectMax != 30 || got.ServiceID != "SVC01" { + t.Fatalf("协议接入参数: %+v", got) + } + if got.Carrier != "cmcc,cucc" || got.BillingLength != 70 || + got.PaymentType != "prepay_monthly" || got.BillingMode != "success_unknown" || + got.Price != 0.05 || got.Category != "验证码" || got.NumberRule != 1 || + got.CodeTruncate != 3 || got.ExtParams != "k=v" || got.ServiceRemark != "客服" { + t.Fatalf("运营属性: %+v", got) + } + // sgip/smpp 版本固定。 + sg, _ := s.Create(ctx, &CreateReq{Name: "s", Code: "ext-sg", Protocol: "sgip", Host: "h"}) + sm, _ := s.Create(ctx, &CreateReq{Name: "m", Code: "ext-sm", Protocol: "smpp", Host: "h"}) + if sg.ProtocolVersion != 12 || sm.ProtocolVersion != 34 { + t.Fatalf("版本填充: sgip=%d smpp=%d", sg.ProtocolVersion, sm.ProtocolVersion) + } +} + +// TestUpdateWhitelistExt Day 31:Update 白名单扩列 + sp_id/3.0 纵深防御。 +func TestUpdateWhitelistExt(t *testing.T) { + s := newSvc35(t) + ctx := context.Background() + ch := mustCreateCh(t, s, "ext-upd") + // 原缺失字段现可更新(修复:前端表单全量提交被拒)。 + if err := s.Update(ctx, ch.ID, map[string]any{"conn_count": 4, "day_limit": 100, "night_limit": 1}); err != nil { + t.Fatal(err) + } + if err := s.Update(ctx, ch.ID, map[string]any{ + "sp_id": "901234", "heartbeat_interval": 60, "reconnect_max": 60, + "carrier": "cmcc", "billing_length": 67, "price": 0.04, "category": "营销", + "mo_forward_channel_id": 0, "number_rule": 2, "code_truncate": 2, + "ext_params": "a=b", "service_remark": "r", "service_id": "SVC", + "payment_type": "prepay_realtime", "billing_mode": "success", + }); err != nil { + t.Fatal(err) + } + got, _ := s.Get(ctx, ch.ID) + if got.SpID != "901234" || got.HeartbeatInterval != 60 || got.Carrier != "cmcc" || + got.BillingLength != 67 || got.Price != 0.04 || got.Category != "营销" { + t.Fatalf("更新回读: %+v", got) + } + // 越权字段仍拒绝。 + if err := s.Update(ctx, ch.ID, map[string]any{"code": "hack"}); err == nil { + t.Fatal("code 不可更新") + } + // sp_id 超长/CMPP3.0 纵深防御。 + if err := s.Update(ctx, ch.ID, map[string]any{"sp_id": "1234567"}); err == nil { + t.Fatal("Update sp_id 超 6 字节应拒绝") + } + if err := s.Update(ctx, ch.ID, map[string]any{"protocol_version": 30}); err == nil { + t.Fatal("Update CMPP 3.0 应拒绝") + } +} + +// TestTestChannelCMPPSpID Day 31:SourceAddr 优先取 sp_id(网关密钥 pw 校验鉴别)。 +// 迷你网关以 VerifyAuth(addr,"pw") 鉴别:sp_id=901234/username=other,仅当映射正确才能登录成功。 +func TestTestChannelCMPPSpID(t *testing.T) { + ln, err := listenMiniCMPP(t) + if err != nil { + t.Fatal(err) + } + s := newSvc35(t) + ctx := context.Background() + ch, err := s.Create(ctx, &CreateReq{ + Name: "sp", Code: "10690", Protocol: "cmpp", Host: "127.0.0.1", Port: portOf(ln), + SpID: "901234", Username: "other", Password: "pw", ServiceID: "MYSVC", + HeartbeatInterval: 45, ReconnectMax: 60, + }) + if err != nil { + t.Fatal(err) + } + if res, err := s.TestChannel(ctx, ch.ID, "13800001111", "hi"); err != nil || res.MessageID == "" { + t.Fatalf("sp_id 映射失败(应为 SourceAddr=901234): res=%+v err=%v", res, err) + } +} + +// TestTestChannelCMPPV30Defense Day 31:直插 3.0 实体,测试工具纵深防御拒绝。 +func TestTestChannelCMPPV30Defense(t *testing.T) { + s := newSvc35(t) + ctx := context.Background() + raw := &entity.ChannelChannel{ + Name: "v30", Code: "cmpp-v30", Protocol: "cmpp", Host: "127.0.0.1", Port: 1, + Status: 1, ProtocolVersion: 30, + } + if err := s.db.Create(raw).Error; err != nil { + t.Fatal(err) + } + if _, err := s.TestChannel(ctx, raw.ID, "13800001111", "hi"); err == nil { + t.Fatal("CMPP 3.0 测试工具应拒绝") + } +} diff --git a/internal/service/channel/upstream.go b/internal/service/channel/upstream.go new file mode 100644 index 00000000..3728087d --- /dev/null +++ b/internal/service/channel/upstream.go @@ -0,0 +1,111 @@ +// upstream.go Day 41(清债③):上家(通道方)管理 API——前端 FE-1 UpstreamList.vue +// 早已调用 /channels/upstreams 四端点,后端此前缺位(Day 39 双轨复盘发现),本文件补齐。 +package channel + +import ( + "context" + + "gorm.io/gorm" + + "go-sms/internal/model/entity" + errs "go-sms/internal/pkg/errors" + "go-sms/internal/repository/mysql" +) + +// UpstreamService 上家服务(独立小服务,不侵入主 Service;与通道表唯一关联=引用守卫)。 +type UpstreamService struct { + db *gorm.DB + dao *mysql.BaseDAO[*entity.ChannelUpstream] +} + +// NewUpstreamService 构造(db nil 仅测试防御,正常装配必传)。 +func NewUpstreamService(db *gorm.DB) *UpstreamService { + return &UpstreamService{db: db, dao: mysql.NewBaseDAO[*entity.ChannelUpstream](db)} +} + +// UpstreamQuery 列表过滤。 +type UpstreamQuery struct { + Page, PageSize int + Name string + Status int8 // -1 不过滤(零值 0=只看停用;HTTP 层缺省已转 -1,调用方须显式传) +} + +// List 分页(id 倒序;name 模糊)。 +func (s *UpstreamService) List(ctx context.Context, q *UpstreamQuery) ([]entity.ChannelUpstream, int64, error) { + if q.Page <= 0 { + q.Page = 1 + } + if q.PageSize <= 0 || q.PageSize > 100 { + q.PageSize = 20 + } + tx := s.db.WithContext(ctx).Model(&entity.ChannelUpstream{}) + if q.Name != "" { + tx = tx.Where("name LIKE ?", "%"+q.Name+"%") + } + if q.Status >= 0 { + tx = tx.Where("status = ?", q.Status) + } + var total int64 + if err := tx.Count(&total).Error; err != nil { + return nil, 0, err + } + var out []entity.ChannelUpstream + if err := tx.Order("id DESC").Offset((q.Page - 1) * q.PageSize).Limit(q.PageSize).Find(&out).Error; err != nil { + return nil, 0, err + } + return out, total, nil +} + +// Create 新建(name 必填唯一)。 +func (s *UpstreamService) Create(ctx context.Context, u *entity.ChannelUpstream) (*entity.ChannelUpstream, error) { + if u.Name == "" { + return nil, errs.InvalidParam.WithMsg("上家名称必填") + } + var n int64 + if err := s.db.WithContext(ctx).Model(&entity.ChannelUpstream{}).Where("name = ?", u.Name).Count(&n).Error; err != nil { + return nil, err + } + if n > 0 { + return nil, errs.InvalidParam.WithMsg("上家名称已存在") + } + if err := s.dao.Create(ctx, u); err != nil { + return nil, err + } + return u, nil +} + +// Update 部分更新(白名单字段;名称改重需守卫)。 +func (s *UpstreamService) Update(ctx context.Context, id int64, fields map[string]any) error { + allowed := map[string]bool{"name": true, "contact": true, "phone": true, "category": true, "status": true, "remark": true} + ups := map[string]any{} + for k, v := range fields { + if allowed[k] { + ups[k] = v + } + } + if len(ups) == 0 { + return errs.InvalidParam.WithMsg("无可更新字段") + } + if name, ok := ups["name"].(string); ok && name != "" { + var n int64 + if err := s.db.WithContext(ctx).Model(&entity.ChannelUpstream{}).Where("name = ? AND id <> ?", name, id).Count(&n).Error; err != nil { + return err + } + if n > 0 { + return errs.InvalidParam.WithMsg("上家名称已存在") + } + } + return s.db.WithContext(ctx).Model(&entity.ChannelUpstream{}).Where("id = ?", id).Updates(ups).Error +} + +// Delete 删除(被通道引用则拒绝——与通道删除守卫同口径)。 +func (s *UpstreamService) Delete(ctx context.Context, id int64) error { + var n int64 + if err := s.db.WithContext(ctx).Model(&entity.ChannelChannel{}).Where("upstream_id = ?", id).Count(&n).Error; err != nil { + return err + } + if n > 0 { + return errs.InvalidParam.WithMsg("被通道引用,须先解除通道关联") + } + return s.dao.Delete(ctx, id) +} diff --git a/internal/service/channel/upstream_test.go b/internal/service/channel/upstream_test.go new file mode 100644 index 00000000..7ed8f249 --- /dev/null +++ b/internal/service/channel/upstream_test.go @@ -0,0 +1,80 @@ +// upstream_test.go Day 41(清债③):上家 CRUD——名称唯一/白名单更新/引用守卫删除。 +package channel + +import ( + "context" + "testing" + + "github.com/glebarez/sqlite" + "gorm.io/gorm" + + "go-sms/internal/model/entity" +) + +func newUpstreamSvc(t *testing.T) *UpstreamService { + 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) // :memory: 多连接=多个空库(同 newSvc35) + } + if err := db.AutoMigrate(&entity.ChannelUpstream{}, &entity.ChannelChannel{}); err != nil { + t.Fatal(err) + } + return NewUpstreamService(db) +} + +func TestUpstreamCRUD(t *testing.T) { + s := newUpstreamSvc(t) + ctx := context.Background() + + // 空名拒绝 + if _, err := s.Create(ctx, &entity.ChannelUpstream{}); err == nil { + t.Fatal("空名应拒绝") + } + u, err := s.Create(ctx, &entity.ChannelUpstream{Name: "移动集团", Contact: "张三", Phone: "13800000000", Category: "运营商"}) + if err != nil { + t.Fatal(err) + } + // 名称唯一 + if _, err := s.Create(ctx, &entity.ChannelUpstream{Name: "移动集团"}); err == nil { + t.Fatal("重名应拒绝") + } + // 列表过滤 + u2, err := s.Create(ctx, &entity.ChannelUpstream{Name: "联信通", Category: "代理商"}) + if err != nil { + t.Fatal("联信通创建失败:", err) + } + list, total, err := s.List(ctx, &UpstreamQuery{Name: "移动", Status: -1}) + if err != nil || total != 1 || len(list) != 1 || list[0].ID != u.ID { + t.Fatalf("过滤失败: total=%d err=%v", total, err) + } + // 白名单更新(名字改重拒绝;非法字段忽略) + if err := s.Update(ctx, u2.ID, map[string]any{"name": "移动集团"}); err == nil { + t.Fatal("改重名应拒绝") + } + if err := s.Update(ctx, u2.ID, map[string]any{"contact": "李四", "id": 999, "created_at": "hack"}); err != nil { + t.Fatal(err) + } + got, _, _ := s.List(ctx, &UpstreamQuery{Status: -1}) + if got[0].ID != u2.ID || got[0].Contact != "李四" || got[0].ID == 999 { + t.Fatalf("白名单更新失败: %+v", got[0]) + } + // 引用守卫:通道挂上游后不可删 + if err := s.db.Create(&entity.ChannelChannel{Name: "c1", Code: "cd1", Protocol: "http", UpstreamID: u.ID}).Error; err != nil { + t.Fatal(err) + } + if err := s.Delete(ctx, u.ID); err == nil { + t.Fatal("被引用应拒绝删除") + } + // 解除引用后可删 + s.db.Model(&entity.ChannelChannel{}).Where("id = ?", 1).Update("upstream_id", 0) + if err := s.Delete(ctx, u.ID); err != nil { + t.Fatal(err) + } + if _, total, _ := s.List(ctx, &UpstreamQuery{Status: -1}); total != 1 { + t.Fatalf("删除后应剩 1,得 %d", total) + } +}