feat: 按运营商账户调度的分发器、卡任务执行器与模式切换

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

View File

@@ -0,0 +1,215 @@
// 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
}