Files
go-sms-V2/internal/service/send/dispatch/aggregator.go
T

234 lines
7.2 KiB
Go

// aggregator.go Day 47:合包聚合器(技术方案 6.3 CMPPSubmitAggregator)。
// 通道+内容 相同的明细聚合为批:满 maxBatch(1000)立即 flush,或窗口(5s)到期统一
// flush——同批一次批量提交(CMPP 单包 ≤100 号码,由通道层切包),显著降低
// 提交调用次数(验收口径:较逐号提交减少 ≥80%)。
package dispatch
import (
"context"
"go-sms/internal/service/send/submit"
"strconv"
"sync"
"sync/atomic"
"time"
"go-sms/internal/pkg/logger"
"go-sms/internal/service/channel/pool"
"go.uber.org/zap"
"gorm.io/gorm"
)
// AggregatorDefaults 默认参数(与开发计划 Day47 对齐:5s/1000 条)。
const (
DefaultAggrWindow = 5 * time.Second
DefaultAggrMaxBatch = 1000
)
// aggrGroup 聚合组(同通道+同内容)。
type aggrGroup struct {
channelID int64
content string
items []aggrItem
}
// aggrItem 单条待发明细。
type aggrItem struct {
detailID int64
mobile string
}
// BatchLinkSubmitter 批量链路提交(channel.linkManager 实现;聚合器出口)。
// 未实现时聚合器退化为逐号提交(行为兼容,聚合收益归零)。
// Day 56:返回「包×片」级 acks(每片独立 msg_id+包内号码+段序/总段数),
// flushGroup 据此逐段登记 message_report_seg 供回执段级配对。
type BatchLinkSubmitter interface {
SubmitBatchViaLink(ctx context.Context, channelID int64, mobiles []string, content string) ([]pool.BatchAck, error)
}
// SubmitAggregator 合包聚合器。
type SubmitAggregator struct {
lk LinkSubmitter
db *gorm.DB // Day 56:seg 配对登记落库(nil=跳过,纯内存测试场景)
window time.Duration
maxBatch int
mark func(ctx context.Context, ids []int64, status int8, channelID int64, errCode string)
mu sync.Mutex
groups map[string]*aggrGroup
// 计数器走 atomic:flushGroup 在锁外执行(Run/FlushAll 换出组后提交),
// 与 Stats() 并发读写必须无竞争(-race 门禁;2026-09-29 补修,原 int64 裸写遗留)。
addTotal atomic.Int64 // 累计入聚合条数
batchTotal atomic.Int64 // 累计批量提交次数(调用次数口径)
singleTotal atomic.Int64 // 累计回退逐号次数
}
// NewSubmitAggregator 构造(window/maxBatch 零值取默认;mark 可后期 bindMark 绑定)。
func NewSubmitAggregator(lk LinkSubmitter, window time.Duration, maxBatch int) *SubmitAggregator {
if window <= 0 {
window = DefaultAggrWindow
}
if maxBatch <= 0 {
maxBatch = DefaultAggrMaxBatch
}
return &SubmitAggregator{
lk: lk, window: window, maxBatch: maxBatch,
groups: map[string]*aggrGroup{},
}
}
// bindMark 终态回写绑定(ChannelDispatcher 构造时注入,避免循环依赖)。
func (a *SubmitAggregator) bindMark(fn func(ctx context.Context, ids []int64, status int8, channelID int64, errCode string)) {
a.mark = fn
}
// WithDB 注入 DB(Day 56:seg 配对登记;nil 保持跳过)。
func (a *SubmitAggregator) WithDB(db *gorm.DB) *SubmitAggregator {
a.db = db
return a
}
// Add 入聚合(组满 maxBatch 同步 flush 该组,保证阈值触发实时性)。
func (a *SubmitAggregator) Add(channelID int64, content, mobile string, detailID int64) {
key := aggrKey(channelID, content)
var full *aggrGroup
a.mu.Lock()
g := a.groups[key]
if g == nil {
g = &aggrGroup{channelID: channelID, content: content}
a.groups[key] = g
}
g.items = append(g.items, aggrItem{detailID: detailID, mobile: mobile})
a.addTotal.Add(1)
if len(g.items) >= a.maxBatch {
delete(a.groups, key)
full = g
}
a.mu.Unlock()
if full != nil {
a.flushGroup(full)
}
}
// Run 常驻窗口 flush(随 ctx 退出;退出前清空缓冲)。
func (a *SubmitAggregator) Run(ctx context.Context) {
t := time.NewTicker(a.window)
defer t.Stop()
for {
select {
case <-ctx.Done():
a.FlushAll()
return
case <-t.C:
a.FlushAll()
}
}
}
// FlushAll 冲洗全部缓冲组。
func (a *SubmitAggregator) FlushAll() {
a.mu.Lock()
pending := a.groups
a.groups = map[string]*aggrGroup{}
a.mu.Unlock()
for _, g := range pending {
a.flushGroup(g)
}
}
// flushGroup 单组提交:批量优先,失败逐号回退;终态按结果回写。
func (a *SubmitAggregator) flushGroup(g *aggrGroup) {
if len(g.items) == 0 {
return
}
ctx := context.Background()
mobiles := make([]string, 0, len(g.items))
ids := make([]int64, 0, len(g.items))
for _, it := range g.items {
mobiles = append(mobiles, it.mobile)
ids = append(ids, it.detailID)
}
if bl, ok := a.lk.(BatchLinkSubmitter); ok {
a.batchTotal.Add(1)
acks, err := bl.SubmitBatchViaLink(ctx, g.channelID, mobiles, g.content)
// Day 56:成功包先行登记段级配对(哪怕整批报错,已确认包不丢 seg)。
writeSegRows(ctx, a.db, segRowsForBatch(g.channelID, g.items, acks))
acked := make(map[string]bool, len(mobiles))
for _, ack := range acks {
for _, mo := range ack.Mobiles {
acked[mo] = true
}
}
if err != nil {
logger.L().Warn("aggr_batch_submit_failed_fallback_single",
zap.Int64("channel_id", g.channelID), zap.Error(err))
// 批量失败回退逐号,尽量保送达(逐号独立成败)。
// Day 56 增强:已确认包(在 acks 内)不重复发送——重复提交=重复计费风险。
var okIDs, failIDs []int64
for _, it := range g.items {
if acked[it.mobile] {
okIDs = append(okIDs, it.detailID)
continue
}
mids, serr := a.lk.SubmitViaLink(ctx, g.channelID, it.mobile, g.content)
if serr != nil {
failIDs = append(failIDs, it.detailID)
} else {
writeSegRows(ctx, a.db, segRowsFor(g.channelID, it.detailID, it.mobile, mids))
okIDs = append(okIDs, it.detailID)
}
a.singleTotal.Add(1)
}
a.markIDs(ctx, okIDs, submit.DetailStSubmitted, g.channelID, "")
a.markIDs(ctx, failIDs, submit.DetailStFailed, g.channelID, errText(err))
return
}
a.markIDs(ctx, ids, submit.DetailStSubmitted, g.channelID, "")
return
}
// 链路无批量能力:逐号提交(兼容路径;Day52 修复:终态保留最后错误,原空串丢排障信息)。
var okIDs, failIDs []int64
lastErr := ""
for _, it := range g.items {
mids, serr := a.lk.SubmitViaLink(ctx, g.channelID, it.mobile, g.content)
if serr != nil {
failIDs = append(failIDs, it.detailID)
lastErr = errText(serr)
} else {
writeSegRows(ctx, a.db, segRowsFor(g.channelID, it.detailID, it.mobile, mids))
okIDs = append(okIDs, it.detailID)
}
a.singleTotal.Add(1)
}
a.markIDs(ctx, okIDs, submit.DetailStSubmitted, g.channelID, "")
a.markIDs(ctx, failIDs, submit.DetailStFailed, g.channelID, lastErr)
}
// markIDs 批量终态回写(mark 未绑定时忽略——纯内存测试场景)。
func (a *SubmitAggregator) markIDs(ctx context.Context, ids []int64, status int8, channelID int64, errCode string) {
if len(ids) == 0 || a.mark == nil {
return
}
a.mark(ctx, ids, status, channelID, errCode)
}
// Stats 聚合统计(观测/验收:调用次数口径)。计数器为 atomic,无需持锁。
func (a *SubmitAggregator) Stats() (added, batchCalls, singleCalls int64) {
return a.addTotal.Load(), a.batchTotal.Load(), a.singleTotal.Load()
}
// aggrKey 组键(通道+内容;内容即签名+正文一体,同内容才可合包)。
func aggrKey(channelID int64, content string) string {
return strconv.FormatInt(channelID, 10) + "\x00" + content
}
func errText(err error) string {
if err == nil {
return ""
}
return err.Error()
}