234 lines
7.2 KiB
Go
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()
|
|
}
|