All checks were successful
构建并部署到测试环境(无 SSH) / build-and-deploy (push) Successful in 9m24s
- 开关开启但分发器心跳缺失时回退为当场执行,避免指令无人消费 - 待确认指令先查上游状态再判断;执行期间被覆盖时把待确认带到新指令 - 同方向失败退避中重复写入不提前执行时间 - 领取容量把执行上限与本秒剩余 QPS 分开计算 - 队列复机共用单卡复机锁;执行上下文取消后按结果未知确认 - 消费者并行停止;读取最近调用时间失败时不覆盖;成功但终结日志失败按成功处理 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
150 lines
6.4 KiB
Go
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
|
|
}
|