From dc3f9cc91759823ce59486f19b138be4b296a0f1 Mon Sep 17 00:00:00 2001
From: Junjie <fallin.jie@qq.com>
Date: 星期二, 28 四月 2026 09:43:28 +0800
Subject: [PATCH] #
---
src/main/java/com/zy/ai/service/impl/AutoTuneApplyServiceImpl.java | 622 ++++++++++++++++++++++++++++++++++++++++++++-----------
1 files changed, 494 insertions(+), 128 deletions(-)
diff --git a/src/main/java/com/zy/ai/service/impl/AutoTuneApplyServiceImpl.java b/src/main/java/com/zy/ai/service/impl/AutoTuneApplyServiceImpl.java
index 98a588a..14ce0c9 100644
--- a/src/main/java/com/zy/ai/service/impl/AutoTuneApplyServiceImpl.java
+++ b/src/main/java/com/zy/ai/service/impl/AutoTuneApplyServiceImpl.java
@@ -17,30 +17,47 @@
import com.zy.asrs.entity.BasCrnp;
import com.zy.asrs.entity.BasDualCrnp;
import com.zy.asrs.entity.BasStation;
-import com.zy.asrs.entity.StationFlowCapacity;
+import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.BasCrnpService;
import com.zy.asrs.service.BasDualCrnpService;
import com.zy.asrs.service.BasStationService;
-import com.zy.asrs.service.StationFlowCapacityService;
+import com.zy.asrs.service.WrkMastService;
+import com.zy.common.utils.RedisUtil;
+import com.zy.core.enums.RedisKeyType;
+import com.zy.core.enums.WrkStsType;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
+import java.util.UUID;
@Service("autoTuneApplyService")
public class AutoTuneApplyServiceImpl implements AutoTuneApplyService {
+ private static final Logger LOGGER = LoggerFactory.getLogger(AutoTuneApplyServiceImpl.class);
private static final String PROMPT_SCENE_CODE = "auto_tune_apply";
- private static final String DIRECTION_OUT = "OUT";
+ private static final long APPLY_LOCK_SECONDS = 120L;
+ private static final String APPLY_LOCK_BUSY_REASON = "鐢宠璋冨弬閿佸け璐ワ紝閿佷笉鍙敤锛屽彲鑳藉凡鏈変换鍔℃垨 Redis 寮傚父";
+ private static final List<Long> FINAL_WRK_STS_LIST = Arrays.asList(
+ WrkStsType.COMPLETE_INBOUND.sts,
+ WrkStsType.SETTLE_INBOUND.sts,
+ WrkStsType.COMPLETE_OUTBOUND.sts,
+ WrkStsType.SETTLE_OUTBOUND.sts,
+ WrkStsType.COMPLETE_LOC_MOVE.sts,
+ WrkStsType.COMPLETE_CRN_MOVE.sts
+ );
@Autowired
private AiAutoTuneJobService aiAutoTuneJobService;
@@ -55,9 +72,11 @@
@Autowired
private BasDualCrnpService basDualCrnpService;
@Autowired
- private StationFlowCapacityService stationFlowCapacityService;
- @Autowired(required = false)
+ private WrkMastService wrkMastService;
+ @Autowired
private PlatformTransactionManager transactionManager;
+ @Autowired
+ private RedisUtil redisUtil;
@Override
public AutoTuneApplyResult apply(AutoTuneApplyRequest request) {
@@ -65,58 +84,176 @@
boolean dryRun = Boolean.TRUE.equals(safeRequest.getDryRun());
Date now = new Date();
AiAutoTuneJob job = createJob(safeRequest, dryRun, now);
- aiAutoTuneJobService.save(job);
- List<ValidatedChange> validatedChanges = validateChanges(safeRequest, dryRun, now);
- boolean hasRejectedChange = hasRejectedChange(validatedChanges);
- if (!dryRun && hasRejectedChange) {
- markAcceptedChangesAsBatchRejected(validatedChanges);
+ if (dryRun) {
+ return applyDryRun(safeRequest, job, now);
}
- if (!dryRun && !hasRejectedChange) {
+ return applyRealWithLock(safeRequest, job, now);
+ }
+
+ private AutoTuneApplyResult applyDryRun(AutoTuneApplyRequest request, AiAutoTuneJob job, Date now) {
+ List<ValidatedChange> validatedChanges = validateChanges(request, true, now);
+ ApplyPersistenceResult persistenceResult = persistApplyResultInTransaction(
+ job,
+ request,
+ validatedChanges,
+ true,
+ now,
+ false
+ );
+ return buildResult(job, persistenceResult.getAuditChanges(), true);
+ }
+
+ private AutoTuneApplyResult applyRealWithLock(AutoTuneApplyRequest request, AiAutoTuneJob job, Date now) {
+ if (request.getChanges() == null || request.getChanges().isEmpty()) {
+ ApplyPersistenceResult persistenceResult = persistApplyResultInTransaction(
+ job,
+ request,
+ new ArrayList<>(),
+ false,
+ now,
+ false
+ );
+ return buildResult(job, persistenceResult.getAuditChanges(), false);
+ }
+
+ String lockKey = RedisKeyType.AI_AUTO_TUNE_APPLY_LOCK.key;
+ String lockToken = UUID.randomUUID().toString();
+ if (!redisUtil.trySetStringIfAbsent(lockKey, lockToken, APPLY_LOCK_SECONDS)) {
+ return rejectRealApplyForUnavailableLock(request, job, now, lockKey);
+ }
+
+ try {
+ List<ValidatedChange> validatedChanges = validateChanges(request, false, now);
+ boolean hasRejectedChange = hasRejectedChange(validatedChanges);
+ if (hasRejectedChange) {
+ markAcceptedChangesAsBatchRejected(validatedChanges);
+ }
+ if (hasRejectedChange) {
+ ApplyPersistenceResult persistenceResult = persistApplyResultInTransaction(
+ job,
+ request,
+ validatedChanges,
+ false,
+ now,
+ false
+ );
+ return buildResult(job, persistenceResult.getAuditChanges(), false);
+ }
+
try {
- applyValidatedChangesInTransaction(validatedChanges);
+ ApplyPersistenceResult persistenceResult = persistApplyResultInTransaction(
+ job,
+ request,
+ validatedChanges,
+ false,
+ now,
+ true
+ );
+ refreshSystemConfigCacheSafely(persistenceResult);
+ return buildResult(job, persistenceResult.getAuditChanges(), false);
} catch (RuntimeException exception) {
markWriteFailure(validatedChanges, exception);
+ Date failureNow = new Date();
+ AiAutoTuneJob failureJob = createJob(request, false, failureNow);
+ ApplyPersistenceResult persistenceResult = persistApplyResultInTransaction(
+ failureJob,
+ request,
+ validatedChanges,
+ false,
+ failureNow,
+ false
+ );
+ return buildResult(failureJob, persistenceResult.getAuditChanges(), false);
}
+ } finally {
+ redisUtil.compareAndDelete(lockKey, lockToken);
}
+ }
- List<AiAutoTuneChange> auditChanges = buildAuditChanges(job.getId(), validatedChanges, now);
- if (!auditChanges.isEmpty()) {
- aiAutoTuneChangeService.saveBatch(auditChanges);
+ private AutoTuneApplyResult rejectRealApplyForUnavailableLock(AutoTuneApplyRequest request,
+ AiAutoTuneJob job,
+ Date now,
+ String lockKey) {
+ boolean lockKeyExists = redisUtil.hasKey(lockKey);
+ LOGGER.warn("鐢宠AI鑷姩璋冨弬 apply 閿佸け璐ワ紝lockKey={}, lockKeyExists={}", lockKey, lockKeyExists);
+ List<ValidatedChange> validatedChanges = buildLockBusyChanges(request);
+ ApplyPersistenceResult persistenceResult = persistApplyResultInTransaction(
+ job,
+ request,
+ validatedChanges,
+ false,
+ now,
+ false
+ );
+ return buildResult(job, persistenceResult.getAuditChanges(), false);
+ }
+
+ private List<ValidatedChange> buildLockBusyChanges(AutoTuneApplyRequest request) {
+ List<ValidatedChange> validatedChanges = new ArrayList<>();
+ if (request.getChanges() == null || request.getChanges().isEmpty()) {
+ return validatedChanges;
}
- finishJob(job, safeRequest, auditChanges, dryRun, now);
- aiAutoTuneJobService.updateById(job);
- return buildResult(job, auditChanges, dryRun);
+ for (AutoTuneChangeCommand command : request.getChanges()) {
+ ValidatedChange validatedChange = new ValidatedChange(command);
+ validatedChange.fail(APPLY_LOCK_BUSY_REASON);
+ validatedChanges.add(validatedChange);
+ }
+ return validatedChanges;
}
@Override
public AutoTuneApplyResult rollbackLastSuccessfulJob(String reason) {
Date now = new Date();
AiAutoTuneJob rollbackJob = createRollbackJob(reason, now);
- aiAutoTuneJobService.save(rollbackJob);
- List<AiAutoTuneChange> sourceChanges = findLatestSuccessfulChanges();
- if (sourceChanges.isEmpty()) {
- rollbackJob.setStatus(AutoTuneJobStatus.REJECTED.getCode());
- rollbackJob.setFinishTime(now);
- rollbackJob.setRejectCount(0);
- rollbackJob.setSuccessCount(0);
- rollbackJob.setSummary("鏈壘鍒板彲鍥炴粴鐨勬垚鍔熻皟鍙傝褰�");
- rollbackJob.setErrorMessage("鏈壘鍒板彲鍥炴粴鐨勬垚鍔熻皟鍙傝褰�");
- aiAutoTuneJobService.updateById(rollbackJob);
- return buildResult(rollbackJob, new ArrayList<>(), false);
+ String lockKey = RedisKeyType.AI_AUTO_TUNE_APPLY_LOCK.key;
+ String lockToken = UUID.randomUUID().toString();
+ if (!redisUtil.trySetStringIfAbsent(lockKey, lockToken, APPLY_LOCK_SECONDS)) {
+ return rejectRollbackForUnavailableLock(reason, now, lockKey);
}
- List<AiAutoTuneChange> rollbackChanges = new ArrayList<>();
try {
- rollbackChanges = rollbackChangesInTransaction(rollbackJob.getId(), sourceChanges, now);
- } catch (RuntimeException exception) {
- rollbackChanges = buildFailedRollbackChanges(rollbackJob.getId(), sourceChanges, exception, now);
+ List<AiAutoTuneChange> sourceChanges = findLatestSuccessfulChanges();
+ if (sourceChanges.isEmpty()) {
+ persistNoRollbackSourceJobInTransaction(rollbackJob, now);
+ return buildResult(rollbackJob, new ArrayList<>(), false);
+ }
+ try {
+ RollbackPersistenceResult persistenceResult = persistRollbackResultInTransaction(
+ rollbackJob,
+ sourceChanges,
+ now
+ );
+ refreshRollbackConfigCacheSafely(persistenceResult);
+ return buildResult(rollbackJob, persistenceResult.getRollbackChanges(), false);
+ } catch (RuntimeException exception) {
+ Date failureNow = new Date();
+ AiAutoTuneJob failureJob = createRollbackJob(reason, failureNow);
+ RollbackPersistenceResult persistenceResult = persistFailedRollbackResultInTransaction(
+ failureJob,
+ sourceChanges,
+ exception,
+ failureNow
+ );
+ return buildResult(failureJob, persistenceResult.getRollbackChanges(), false);
+ }
+ } finally {
+ redisUtil.compareAndDelete(lockKey, lockToken);
}
- aiAutoTuneChangeService.saveBatch(rollbackChanges);
- finishRollbackJob(rollbackJob, rollbackChanges, now);
- aiAutoTuneJobService.updateById(rollbackJob);
- return buildResult(rollbackJob, rollbackChanges, false);
+ }
+
+ private AutoTuneApplyResult rejectRollbackForUnavailableLock(String reason,
+ Date now,
+ String lockKey) {
+ boolean lockKeyExists = redisUtil.hasKey(lockKey);
+ LOGGER.warn("鐢宠AI鑷姩璋冨弬 rollback 閿佸け璐ワ紝lockKey={}, lockKeyExists={}", lockKey, lockKeyExists);
+ AiAutoTuneJob rollbackJob = createRollbackJob(reason, now);
+ RollbackPersistenceResult persistenceResult = persistRollbackLockFailureInTransaction(
+ rollbackJob,
+ now
+ );
+ return buildResult(rollbackJob, persistenceResult.getRollbackChanges(), false);
}
private List<ValidatedChange> validateChanges(AutoTuneApplyRequest request, boolean dryRun, Date now) {
@@ -132,31 +269,37 @@
private ValidatedChange validateChange(AutoTuneChangeCommand command, boolean dryRun, Date now) {
ValidatedChange validatedChange = new ValidatedChange(command);
- AutoTuneRuleDefinition.Rule rule = AutoTuneRuleDefinition.findRule(command.getTargetType(), command.getTargetKey());
+ AutoTuneRuleDefinition.Rule rule = AutoTuneRuleDefinition.findRule(
+ validatedChange.getTargetType(),
+ validatedChange.getTargetKey()
+ );
if (rule == null) {
- return validatedChange.reject("涓嶆敮鎸佺殑璋冨弬鐩爣: " + command.getTargetType() + "/" + command.getTargetKey());
+ return validatedChange.reject("涓嶆敮鎸佺殑璋冨弬鐩爣: "
+ + validatedChange.getTargetType() + "/" + validatedChange.getTargetKey());
}
validatedChange.setRule(rule);
- Integer requestedValue = parseRequestedInt(command.getNewValue());
+ Integer requestedValue = parseRequestedInt(validatedChange.getRawRequestedValue());
if (requestedValue == null) {
- return validatedChange.reject(command.getTargetKey() + " 蹇呴』涓烘暣鏁�");
+ return validatedChange.reject(validatedChange.getTargetKey() + " 蹇呴』涓烘暣鏁�");
}
validatedChange.setRequestedIntValue(requestedValue);
validatedChange.setRequestedValue(String.valueOf(requestedValue));
- CurrentValue currentValue = readCurrentValueForValidation(command, rule);
+ CurrentValue currentValue = readCurrentValueForValidation(validatedChange, rule);
if (currentValue.getRejectReason() != null) {
return validatedChange.reject(currentValue.getRejectReason());
}
validatedChange.setOldValue(currentValue.getOldValue());
- Integer maxValue = resolveMaxValue(command, rule, requestedValue);
+ Integer maxValue = resolveMaxValue(validatedChange, rule, requestedValue);
if (maxValue == null) {
- return validatedChange.reject("绔欑偣 " + command.getTargetId() + " 缂哄皯 OUT 鏂瑰悜 bufferCapacity锛屾棤娉曡瘉鏄� outTaskLimit 涓婇檺");
+ return validatedChange.reject("绔欑偣 " + validatedChange.getTargetId()
+ + " 缂哄皯 outBufferCapacity锛屾棤娉曡瘉鏄� outTaskLimit 涓婇檺");
}
if (requestedValue < rule.getMinValue() || requestedValue > maxValue) {
- return validatedChange.reject(command.getTargetKey() + " 蹇呴』鍦� " + rule.getMinValue() + "~" + maxValue + " 鑼冨洿鍐�");
+ return validatedChange.reject(validatedChange.getTargetKey() + " 蹇呴』鍦� "
+ + rule.getMinValue() + "~" + maxValue + " 鑼冨洿鍐�");
}
if (Objects.equals(currentValue.getNumericValue(), requestedValue)) {
@@ -164,10 +307,10 @@
}
int step = Math.abs(requestedValue - currentValue.getNumericValue());
if (step > rule.getMaxStep()) {
- return validatedChange.reject(command.getTargetKey() + " 鍗曟璋冩暣姝ラ暱涓嶈兘瓒呰繃 " + rule.getMaxStep());
+ return validatedChange.reject(validatedChange.getTargetKey() + " 鍗曟璋冩暣姝ラ暱涓嶈兘瓒呰繃 " + rule.getMaxStep());
}
- Date cooldownExpireTime = findCooldownExpireTime(command, now);
+ Date cooldownExpireTime = findCooldownExpireTime(validatedChange, now);
if (cooldownExpireTime != null) {
validatedChange.setCooldownExpireTime(cooldownExpireTime);
return validatedChange.reject("鐩爣浠嶅湪鍐峰嵈鏈燂紝鍐峰嵈鎴鏃堕棿: " + cooldownExpireTime);
@@ -178,86 +321,81 @@
return validatedChange.accept(dryRun ? ChangeStatus.DRY_RUN : ChangeStatus.PENDING, null);
}
- private CurrentValue readCurrentValueForValidation(AutoTuneChangeCommand command, AutoTuneRuleDefinition.Rule rule) {
+ private CurrentValue readCurrentValueForValidation(ValidatedChange validatedChange, AutoTuneRuleDefinition.Rule rule) {
AutoTuneTargetType targetType = rule.getTargetType();
- Integer targetId = parseTargetId(command.getTargetId(), targetType);
+ Integer targetId = parseTargetId(validatedChange.getTargetId(), targetType);
if (!AutoTuneTargetType.SYS_CONFIG.equals(targetType) && targetId == null) {
return CurrentValue.rejected("targetId 蹇呴』涓烘暣鏁�");
}
if (AutoTuneTargetType.SYS_CONFIG.equals(targetType)) {
- Config config = configService.getOne(new QueryWrapper<Config>().eq("code", command.getTargetKey()).last("limit 1"));
+ Config config = configService.getOne(new QueryWrapper<Config>().eq("code", validatedChange.getTargetKey()).last("limit 1"));
if (config == null) {
- return CurrentValue.rejected("杩愯鍙傛暟涓嶅瓨鍦�: " + command.getTargetKey());
+ return CurrentValue.rejected("杩愯鍙傛暟涓嶅瓨鍦�: " + validatedChange.getTargetKey());
}
- return numericCurrentValue(config.getValue(), false, command.getTargetKey());
+ return numericCurrentValue(config.getValue(), validatedChange.getTargetKey());
}
if (AutoTuneTargetType.STATION.equals(targetType)) {
BasStation station = basStationService.getById(targetId);
if (station == null) {
- return CurrentValue.rejected("绔欑偣涓嶅瓨鍦�: " + command.getTargetId());
+ return CurrentValue.rejected("绔欑偣涓嶅瓨鍦�: " + validatedChange.getTargetId());
}
- return numericCurrentValue(toText(station.getOutTaskLimit()), true, command.getTargetKey());
+ return stationOutTaskLimitCurrentValue(station.getOutTaskLimit(), validatedChange.getTargetKey());
}
if (AutoTuneTargetType.CRN.equals(targetType)) {
BasCrnp crnp = basCrnpService.getById(targetId);
if (crnp == null) {
- return CurrentValue.rejected("鍫嗗灈鏈轰笉瀛樺湪: " + command.getTargetId());
+ return CurrentValue.rejected("鍫嗗灈鏈轰笉瀛樺湪: " + validatedChange.getTargetId());
}
- Integer value = "maxOutTask".equals(command.getTargetKey()) ? crnp.getMaxOutTask() : crnp.getMaxInTask();
- return numericCurrentValue(toText(value), false, command.getTargetKey());
+ Integer value = "maxOutTask".equals(validatedChange.getTargetKey()) ? crnp.getMaxOutTask() : crnp.getMaxInTask();
+ return numericCurrentValue(toText(value), validatedChange.getTargetKey());
}
BasDualCrnp dualCrnp = basDualCrnpService.getById(targetId);
if (dualCrnp == null) {
- return CurrentValue.rejected("鍙屽伐浣嶅爢鍨涙満涓嶅瓨鍦�: " + command.getTargetId());
+ return CurrentValue.rejected("鍙屽伐浣嶅爢鍨涙満涓嶅瓨鍦�: " + validatedChange.getTargetId());
}
- Integer value = "maxOutTask".equals(command.getTargetKey()) ? dualCrnp.getMaxOutTask() : dualCrnp.getMaxInTask();
- return numericCurrentValue(toText(value), false, command.getTargetKey());
+ Integer value = "maxOutTask".equals(validatedChange.getTargetKey()) ? dualCrnp.getMaxOutTask() : dualCrnp.getMaxInTask();
+ return numericCurrentValue(toText(value), validatedChange.getTargetKey());
}
- private CurrentValue numericCurrentValue(String oldValue, boolean nullOrNegativeAsZero, String targetKey) {
+ private CurrentValue stationOutTaskLimitCurrentValue(Integer outTaskLimit, String targetKey) {
+ if (outTaskLimit == null || outTaskLimit < 0) {
+ return CurrentValue.rejected(targetKey + " 褰撳墠涓轰笉闄愬埗锛岄渶瑕佷汉宸ュ厛鍒濆鍖栦负鏈夐檺鍊煎悗鎵嶈兘鑷姩璋冨弬");
+ }
+ return numericCurrentValue(toText(outTaskLimit), targetKey);
+ }
+
+ private CurrentValue numericCurrentValue(String oldValue, String targetKey) {
if (oldValue == null || oldValue.trim().isEmpty()) {
- if (nullOrNegativeAsZero) {
- return CurrentValue.accepted(null, 0);
- }
return CurrentValue.rejected(targetKey + " 褰撳墠鍊间负绌猴紝鏃犳硶璁＄畻姝ラ暱");
}
try {
Integer parsedValue = Integer.valueOf(oldValue.trim());
- if (nullOrNegativeAsZero && parsedValue < 0) {
- return CurrentValue.accepted(oldValue, 0);
- }
return CurrentValue.accepted(oldValue, parsedValue);
} catch (Exception exception) {
return CurrentValue.rejected(targetKey + " 褰撳墠鍊间笉鏄暣鏁帮紝鏃犳硶璁＄畻姝ラ暱");
}
}
- private Integer resolveMaxValue(AutoTuneChangeCommand command,
+ private Integer resolveMaxValue(ValidatedChange validatedChange,
AutoTuneRuleDefinition.Rule rule,
Integer requestedValue) {
if (!rule.isDynamicMaxValue()) {
return rule.getMaxValue();
}
- Integer targetId = parseTargetId(command.getTargetId(), rule.getTargetType());
- StationFlowCapacity capacity = stationFlowCapacityService.getOne(
- new QueryWrapper<StationFlowCapacity>()
- .eq("station_id", targetId)
- .eq("direction_code", DIRECTION_OUT)
- .last("limit 1")
- );
- if (capacity == null || capacity.getBufferCapacity() == null) {
+ Integer targetId = parseTargetId(validatedChange.getTargetId(), rule.getTargetType());
+ BasStation station = basStationService.getById(targetId);
+ if (station == null || station.getOutBufferCapacity() == null) {
return requestedValue == 0 ? 0 : null;
}
- return Math.max(0, capacity.getBufferCapacity());
+ return Math.max(0, station.getOutBufferCapacity());
}
- private Date findCooldownExpireTime(AutoTuneChangeCommand command, Date now) {
- String targetId = normalizeTargetId(command.getTargetType(), command.getTargetId());
+ private Date findCooldownExpireTime(ValidatedChange validatedChange, Date now) {
List<AiAutoTuneChange> recentChanges = aiAutoTuneChangeService.list(
new QueryWrapper<AiAutoTuneChange>()
- .eq("target_type", command.getTargetType())
- .eq("target_id", targetId)
- .eq("target_key", command.getTargetKey())
+ .eq("target_type", validatedChange.getTargetType())
+ .eq("target_id", validatedChange.getTargetId())
+ .eq("target_key", validatedChange.getTargetKey())
.eq("result_status", ChangeStatus.SUCCESS.getCode())
.gt("cooldown_expire_time", now)
.orderByDesc("create_time")
@@ -274,45 +412,150 @@
return cooldownExpireTime;
}
- private void applyValidatedChangesInTransaction(List<ValidatedChange> validatedChanges) {
- if (transactionManager == null) {
- applyValidatedChanges(validatedChanges);
- return;
- }
+ private ApplyPersistenceResult persistApplyResultInTransaction(AiAutoTuneJob job,
+ AutoTuneApplyRequest request,
+ List<ValidatedChange> validatedChanges,
+ boolean dryRun,
+ Date now,
+ boolean writeTargets) {
TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
- transactionTemplate.executeWithoutResult(status -> applyValidatedChanges(validatedChanges));
+ return transactionTemplate.execute(status -> persistApplyResult(
+ job,
+ request,
+ validatedChanges,
+ dryRun,
+ now,
+ writeTargets
+ ));
}
- private void applyValidatedChanges(List<ValidatedChange> validatedChanges) {
+ private ApplyPersistenceResult persistApplyResult(AiAutoTuneJob job,
+ AutoTuneApplyRequest request,
+ List<ValidatedChange> validatedChanges,
+ boolean dryRun,
+ Date now,
+ boolean writeTargets) {
+ saveJob(job);
+ boolean refreshConfigCache = false;
+ if (writeTargets) {
+ refreshConfigCache = applyValidatedChanges(validatedChanges);
+ }
+ List<AiAutoTuneChange> auditChanges = buildAuditChanges(job.getId(), validatedChanges, now);
+ saveAuditChanges(auditChanges);
+ finishJob(job, request, auditChanges, dryRun, now);
+ updateJob(job);
+ return new ApplyPersistenceResult(auditChanges, refreshConfigCache);
+ }
+
+ private void saveJob(AiAutoTuneJob job) {
+ if (!aiAutoTuneJobService.save(job)) {
+ throw new IllegalStateException("淇濆瓨璋冨弬浠诲姟澶辫触");
+ }
+ }
+
+ private boolean applyValidatedChanges(List<ValidatedChange> validatedChanges) {
boolean refreshConfigCache = false;
for (ValidatedChange validatedChange : validatedChanges) {
if (ChangeStatus.NO_CHANGE.equals(validatedChange.getStatus())) {
continue;
}
- AutoTuneChangeCommand command = validatedChange.getCommand();
- writeValue(command.getTargetType(), command.getTargetId(), command.getTargetKey(), validatedChange.getRequestedValue());
+ writeValue(
+ validatedChange.getTargetType(),
+ validatedChange.getTargetId(),
+ validatedChange.getTargetKey(),
+ validatedChange.getRequestedValue()
+ );
validatedChange.accept(ChangeStatus.SUCCESS, null);
validatedChange.setAppliedValue(validatedChange.getRequestedValue());
- if (AutoTuneTargetType.SYS_CONFIG.getCode().equals(command.getTargetType())) {
+ if (AutoTuneTargetType.SYS_CONFIG.getCode().equals(validatedChange.getTargetType())) {
refreshConfigCache = true;
}
}
- if (refreshConfigCache) {
- configService.refreshSystemConfigCache();
+ return refreshConfigCache;
+ }
+
+ private void saveAuditChanges(List<AiAutoTuneChange> auditChanges) {
+ if (auditChanges.isEmpty()) {
+ return;
+ }
+ if (!aiAutoTuneChangeService.saveBatch(auditChanges)) {
+ throw new IllegalStateException("淇濆瓨璋冨弬瀹¤澶辫触");
}
}
- private List<AiAutoTuneChange> rollbackChangesInTransaction(Long rollbackJobId,
- List<AiAutoTuneChange> sourceChanges,
- Date now) {
- if (transactionManager == null) {
- return rollbackChanges(rollbackJobId, sourceChanges, now);
+ private void updateJob(AiAutoTuneJob job) {
+ if (!aiAutoTuneJobService.updateById(job)) {
+ throw new IllegalStateException("鏇存柊璋冨弬浠诲姟鐘舵�佸け璐�");
}
+ }
+
+ private void refreshSystemConfigCacheSafely(ApplyPersistenceResult persistenceResult) {
+ if (persistenceResult != null && persistenceResult.isRefreshConfigCache()) {
+ refreshSystemConfigCacheSafely("apply");
+ }
+ }
+
+ private void persistNoRollbackSourceJobInTransaction(AiAutoTuneJob rollbackJob, Date now) {
TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
- return transactionTemplate.execute(status -> rollbackChanges(rollbackJobId, sourceChanges, now));
+ transactionTemplate.executeWithoutResult(status -> {
+ saveJob(rollbackJob);
+ rollbackJob.setStatus(AutoTuneJobStatus.REJECTED.getCode());
+ rollbackJob.setFinishTime(now);
+ rollbackJob.setRejectCount(0);
+ rollbackJob.setSuccessCount(0);
+ rollbackJob.setSummary("鏈壘鍒板彲鍥炴粴鐨勬垚鍔熻皟鍙傝褰�");
+ rollbackJob.setErrorMessage("鏈壘鍒板彲鍥炴粴鐨勬垚鍔熻皟鍙傝褰�");
+ updateJob(rollbackJob);
+ });
}
- private List<AiAutoTuneChange> rollbackChanges(Long rollbackJobId, List<AiAutoTuneChange> sourceChanges, Date now) {
+ private RollbackPersistenceResult persistRollbackResultInTransaction(AiAutoTuneJob rollbackJob,
+ List<AiAutoTuneChange> sourceChanges,
+ Date now) {
+ TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
+ return transactionTemplate.execute(status -> {
+ saveJob(rollbackJob);
+ RollbackPersistenceResult rollbackResult = rollbackChanges(rollbackJob.getId(), sourceChanges, now);
+ saveAuditChanges(rollbackResult.getRollbackChanges());
+ finishRollbackJob(rollbackJob, rollbackResult.getRollbackChanges(), now);
+ updateJob(rollbackJob);
+ return rollbackResult;
+ });
+ }
+
+ private RollbackPersistenceResult persistFailedRollbackResultInTransaction(AiAutoTuneJob rollbackJob,
+ List<AiAutoTuneChange> sourceChanges,
+ RuntimeException exception,
+ Date now) {
+ TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
+ return transactionTemplate.execute(status -> {
+ saveJob(rollbackJob);
+ List<AiAutoTuneChange> rollbackChanges = buildFailedRollbackChanges(
+ rollbackJob.getId(),
+ sourceChanges,
+ exception,
+ now
+ );
+ saveAuditChanges(rollbackChanges);
+ finishRollbackJob(rollbackJob, rollbackChanges, now);
+ updateJob(rollbackJob);
+ return new RollbackPersistenceResult(rollbackChanges, false);
+ });
+ }
+
+ private RollbackPersistenceResult persistRollbackLockFailureInTransaction(AiAutoTuneJob rollbackJob, Date now) {
+ TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
+ return transactionTemplate.execute(status -> {
+ saveJob(rollbackJob);
+ List<AiAutoTuneChange> rollbackChanges = buildRollbackLockFailureChanges(rollbackJob.getId(), now);
+ saveAuditChanges(rollbackChanges);
+ finishRollbackJob(rollbackJob, rollbackChanges, now);
+ updateJob(rollbackJob);
+ return new RollbackPersistenceResult(rollbackChanges, false);
+ });
+ }
+
+ private RollbackPersistenceResult rollbackChanges(Long rollbackJobId, List<AiAutoTuneChange> sourceChanges, Date now) {
List<AiAutoTuneChange> rollbackChanges = new ArrayList<>();
boolean refreshConfigCache = false;
for (AiAutoTuneChange sourceChange : sourceChanges) {
@@ -331,55 +574,90 @@
rollbackChange.setResultStatus(ChangeStatus.SUCCESS.getCode());
rollbackChanges.add(rollbackChange);
}
- if (refreshConfigCache) {
- configService.refreshSystemConfigCache();
+ return new RollbackPersistenceResult(rollbackChanges, refreshConfigCache);
+ }
+
+ private List<AiAutoTuneChange> buildRollbackLockFailureChanges(Long rollbackJobId, Date now) {
+ AiAutoTuneChange rollbackChange = new AiAutoTuneChange();
+ rollbackChange.setJobId(rollbackJobId);
+ rollbackChange.setTargetType(AutoTuneTriggerType.ROLLBACK.getCode());
+ rollbackChange.setTargetId("");
+ rollbackChange.setTargetKey("latest_successful_job");
+ rollbackChange.setResultStatus(ChangeStatus.FAILED.getCode());
+ rollbackChange.setRejectReason(APPLY_LOCK_BUSY_REASON);
+ rollbackChange.setCreateTime(now);
+ return List.of(rollbackChange);
+ }
+
+ private void refreshRollbackConfigCacheSafely(RollbackPersistenceResult persistenceResult) {
+ if (persistenceResult != null && persistenceResult.isRefreshConfigCache()) {
+ refreshSystemConfigCacheSafely("rollback");
}
- return rollbackChanges;
+ }
+
+ private void refreshSystemConfigCacheSafely(String scene) {
+ try {
+ configService.refreshSystemConfigCache();
+ } catch (RuntimeException exception) {
+ LOGGER.warn("AI鑷姩璋冨弬{}宸叉彁浜わ紝浣嗗埛鏂扮郴缁熼厤缃紦瀛樺け璐�", scene, exception);
+ }
}
private void writeValue(String targetType, String targetId, String targetKey, String value) {
- AutoTuneTargetType parsedTargetType = AutoTuneTargetType.fromCode(targetType);
+ String normalizedTargetType = normalizeText(targetType);
+ String normalizedTargetKey = normalizeText(targetKey);
+ String normalizedTargetId = normalizeTargetId(normalizedTargetType, targetId);
+ AutoTuneTargetType parsedTargetType = AutoTuneTargetType.fromCode(normalizedTargetType);
+ if (parsedTargetType == null) {
+ throw new IllegalArgumentException("涓嶆敮鎸佺殑璋冨弬鐩爣: " + normalizedTargetType + "/" + normalizedTargetKey);
+ }
if (AutoTuneTargetType.SYS_CONFIG.equals(parsedTargetType)) {
- if (!configService.saveConfigValue(targetKey, value)) {
- throw new IllegalStateException("淇濆瓨杩愯鍙傛暟澶辫触: " + targetKey);
+ if (!configService.saveConfigValue(normalizedTargetKey, value)) {
+ throw new IllegalStateException("淇濆瓨杩愯鍙傛暟澶辫触: " + normalizedTargetKey);
}
return;
}
- Integer parsedTargetId = parseTargetId(targetId, parsedTargetType);
+ Integer parsedTargetId = parseTargetId(normalizedTargetId, parsedTargetType);
Integer intValue = value == null ? null : Integer.valueOf(value);
if (AutoTuneTargetType.STATION.equals(parsedTargetType)) {
boolean updated = basStationService.update(new UpdateWrapper<BasStation>()
.eq("station_id", parsedTargetId)
.set("out_task_limit", intValue));
if (!updated) {
- throw new IllegalStateException("淇濆瓨绔欑偣鍙傛暟澶辫触: " + targetId + "/" + targetKey);
+ throw new IllegalStateException("淇濆瓨绔欑偣鍙傛暟澶辫触: " + normalizedTargetId + "/" + normalizedTargetKey);
}
return;
}
if (AutoTuneTargetType.CRN.equals(parsedTargetType)) {
- String column = "maxOutTask".equals(targetKey) ? "max_out_task" : "max_in_task";
+ String column = "maxOutTask".equals(normalizedTargetKey) ? "max_out_task" : "max_in_task";
boolean updated = basCrnpService.update(new UpdateWrapper<BasCrnp>()
.eq("crn_no", parsedTargetId)
.set(column, intValue));
if (!updated) {
- throw new IllegalStateException("淇濆瓨鍫嗗灈鏈哄弬鏁板け璐�: " + targetId + "/" + targetKey);
+ throw new IllegalStateException("淇濆瓨鍫嗗灈鏈哄弬鏁板け璐�: " + normalizedTargetId + "/" + normalizedTargetKey);
}
return;
}
- String column = "maxOutTask".equals(targetKey) ? "max_out_task" : "max_in_task";
+ String column = "maxOutTask".equals(normalizedTargetKey) ? "max_out_task" : "max_in_task";
boolean updated = basDualCrnpService.update(new UpdateWrapper<BasDualCrnp>()
.eq("crn_no", parsedTargetId)
.set(column, intValue));
if (!updated) {
- throw new IllegalStateException("淇濆瓨鍙屽伐浣嶅爢鍨涙満鍙傛暟澶辫触: " + targetId + "/" + targetKey);
+ throw new IllegalStateException("淇濆瓨鍙屽伐浣嶅爢鍨涙満鍙傛暟澶辫触: " + normalizedTargetId + "/" + normalizedTargetKey);
}
}
private String readCurrentValue(String targetType, String targetId, String targetKey) {
- AutoTuneTargetType parsedTargetType = AutoTuneTargetType.fromCode(targetType);
- Integer parsedTargetId = parseTargetId(targetId, parsedTargetType);
+ String normalizedTargetType = normalizeText(targetType);
+ String normalizedTargetKey = normalizeText(targetKey);
+ String normalizedTargetId = normalizeTargetId(normalizedTargetType, targetId);
+ AutoTuneTargetType parsedTargetType = AutoTuneTargetType.fromCode(normalizedTargetType);
+ if (parsedTargetType == null) {
+ throw new IllegalArgumentException("涓嶆敮鎸佺殑璋冨弬鐩爣: " + normalizedTargetType + "/" + normalizedTargetKey);
+ }
+ Integer parsedTargetId = parseTargetId(normalizedTargetId, parsedTargetType);
if (AutoTuneTargetType.SYS_CONFIG.equals(parsedTargetType)) {
- Config config = configService.getOne(new QueryWrapper<Config>().eq("code", targetKey).last("limit 1"));
+ Config config = configService.getOne(new QueryWrapper<Config>().eq("code", normalizedTargetKey).last("limit 1"));
return config == null ? null : config.getValue();
}
if (AutoTuneTargetType.STATION.equals(parsedTargetType)) {
@@ -391,13 +669,13 @@
if (crnp == null) {
return null;
}
- return toText("maxOutTask".equals(targetKey) ? crnp.getMaxOutTask() : crnp.getMaxInTask());
+ return toText("maxOutTask".equals(normalizedTargetKey) ? crnp.getMaxOutTask() : crnp.getMaxInTask());
}
BasDualCrnp dualCrnp = basDualCrnpService.getById(parsedTargetId);
if (dualCrnp == null) {
return null;
}
- return toText("maxOutTask".equals(targetKey) ? dualCrnp.getMaxOutTask() : dualCrnp.getMaxInTask());
+ return toText("maxOutTask".equals(normalizedTargetKey) ? dualCrnp.getMaxOutTask() : dualCrnp.getMaxInTask());
}
private AiAutoTuneJob createJob(AutoTuneApplyRequest request, boolean dryRun, Date now) {
@@ -405,7 +683,7 @@
job.setTriggerType(AutoTuneTriggerType.normalize(request.getTriggerType()));
job.setStatus(AutoTuneJobStatus.RUNNING.getCode());
job.setStartTime(now);
- job.setHasActiveTasks(0);
+ job.setHasActiveTasks(resolveHasActiveTasksForAudit());
job.setPromptSceneCode(PROMPT_SCENE_CODE);
job.setSummary(dryRun ? "AI鑷姩璋冨弬 dry-run: " + safeReason(request.getReason()) : safeReason(request.getReason()));
job.setIntervalBefore(readIntervalMinutes());
@@ -424,7 +702,7 @@
job.setTriggerType(AutoTuneTriggerType.ROLLBACK.getCode());
job.setStatus(AutoTuneJobStatus.RUNNING.getCode());
job.setStartTime(now);
- job.setHasActiveTasks(0);
+ job.setHasActiveTasks(resolveHasActiveTasksForAudit());
job.setPromptSceneCode(PROMPT_SCENE_CODE);
job.setSummary(safeReason(reason));
job.setIntervalBefore(readIntervalMinutes());
@@ -436,6 +714,21 @@
job.setTotalTokens(0);
job.setCreateTime(now);
return job;
+ }
+
+ private int resolveHasActiveTasksForAudit() {
+ if (wrkMastService == null) {
+ LOGGER.warn("AI鑷姩璋冨弬瀹¤鏃犳硶鑾峰彇 WrkMastService锛宧asActiveTasks 鎸� 0 璁板綍");
+ return 0;
+ }
+ try {
+ QueryWrapper<WrkMast> queryWrapper = new QueryWrapper<>();
+ queryWrapper.and(wrapper -> wrapper.notIn("wrk_sts", FINAL_WRK_STS_LIST).or().isNull("wrk_sts"));
+ return wrkMastService.count(queryWrapper) > 0 ? 1 : 0;
+ } catch (RuntimeException exception) {
+ LOGGER.warn("AI鑷姩璋冨弬瀹¤鏌ヨ鏈畬鎴愪换鍔″け璐ワ紝hasActiveTasks 鎸� 0 璁板綍", exception);
+ return 0;
+ }
}
private void finishJob(AiAutoTuneJob job,
@@ -463,7 +756,15 @@
job.setSuccessCount(successCount);
job.setRejectCount(rejectCount);
job.setIntervalAfter(readIntervalMinutes());
- job.setStatus(rejectCount == 0 ? AutoTuneJobStatus.SUCCESS.getCode() : AutoTuneJobStatus.PARTIAL_SUCCESS.getCode());
+ if (rejectCount == 0) {
+ job.setStatus(AutoTuneJobStatus.SUCCESS.getCode());
+ } else if (successCount == 0 && hasFailedChange(changes)) {
+ job.setStatus(AutoTuneJobStatus.FAILED.getCode());
+ } else if (successCount == 0) {
+ job.setStatus(AutoTuneJobStatus.REJECTED.getCode());
+ } else {
+ job.setStatus(AutoTuneJobStatus.PARTIAL_SUCCESS.getCode());
+ }
job.setSummary("鍥炴粴鏈�杩戜竴娆℃垚鍔熻皟鍙傦紝鎴愬姛 " + successCount + " 椤癸紝澶辫触 " + rejectCount + " 椤�");
if (rejectCount > 0) {
job.setErrorMessage(firstRejectReason(changes));
@@ -502,13 +803,14 @@
List<AiAutoTuneChange> auditChanges = new ArrayList<>();
for (ValidatedChange validatedChange : validatedChanges) {
AiAutoTuneChange change = new AiAutoTuneChange();
- AutoTuneChangeCommand command = validatedChange.getCommand();
change.setJobId(jobId);
- change.setTargetType(command.getTargetType());
- change.setTargetId(normalizeTargetId(command.getTargetType(), command.getTargetId()));
- change.setTargetKey(command.getTargetKey());
+ change.setTargetType(validatedChange.getTargetType());
+ change.setTargetId(validatedChange.getTargetId());
+ change.setTargetKey(validatedChange.getTargetKey());
change.setOldValue(validatedChange.getOldValue());
- change.setRequestedValue(validatedChange.getRequestedValue() == null ? command.getNewValue() : validatedChange.getRequestedValue());
+ change.setRequestedValue(validatedChange.getRequestedValue() == null
+ ? validatedChange.getRawRequestedValue()
+ : validatedChange.getRequestedValue());
change.setAppliedValue(validatedChange.getAppliedValue());
change.setResultStatus(validatedChange.getStatus().getCode());
change.setRejectReason(validatedChange.getRejectReason());
@@ -658,12 +960,16 @@
}
}
- private String normalizeTargetId(String targetType, String targetId) {
+ private static String normalizeTargetId(String targetType, String targetId) {
AutoTuneTargetType parsedTargetType = AutoTuneTargetType.fromCode(targetType);
if (AutoTuneTargetType.SYS_CONFIG.equals(parsedTargetType)) {
return "";
}
- return targetId == null ? "" : targetId.trim();
+ return normalizeText(targetId);
+ }
+
+ private static String normalizeText(String value) {
+ return value == null ? "" : value.trim();
}
private int readIntervalMinutes() {
@@ -732,8 +1038,48 @@
return null;
}
+ private static class ApplyPersistenceResult {
+ private final List<AiAutoTuneChange> auditChanges;
+ private final boolean refreshConfigCache;
+
+ private ApplyPersistenceResult(List<AiAutoTuneChange> auditChanges, boolean refreshConfigCache) {
+ this.auditChanges = auditChanges == null ? new ArrayList<>() : auditChanges;
+ this.refreshConfigCache = refreshConfigCache;
+ }
+
+ public List<AiAutoTuneChange> getAuditChanges() {
+ return auditChanges;
+ }
+
+ public boolean isRefreshConfigCache() {
+ return refreshConfigCache;
+ }
+ }
+
+ private static class RollbackPersistenceResult {
+ private final List<AiAutoTuneChange> rollbackChanges;
+ private final boolean refreshConfigCache;
+
+ private RollbackPersistenceResult(List<AiAutoTuneChange> rollbackChanges, boolean refreshConfigCache) {
+ this.rollbackChanges = rollbackChanges == null ? new ArrayList<>() : rollbackChanges;
+ this.refreshConfigCache = refreshConfigCache;
+ }
+
+ public List<AiAutoTuneChange> getRollbackChanges() {
+ return rollbackChanges;
+ }
+
+ public boolean isRefreshConfigCache() {
+ return refreshConfigCache;
+ }
+ }
+
private static class ValidatedChange {
private final AutoTuneChangeCommand command;
+ private final String targetType;
+ private final String targetId;
+ private final String targetKey;
+ private final String rawRequestedValue;
private AutoTuneRuleDefinition.Rule rule;
private String oldValue;
private String requestedValue;
@@ -745,6 +1091,10 @@
private ValidatedChange(AutoTuneChangeCommand command) {
this.command = command == null ? new AutoTuneChangeCommand() : command;
+ this.targetType = normalizeText(this.command.getTargetType());
+ this.targetId = normalizeTargetId(this.targetType, this.command.getTargetId());
+ this.targetKey = normalizeText(this.command.getTargetKey());
+ this.rawRequestedValue = this.command.getNewValue();
}
private ValidatedChange reject(String reason) {
@@ -773,6 +1123,22 @@
return command;
}
+ public String getTargetType() {
+ return targetType;
+ }
+
+ public String getTargetId() {
+ return targetId;
+ }
+
+ public String getTargetKey() {
+ return targetKey;
+ }
+
+ public String getRawRequestedValue() {
+ return rawRequestedValue;
+ }
+
public AutoTuneRuleDefinition.Rule getRule() {
return rule;
}
--
Gitblit v1.9.1