Files
junhong_cmp_fiber/internal/service/iot_card/stop_resume_request.go
邹进 a4e3fe4d8f
All checks were successful
构建并部署到测试环境(无 SSH) / build-and-deploy (push) Successful in 9m24s
fix: 停复机指令队列审查问题
- 开关开启但分发器心跳缺失时回退为当场执行,避免指令无人消费
- 待确认指令先查上游状态再判断;执行期间被覆盖时把待确认带到新指令
- 同方向失败退避中重复写入不提前执行时间
- 领取容量把执行上限与本秒剩余 QPS 分开计算
- 队列复机共用单卡复机锁;执行上下文取消后按结果未知确认
- 消费者并行停止;读取最近调用时间失败时不覆盖;成功但终结日志失败按成功处理

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 00:43:58 +09:00

150 lines
6.4 KiB
Go

package iot_card
import (
"context"
stderrors "errors"
"go.uber.org/zap"
"github.com/break/junhong_cmp_fiber/internal/model"
"github.com/break/junhong_cmp_fiber/internal/polling/carrierqueue"
"github.com/break/junhong_cmp_fiber/pkg/constants"
"github.com/break/junhong_cmp_fiber/pkg/errors"
)
// StopResumeCommandQueue 是停复机指令队列的写入接缝(共享缓存)。
type StopResumeCommandQueue interface {
// Enabled 返回停复机出口开关 polling.stop_resume.queue_enabled。
Enabled(ctx context.Context) bool
WriteCommand(ctx context.Context, cmd carrierqueue.StopResumeCommand) (int64, error)
RequestDeviceEval(ctx context.Context, deviceID uint, scenes []string) error
}
// SetCommandQueue 注入停复机指令队列;未注入时始终当场执行。
func (s *StopResumeService) SetCommandQueue(queue StopResumeCommandQueue) {
s.commandQueue = queue
}
// CommandQueueEnabled 返回停复机出口开关是否开启(供调用方决定是否还需要异步执行)。
func (s *StopResumeService) CommandQueueEnabled(ctx context.Context) bool {
return s.commandQueueEnabled(ctx)
}
func (s *StopResumeService) commandQueueEnabled(ctx context.Context) bool {
return s != nil && s.commandQueue != nil && s.commandQueue.Enabled(ctx)
}
// RequestAssetEvaluation 请求评估门面:开关开启时单卡生成指令、设备请求设备判断;关闭时走旧路径当场执行。
// assetType 为 constants.AssetTypeIotCard / AssetTypeDevice。
func (s *StopResumeService) RequestAssetEvaluation(ctx context.Context, assetType string, assetID uint, scene, source string) error {
ctx = WithStopResumeScene(ctx, scene)
if !s.commandQueueEnabled(ctx) {
return s.legacyAssetEvaluation(ctx, assetType, assetID)
}
if assetType == constants.AssetTypeDevice {
return s.requestDeviceEval(ctx, assetID, []string{scene}, source)
}
card, err := s.iotCardStore.GetByID(ctx, assetID)
if err != nil {
return errors.Wrap(errors.CodeDatabaseError, err, "读取卡失败")
}
scenes := []string{scene}
decision, err := s.decideCard(ctx, card, scenes)
if err != nil {
return err
}
return s.submitDecisionWithSource(ctx, card, decision, scenes, source)
}
// legacyAssetEvaluation 开关关闭时的当场执行:单卡按统一判断执行,设备按设备复机(套餐激活、重置、订单)或逐卡评估(其他场景)。
func (s *StopResumeService) legacyAssetEvaluation(ctx context.Context, assetType string, assetID uint) error {
if assetType == constants.AssetTypeDevice {
cards, err := s.deviceCards(ctx, assetID)
if err != nil {
return err
}
var failed []error
for _, card := range cards {
if err := s.EvaluateAndAct(ctx, card); err != nil {
failed = append(failed, err)
}
}
if len(failed) > 0 {
return errors.Wrap(errors.CodeInternalError, stderrors.Join(failed...), "设备停复机评估存在未成功处理的卡")
}
return nil
}
card, err := s.iotCardStore.GetByID(ctx, assetID)
if err != nil {
return errors.Wrap(errors.CodeDatabaseError, err, "读取卡失败")
}
return s.EvaluateAndAct(ctx, card)
}
// submitDecision 把统一判断结果写入指令队列(来源取场景)。
func (s *StopResumeService) submitDecision(ctx context.Context, card *model.IotCard, decision stopResumeDecision, scenes []string) error {
return s.submitDecisionWithSource(ctx, card, decision, scenes, "")
}
func (s *StopResumeService) submitDecisionWithSource(ctx context.Context, card *model.IotCard, decision stopResumeDecision, scenes []string, source string) error {
if decision.Action == "" {
return nil
}
if decision.DeviceID > 0 {
return s.requestDeviceEval(ctx, decision.DeviceID, scenes, source)
}
return s.writeCardCommand(ctx, card, decision, scenes, source)
}
// writeCardCommand 生成单卡停复机指令;复机前检查通道阈值锁,持锁时记录拒绝事实不生成指令。
func (s *StopResumeService) writeCardCommand(ctx context.Context, card *model.IotCard, decision stopResumeDecision, scenes []string, source string) error {
if decision.Action == constants.StopResumeActionStart {
blocked, err := s.channelThresholdBlocked(ctx, card)
if err != nil {
return err
}
if blocked {
s.recordChannelThresholdDenial(ctx, card, constants.AuditActionIotCardAutoStarted, "自动恢复 IoT 卡网络")
return nil
}
}
if source == "" {
source = constants.JoinStopResumeScenes(scenes)
}
version, err := s.commandQueue.WriteCommand(ctx, carrierqueue.StopResumeCommand{
CardID: card.ID, CarrierID: card.CarrierID, Action: decision.Action, Reason: decision.Reason, Scenes: scenes, Source: source,
})
if err != nil {
// 写入失败只记日志:由该卡下一次套餐步骤兜底。
s.logger.Error("写入停复机指令失败", zap.Uint("card_id", card.ID), zap.String("action", decision.Action),
zap.Strings("scenes", scenes), zap.String("metric", "stop_resume.request_failed"), zap.Error(err))
return errors.Wrap(errors.CodeRedisError, err, "写入停复机指令失败")
}
s.logger.Info("已生成停复机指令", zap.Uint("card_id", card.ID), zap.Uint("carrier_id", card.CarrierID),
zap.String("action", decision.Action), zap.String("reason", decision.Reason), zap.Strings("scenes", scenes), zap.Int64("version", version))
return nil
}
// requestDeviceEval 请求一次设备维度判断。
func (s *StopResumeService) requestDeviceEval(ctx context.Context, deviceID uint, scenes []string, source string) error {
if err := s.commandQueue.RequestDeviceEval(ctx, deviceID, scenes); err != nil {
s.logger.Error("请求设备判断失败", zap.Uint("device_id", deviceID), zap.Strings("scenes", scenes), zap.String("source", source),
zap.String("metric", "stop_resume.request_failed"), zap.Error(err))
return errors.Wrap(errors.CodeRedisError, err, "请求设备判断失败")
}
return nil
}
// deviceCards 返回设备下有效绑定的全部卡(在线与停机)。
func (s *StopResumeService) deviceCards(ctx context.Context, deviceID uint) ([]*model.IotCard, error) {
online, err := s.iotCardStore.ListByDeviceIDAndNetworkStatus(ctx, deviceID, constants.NetworkStatusOnline)
if err != nil {
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询设备在线卡失败")
}
offline, err := s.iotCardStore.ListByDeviceIDAndNetworkStatus(ctx, deviceID, constants.NetworkStatusOffline)
if err != nil {
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询设备停机卡失败")
}
return append(online, offline...), nil
}