Files
go-sms-V2/internal/pkg/queue/consumer.go
T

325 lines
9.9 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package queue
import (
"context"
"errors"
"fmt"
"strings"
"sync"
"time"
"github.com/IBM/sarama"
"go.uber.org/zap"
)
// 起步 offset 模式(Day58:起步 offset 可配,dev 存量治理配套)。
const (
OffsetModeOldest = "oldest" // 最早(历史积压回放;生产默认语义)
OffsetModeLatest = "latest" // 最新(跳过积压;dev 止血用)
)
// Handler 消息处理函数:返回 nil 视为处理成功并提交 offset;
// 返回错误则不提交(at-least-once,重平衡/重启后重新投递)。
type Handler func(ctx context.Context, msg *sarama.ConsumerMessage) error
// ConsumerConfig 消费者组配置。
type ConsumerConfig struct {
Brokers []string
GroupID string
Topics []string
Handler Handler
Logger *zap.Logger
// OffsetMode 起步 offset:oldest|latest(大小写不敏感,非法值创建报错)。
// 仅对无已提交 offset 的消费组生效(新组/offset 重置后);显式指定时
// 优先于 Oldest bool;空则回退 Oldest 语义(历史调用方兼容)。
OffsetMode string
Oldest bool // true 从最早 offset 开始(新组/集成测试);默认从最新
// CommitEveryN 每成功处理 N 条显式提交一次 offset(默认 100)。
CommitEveryN int
// WorkersPerPartition 每分区并行 worker 数(Day 65;默认 0/1=串行原行为)。
// >1 时同分区消息乱序并行处理,offset 按连续前缀有序 Mark——at-least-once
// 语义不变(失败不 Mark 由后继越过;退出/重平衡窗口内不 Mark 的在途消息重投)。
// 适用:单条处理为 DB 慢事务链(sms-submit Deferred 补全),吞吐=并发÷延迟。
WorkersPerPartition int
// PaceEvery/PaceSleep 消费 pacing(Day58):每成功处理 PaceEvery 条
// sleep PaceSleep(默认 0=不限速)。冷启动 oldest 存量回放时压制消费
// 速率,防落库风暴打爆下游(dev MySQL);等待可被会话取消即时打断。
PaceEvery int
PaceSleep time.Duration
}
// resolveInitialOffset 解析起步 offset:OffsetMode 显式优先(非法值报错,
// 防误配 oldest 引发存量回放风暴);空回退 Oldest bool;默认最新。
func (c ConsumerConfig) resolveInitialOffset() (int64, error) {
if c.OffsetMode != "" {
switch strings.ToLower(strings.TrimSpace(c.OffsetMode)) {
case OffsetModeOldest:
return sarama.OffsetOldest, nil
case OffsetModeLatest:
return sarama.OffsetNewest, nil
default:
return 0, fmt.Errorf("queue: offset_mode 非法 %q(合法:oldest|latest)", c.OffsetMode)
}
}
if c.Oldest {
return sarama.OffsetOldest, nil
}
return sarama.OffsetNewest, nil
}
// Consumer 消费者组封装:自动应对重平衡,手动提交 offset。
type Consumer struct {
group sarama.ConsumerGroup
cfg ConsumerConfig
log *zap.Logger
}
// NewConsumer 创建消费者组(连接 broker)。
func NewConsumer(cfg ConsumerConfig) (*Consumer, error) {
if len(cfg.Brokers) == 0 {
return nil, errors.New("queue: kafka.brokers 不能为空")
}
if cfg.GroupID == "" {
return nil, errors.New("queue: group_id 不能为空")
}
if len(cfg.Topics) == 0 {
return nil, errors.New("queue: topics 不能为空")
}
if cfg.Handler == nil {
return nil, errors.New("queue: handler 不能为空")
}
if cfg.CommitEveryN <= 0 {
cfg.CommitEveryN = 100
}
if cfg.Logger == nil {
cfg.Logger = zap.NewNop()
}
initial, err := cfg.resolveInitialOffset()
if err != nil {
return nil, err
}
sc := sarama.NewConfig()
sc.Version = sarama.V2_8_0_0
sc.Consumer.Offsets.AutoCommit.Enable = false // 手动提交
sc.Consumer.Offsets.Initial = initial // 起步 offset(Day58 可配;仅新组/重置后生效)
sc.Consumer.Group.Heartbeat.Interval = 3 * time.Second
sc.Consumer.Group.Rebalance.Retry.Max = 3 // 重平衡重试
sc.Consumer.Group.Rebalance.Timeout = 60 * time.Second
group, err := sarama.NewConsumerGroup(cfg.Brokers, cfg.GroupID, sc)
if err != nil {
return nil, err
}
return &Consumer{group: group, cfg: cfg, log: cfg.Logger}, nil
}
// Run 阻塞消费直至 ctx 取消;正常退出(含 Close 后)返回 nil。
func (c *Consumer) Run(ctx context.Context) error {
h := &groupHandler{cfg: c.cfg, log: c.log}
for {
if err := c.group.Consume(ctx, c.cfg.Topics, h); err != nil {
if errors.Is(err, sarama.ErrClosedConsumerGroup) {
return nil
}
return err
}
if ctx.Err() != nil {
return nil
}
}
}
// Close 关闭消费者组。
func (c *Consumer) Close() error { return c.group.Close() }
// groupHandler sarama.ConsumerGroupHandler 实现。
type groupHandler struct {
cfg ConsumerConfig
log *zap.Logger
}
func (h *groupHandler) Setup(sarama.ConsumerGroupSession) error { return nil }
func (h *groupHandler) Cleanup(sarama.ConsumerGroupSession) error { return nil }
// ConsumeClaim 逐条处理:成功 Mark + 周期 Commit;失败跳过不提交;
// 可选 pacing(每 PaceEvery 条成功消息歇 PaceSleep,存量回放防落库风暴)。
// WorkersPerPartition>1 时转并行路径(consumeParallel)。
func (h *groupHandler) ConsumeClaim(sess sarama.ConsumerGroupSession, claim sarama.ConsumerGroupClaim) error {
if h.cfg.WorkersPerPartition > 1 {
return h.consumeParallel(sess, claim)
}
n := 0
paced := 0
pace := h.cfg.PaceEvery > 0 && h.cfg.PaceSleep > 0
for {
select {
case <-sess.Context().Done():
return nil
case msg, ok := <-claim.Messages():
if !ok {
return nil
}
if err := h.cfg.Handler(sess.Context(), msg); err != nil {
// 不 Mark:offset 不前进,重平衡/重启后重新投递(at-least-once)
h.log.Warn("kafka_consume_handler_failed",
zap.String("topic", msg.Topic), zap.Int32("partition", msg.Partition),
zap.Int64("offset", msg.Offset), zap.Error(err))
continue
}
sess.MarkMessage(msg, "")
n++
if n >= h.cfg.CommitEveryN {
sess.Commit() // 手动提交已 Mark 的 offset
n = 0
}
// Day58 pacing:以成功消息计数驱动(失败消息不歇,快速跳过毒丸),
// 等待期可被会话取消即时打断(不阻塞优雅退出/重平衡)。
if pace {
paced++
if paced >= h.cfg.PaceEvery {
select {
case <-time.After(h.cfg.PaceSleep):
case <-sess.Context().Done():
return nil
}
paced = 0
}
}
}
}
}
// consumeParallel 每分区 worker 池(Day 65):消息乱序并行处理,提交严格按
// offset 连续前缀推进——仅 Mark「自身与前驱均已完成」的消息,at-least-once
// 与串行版等价:
// - 失败消息不 Mark 但允许前缀越过(重试语义交 ConsumerGroup wrap 层,
// 与串行版「失败 continue、后继 Mark 越过」一致);
// - 会话结束/通道关闭时窗口内在途消息一律不 Mark,重平衡/重启后重投。
//
// 背压:tasks 通道容量=workers,打满时取消息阻塞(worker 消化后自续)。
func (h *groupHandler) consumeParallel(sess sarama.ConsumerGroupSession, claim sarama.ConsumerGroupClaim) error {
workers := h.cfg.WorkersPerPartition
type outcome struct {
msg *sarama.ConsumerMessage // nil=在途占位(已取未完成)
err error
}
tasks := make(chan *sarama.ConsumerMessage, workers)
// 容量须 ≥ 2×workers+2(在途上限=tasks 缓冲+worker 手中各一):否则主循环
// 阻塞投 tasks 时无人消费 done,worker 全阻塞在 done<- 形成死锁环(单测实证)。
done := make(chan outcome, workers*2+2)
var wg sync.WaitGroup
for i := 0; i < workers; i++ {
wg.Add(1)
go func() {
defer wg.Done()
for m := range tasks {
out := outcome{msg: m, err: h.cfg.Handler(sess.Context(), m)}
select {
case done <- out:
case <-sess.Context().Done():
return
}
}
}()
}
go func() { wg.Wait(); close(done) }()
n, paced := 0, 0
pace := h.cfg.PaceEvery > 0 && h.cfg.PaceSleep > 0
next := int64(-1) // 待推进起始 offset(首条消息锚定)
window := map[int64]outcome{} // offset→处理结果(占位/完成)
// stop 关闭取数通道并等 worker 全部收尾(结果通道关闭),防 goroutine 泄漏。
stop := func() {
close(tasks)
for range done { /* 丢弃在途结果:会话已结束,Mark 无意义 */
}
}
// advance 推进连续完成前缀:成功 Mark+周期 Commit+可选 pacing;失败仅记日志越过。
// 返回 false=会话取消(pacing 等待被打断),调用方须立即退出。
advance := func() bool {
for {
v, exists := window[next]
if !exists || v.msg == nil {
return true
}
if v.err == nil {
sess.MarkMessage(v.msg, "")
n++
if n >= h.cfg.CommitEveryN {
sess.Commit()
n = 0
}
if pace {
paced++
if paced >= h.cfg.PaceEvery {
select {
case <-time.After(h.cfg.PaceSleep):
case <-sess.Context().Done():
return false
}
paced = 0
}
}
} else {
// 不 Mark:offset 不前进,重平衡/重启后重新投递(at-least-once)
h.log.Warn("kafka_consume_handler_failed",
zap.String("topic", v.msg.Topic), zap.Int32("partition", v.msg.Partition),
zap.Int64("offset", v.msg.Offset), zap.Error(v.err))
}
delete(window, next)
next++
}
}
// pending pattern(Day65 死锁修复):投 tasks 阻塞期间仍须消费 done——若投递
// 用嵌套 select 独占等待,done 满后 worker 阻塞发送、不再取 tasks,与主循环
// 互锁(生产实证:16 分区 worker 卡 done<-、主循环卡 tasks<-,进程全静默)。
var pending *sarama.ConsumerMessage
for {
if pending == nil {
select {
case <-sess.Context().Done():
stop()
return nil
case msg, ok := <-claim.Messages():
if !ok {
stop()
return nil
}
if next < 0 {
next = msg.Offset
}
window[msg.Offset] = outcome{} // 在途占位:阻挡前缀越过未完成消息
pending = msg
case r, ok := <-done:
if !ok {
return nil // 仅 stop 后到达:worker 已全部收尾
}
window[r.msg.Offset] = r
if !advance() {
return nil
}
}
continue
}
select {
case <-sess.Context().Done():
stop()
return nil
case tasks <- pending:
pending = nil
case r, ok := <-done:
if !ok {
return nil
}
window[r.msg.Offset] = r
if !advance() {
return nil
}
}
}
}