Files
junhong_cmp_fiber/internal/infrastructure/nsqbus/nsqbus.go
邹进 2fe7c1f8ac feat: 按运营商账户调度的分发器、卡任务执行器与模式切换
- 四个轮询处理器拆为步骤函数 Step(返回结果分类),旧 Asynq Handle 只做并发控制与原有重入队映射,行为不变;carrier 模式下旧 handler 直接结束
- 网关限流增加等待模式(ctx 标记),NSQ 消费者等名额到单步超时,超时按限流处理不计失败;记录限流等待次数
- 卡任务执行器:核对 token 并抢执行权,按配置步骤顺序串行执行到期检查(单步超时、总超时、panic 恢复、流量已触发评估时跳过套餐),执行中续期并 Touch,续期失败立即停止;收尾写回到期、连续失败、退避、延迟确认与告警
- 分发器:每秒按账户抢分发锁领取(执行上限按消费能力收紧、优先占比、按限流组剩余 QPS 估算),发布到 polling.card.{账户},发布失败释放;消费旧优先提示与手动触发;心跳与处理中标记到期计数
- NSQ 生产者与按账户动态订阅的消费者管理器,优雅退出宽限期
- 失败告警异步写 tb_polling_failure_alert(同卡同类型一条未处理,成功转已恢复),账户窗口内告警数超阈值产生账户级告警
- 模式监听:切 carrier 时旧分片调度停止出队,加锁初始化新结构后开始领取并订阅;回 legacy 时停止消费、重建旧分片队列;生命周期(API 与 Worker)在 carrier 模式写账户队列
2026-10-25 18:44:23 +09:00

216 lines
6.0 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 nsqbus 封装卡轮询使用的 NSQ 生产者与按 topic 动态订阅的消费者管理器。
// NSQ 只承担执行分发与消费者并发控制,业务状态与重试全部在 Redis(add-carrier-polling-scheduler)。
package nsqbus
import (
"context"
"strings"
"sync"
"time"
"github.com/nsqio/go-nsq"
"go.uber.org/zap"
)
// Producer 是 nsqd 生产者。
type Producer struct {
producer *nsq.Producer
}
// NewProducer 连接 nsqd TCP 地址创建生产者。
func NewProducer(address string, logger *zap.Logger) (*Producer, error) {
cfg := nsq.NewConfig()
producer, err := nsq.NewProducer(address, cfg)
if err != nil {
return nil, err
}
producer.SetLogger(nsqLogger{logger: logger}, nsq.LogLevelWarning)
return &Producer{producer: producer}, nil
}
// Publish 同步发布一条消息;topic 不存在时由 nsqd 自动创建。
func (p *Producer) Publish(topic string, body []byte) error {
return p.producer.Publish(topic, body)
}
// Stop 停止生产者。
func (p *Producer) Stop() {
if p != nil && p.producer != nil {
p.producer.Stop()
}
}
// Handler 处理一条消息;返回后由管理器 FIN。消息处理期间可调用 touch 延长 NSQ 消息超时。
type Handler func(ctx context.Context, body []byte, touch func())
// ConsumerConfig 是消费者参数。
type ConsumerConfig struct {
NSQDAddress string
NSQLookupdAddresses []string
MsgTimeout time.Duration
MaxAttempts uint16
}
// ConsumerManager 按 topic 动态订阅与取消订阅;每个 topic 一个消费者,max_in_flight 控制本进程对该 topic 的并发。
type ConsumerManager struct {
cfg ConsumerConfig
channel string
handler Handler
logger *zap.Logger
mu sync.Mutex
consumers map[string]*subscription
ctx context.Context
cancel context.CancelFunc
inflight sync.WaitGroup
}
type subscription struct {
consumer *nsq.Consumer
maxInFlight int
}
// NewConsumerManager 创建消费者管理器。
func NewConsumerManager(cfg ConsumerConfig, channel string, handler Handler, logger *zap.Logger) *ConsumerManager {
if logger == nil {
logger = zap.NewNop()
}
ctx, cancel := context.WithCancel(context.Background())
return &ConsumerManager{cfg: cfg, channel: channel, handler: handler, logger: logger,
consumers: map[string]*subscription{}, ctx: ctx, cancel: cancel}
}
// Sync 使订阅集合与 desired(topic → max_in_flight)一致:新增订阅、取消多余订阅、调整 max_in_flight。
func (m *ConsumerManager) Sync(desired map[string]int) {
m.mu.Lock()
defer m.mu.Unlock()
if m.ctx.Err() != nil {
return
}
for topic, sub := range m.consumers {
if _, keep := desired[topic]; !keep {
sub.consumer.Stop()
delete(m.consumers, topic)
m.logger.Info("取消订阅卡任务 topic", zap.String("topic", topic))
}
}
for topic, maxInFlight := range desired {
if maxInFlight <= 0 {
maxInFlight = 1
}
if sub, ok := m.consumers[topic]; ok {
if sub.maxInFlight != maxInFlight {
sub.consumer.ChangeMaxInFlight(maxInFlight)
sub.maxInFlight = maxInFlight
}
continue
}
consumer, err := m.subscribe(topic, maxInFlight)
if err != nil {
m.logger.Warn("订阅卡任务 topic 失败,下一轮重试", zap.String("topic", topic), zap.Error(err))
continue
}
m.consumers[topic] = &subscription{consumer: consumer, maxInFlight: maxInFlight}
m.logger.Info("订阅卡任务 topic", zap.String("topic", topic), zap.Int("max_in_flight", maxInFlight))
}
}
func (m *ConsumerManager) subscribe(topic string, maxInFlight int) (*nsq.Consumer, error) {
cfg := nsq.NewConfig()
cfg.MaxInFlight = maxInFlight
if m.cfg.MsgTimeout > 0 {
cfg.MsgTimeout = m.cfg.MsgTimeout
}
if m.cfg.MaxAttempts > 0 {
cfg.MaxAttempts = m.cfg.MaxAttempts
}
consumer, err := nsq.NewConsumer(topic, m.channel, cfg)
if err != nil {
return nil, err
}
consumer.SetLogger(nsqLogger{logger: m.logger}, nsq.LogLevelWarning)
handlerCtx := m.ctx // subscribe 在持锁时调用,捕获当前处理上下文
consumer.AddConcurrentHandlers(nsq.HandlerFunc(func(message *nsq.Message) error {
message.DisableAutoResponse()
m.inflight.Add(1)
defer m.inflight.Done()
defer message.Finish()
m.handler(handlerCtx, message.Body, message.Touch)
return nil
}), maxInFlight)
if len(m.cfg.NSQLookupdAddresses) > 0 {
err = consumer.ConnectToNSQLookupds(m.cfg.NSQLookupdAddresses)
} else {
err = consumer.ConnectToNSQD(m.cfg.NSQDAddress)
}
if err != nil {
consumer.Stop()
return nil, err
}
return consumer, nil
}
// Topics 返回当前已订阅的 topic。
func (m *ConsumerManager) Topics() []string {
m.mu.Lock()
defer m.mu.Unlock()
topics := make([]string, 0, len(m.consumers))
for topic := range m.consumers {
topics = append(topics, topic)
}
return topics
}
// StopAll 停止全部订阅;在宽限期内等待执行中的消息完成并 FIN,超过宽限期后取消处理上下文。
func (m *ConsumerManager) StopAll(grace time.Duration) {
m.mu.Lock()
for topic, sub := range m.consumers {
sub.consumer.Stop()
delete(m.consumers, topic)
}
m.mu.Unlock()
done := make(chan struct{})
go func() {
m.inflight.Wait()
close(done)
}()
select {
case <-done:
case <-time.After(grace):
m.logger.Warn("优雅退出宽限期内仍有卡任务未完成,取消执行(由租约到期后重新领取)")
}
m.cancel()
}
// Reset 在 StopAll 后重新允许订阅(切回 carrier 模式时使用)。
func (m *ConsumerManager) Reset() {
m.mu.Lock()
defer m.mu.Unlock()
if m.ctx.Err() != nil {
m.ctx, m.cancel = context.WithCancel(context.Background())
}
}
// SplitAddresses 解析逗号分隔的地址列表。
func SplitAddresses(raw string) []string {
var result []string
for _, part := range strings.Split(raw, ",") {
if part = strings.TrimSpace(part); part != "" {
result = append(result, part)
}
}
return result
}
type nsqLogger struct {
logger *zap.Logger
}
// Output 实现 go-nsq 的日志接口。
func (l nsqLogger) Output(_ int, s string) error {
if l.logger != nil {
l.logger.Warn("NSQ", zap.String("message", s))
}
return nil
}