package com.zy.ai.service.impl;
|
|
import com.alibaba.fastjson.JSON;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.zy.ai.domain.autotune.AutoTuneControlModeSnapshot;
|
import com.zy.ai.domain.autotune.AutoTuneJobStatus;
|
import com.zy.ai.domain.autotune.AutoTuneTriggerType;
|
import com.zy.ai.entity.AiAutoTuneMcpCall;
|
import com.zy.ai.entity.AiAutoTuneJob;
|
import com.zy.ai.enums.AiPromptScene;
|
import com.zy.ai.service.AiAutoTuneJobService;
|
import com.zy.ai.service.AiAutoTuneMcpCallService;
|
import com.zy.ai.service.AutoTuneAgentService;
|
import com.zy.ai.service.AutoTuneControlModeService;
|
import com.zy.ai.service.AutoTuneCoordinatorService;
|
import com.zy.asrs.entity.WrkMast;
|
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.OperateLog;
|
import com.zy.system.service.ConfigService;
|
import com.zy.system.service.OperateLogService;
|
import lombok.RequiredArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Date;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.UUID;
|
|
@Slf4j
|
@Service("autoTuneCoordinatorService")
|
@RequiredArgsConstructor
|
public class AutoTuneCoordinatorServiceImpl implements AutoTuneCoordinatorService {
|
|
private static final String CONFIG_INTERVAL_MINUTES = "aiAutoTuneIntervalMinutes";
|
private static final int DEFAULT_INTERVAL_MINUTES = 10;
|
private static final int MIN_INTERVAL_MINUTES = 5;
|
private static final int MAX_INTERVAL_MINUTES = 60;
|
private static final int RUNNING_LOCK_SECONDS = 20 * 60;
|
private static final long SYSTEM_USER_ID = 9527L;
|
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
|
);
|
|
private final ConfigService configService;
|
private final AutoTuneControlModeService autoTuneControlModeService;
|
private final WrkMastService wrkMastService;
|
private final AiAutoTuneJobService aiAutoTuneJobService;
|
private final AiAutoTuneMcpCallService aiAutoTuneMcpCallService;
|
private final AutoTuneAgentService autoTuneAgentService;
|
private final RedisUtil redisUtil;
|
private final OperateLogService operateLogService;
|
|
@Override
|
public AutoTuneCoordinatorResult runAutoTuneIfEligible() {
|
if (!isEnabled()) {
|
return AutoTuneCoordinatorResult.skipped("disabled");
|
}
|
|
int intervalMinutes = resolveIntervalMinutes();
|
if (!hasActiveTasks()) {
|
return AutoTuneCoordinatorResult.skipped("no_active_tasks");
|
}
|
if (isLastTriggerGuardActive()) {
|
return AutoTuneCoordinatorResult.skipped("last_trigger_guard_active");
|
}
|
|
AiAutoTuneJob latestSuccessfulJob = latestSuccessfulAutoJob();
|
if (!isIntervalReached(latestSuccessfulJob, intervalMinutes)) {
|
return AutoTuneCoordinatorResult.skipped("interval_not_reached");
|
}
|
|
return runAgentWithLock(AutoTuneTriggerType.AUTO.getCode(), intervalMinutes, true);
|
}
|
|
@Override
|
public AutoTuneCoordinatorResult runManualAutoTune() {
|
return runAgentWithLock(AutoTuneTriggerType.MANUAL.getCode(), null, false);
|
}
|
|
private AutoTuneCoordinatorResult runAgentWithLock(String triggerType, Integer intervalMinutes, boolean writeGuard) {
|
String lockKey = RedisKeyType.AI_AUTO_TUNE_RUNNING_LOCK.key;
|
String lockToken = UUID.randomUUID().toString();
|
if (!redisUtil.trySetStringIfAbsent(lockKey, lockToken, RUNNING_LOCK_SECONDS)) {
|
return AutoTuneCoordinatorResult.skipped("running_lock_not_acquired");
|
}
|
|
AutoTuneAgentService.AutoTuneAgentResult agentResult = null;
|
Date startTime = new Date();
|
try {
|
if (writeGuard && intervalMinutes != null) {
|
safeMarkLastTriggerGuard(intervalMinutes);
|
}
|
agentResult = autoTuneAgentService.runAutoTune(triggerType);
|
safeWriteOperateLog(agentResult);
|
safeWriteAgentRunAudit(triggerType, startTime, agentResult);
|
return AutoTuneCoordinatorResult.triggered(agentResult);
|
} catch (Exception exception) {
|
log.error("Auto tune coordinator failed to run agent", exception);
|
agentResult = failedAgentResult(triggerType, exception);
|
safeWriteOperateLog(agentResult);
|
safeWriteAgentRunAudit(triggerType, startTime, agentResult);
|
return AutoTuneCoordinatorResult.triggered(agentResult);
|
} finally {
|
redisUtil.compareAndDelete(lockKey, lockToken);
|
}
|
}
|
|
private boolean isEnabled() {
|
AutoTuneControlModeSnapshot controlMode = autoTuneControlModeService.currentMode();
|
return controlMode != null && Boolean.TRUE.equals(controlMode.getEnabled());
|
}
|
|
private int resolveIntervalMinutes() {
|
String value = configService.getConfigValue(CONFIG_INTERVAL_MINUTES, String.valueOf(DEFAULT_INTERVAL_MINUTES));
|
try {
|
int intervalMinutes = Integer.parseInt(value.trim());
|
if (intervalMinutes < MIN_INTERVAL_MINUTES || intervalMinutes > MAX_INTERVAL_MINUTES) {
|
return DEFAULT_INTERVAL_MINUTES;
|
}
|
return intervalMinutes;
|
} catch (Exception exception) {
|
return DEFAULT_INTERVAL_MINUTES;
|
}
|
}
|
|
private boolean hasActiveTasks() {
|
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;
|
}
|
|
private boolean isLastTriggerGuardActive() {
|
Object guardValue = redisUtil.get(RedisKeyType.AI_AUTO_TUNE_LAST_TRIGGER_GUARD.key);
|
return guardValue != null;
|
}
|
|
private AiAutoTuneJob latestSuccessfulAutoJob() {
|
QueryWrapper<AiAutoTuneJob> queryWrapper = new QueryWrapper<>();
|
queryWrapper.eq("status", AutoTuneJobStatus.SUCCESS.getCode());
|
queryWrapper.eq("trigger_type", AutoTuneTriggerType.AUTO.getCode());
|
queryWrapper.last("order by coalesce(finish_time, create_time) desc limit 1");
|
List<AiAutoTuneJob> jobs = aiAutoTuneJobService.list(queryWrapper);
|
if (jobs == null || jobs.isEmpty()) {
|
return null;
|
}
|
return jobs.get(0);
|
}
|
|
private boolean isIntervalReached(AiAutoTuneJob latestSuccessfulJob, int intervalMinutes) {
|
if (latestSuccessfulJob == null) {
|
return true;
|
}
|
Date latestFinishTime = latestSuccessfulJob.getFinishTime();
|
if (latestFinishTime == null) {
|
latestFinishTime = latestSuccessfulJob.getCreateTime();
|
}
|
if (latestFinishTime == null) {
|
return true;
|
}
|
long intervalMillis = intervalMinutes * 60L * 1000L;
|
return System.currentTimeMillis() - latestFinishTime.getTime() >= intervalMillis;
|
}
|
|
private void safeMarkLastTriggerGuard(int intervalMinutes) {
|
try {
|
markLastTriggerGuard(intervalMinutes);
|
} catch (Exception exception) {
|
log.warn("Auto tune coordinator failed to write last trigger guard", exception);
|
}
|
}
|
|
private void markLastTriggerGuard(int intervalMinutes) {
|
long expireSeconds = intervalMinutes * 60L;
|
redisUtil.set(RedisKeyType.AI_AUTO_TUNE_LAST_TRIGGER_GUARD.key,
|
String.valueOf(System.currentTimeMillis()), expireSeconds);
|
}
|
|
private AutoTuneAgentService.AutoTuneAgentResult failedAgentResult(String triggerType, Exception exception) {
|
AutoTuneControlModeSnapshot controlMode = autoTuneControlModeService.currentMode();
|
AutoTuneAgentService.AutoTuneAgentResult result = new AutoTuneAgentService.AutoTuneAgentResult();
|
result.setSuccess(false);
|
result.setTriggerType(triggerType);
|
result.setSummary("自动调参后台任务执行异常: " + exception.getMessage());
|
result.setToolCallCount(0);
|
result.setLlmCallCount(0);
|
result.setPromptTokens(0L);
|
result.setCompletionTokens(0L);
|
result.setTotalTokens(0L);
|
result.setMaxRoundsReached(false);
|
result.setAnalysisOnly(controlMode.getAnalysisOnly());
|
result.setAllowApply(controlMode.getAllowApply());
|
result.setExecutionMode(controlMode.getModeCode());
|
result.setActualApplyCalled(false);
|
result.setRollbackCalled(false);
|
result.setSuccessCount(0);
|
result.setRejectCount(0);
|
result.setMcpCalls(new ArrayList<>());
|
return result;
|
}
|
|
private void safeWriteAgentRunAudit(String triggerType,
|
Date startTime,
|
AutoTuneAgentService.AutoTuneAgentResult agentResult) {
|
try {
|
writeAgentRunAudit(triggerType, startTime, agentResult);
|
} catch (Exception exception) {
|
log.warn("Auto tune coordinator failed to write agent run audit", exception);
|
}
|
}
|
|
private void writeAgentRunAudit(String triggerType,
|
Date startTime,
|
AutoTuneAgentService.AutoTuneAgentResult agentResult) {
|
if (agentResult == null) {
|
return;
|
}
|
Date finishTime = new Date();
|
Integer intervalMinutes = resolveIntervalMinutes();
|
AiAutoTuneJob job = new AiAutoTuneJob();
|
job.setTriggerType(AutoTuneTriggerType.normalize(triggerType));
|
job.setStatus(resolveAuditStatus(agentResult));
|
job.setStartTime(startTime == null ? finishTime : startTime);
|
job.setFinishTime(finishTime);
|
job.setHasActiveTasks(resolveHasActiveTasksForAudit());
|
job.setPromptSceneCode(AiPromptScene.AUTO_TUNE_DISPATCH.getCode());
|
job.setSummary(agentResult.getSummary());
|
job.setIntervalBefore(intervalMinutes);
|
job.setIntervalAfter(intervalMinutes);
|
job.setSuccessCount(safeCount(agentResult.getSuccessCount()));
|
job.setRejectCount(safeCount(agentResult.getRejectCount()));
|
if (isErrorAuditStatus(job.getStatus())) {
|
job.setErrorMessage(agentResult.getSummary());
|
}
|
job.setLlmCallCount(agentResult.getLlmCallCount() == null ? 0 : agentResult.getLlmCallCount());
|
job.setPromptTokens(toSafeInteger(agentResult.getPromptTokens()));
|
job.setCompletionTokens(toSafeInteger(agentResult.getCompletionTokens()));
|
job.setTotalTokens(toSafeInteger(agentResult.getTotalTokens()));
|
job.setCreateTime(job.getStartTime());
|
if (!aiAutoTuneJobService.save(job)) {
|
log.warn("Auto tune coordinator failed to save agent run audit");
|
return;
|
}
|
safeWriteMcpCallAudit(job.getId(), agentResult);
|
}
|
|
private void safeWriteMcpCallAudit(Long agentJobId, AutoTuneAgentService.AutoTuneAgentResult agentResult) {
|
try {
|
writeMcpCallAudit(agentJobId, agentResult);
|
} catch (Exception exception) {
|
log.warn("Auto tune coordinator failed to write MCP call audit", exception);
|
}
|
}
|
|
private void writeMcpCallAudit(Long agentJobId, AutoTuneAgentService.AutoTuneAgentResult agentResult) {
|
if (agentJobId == null || agentResult == null || agentResult.getMcpCalls() == null
|
|| agentResult.getMcpCalls().isEmpty()) {
|
return;
|
}
|
List<AiAutoTuneMcpCall> mcpCalls = new ArrayList<>();
|
Date createTime = new Date();
|
for (AutoTuneAgentService.McpCallResult callResult : agentResult.getMcpCalls()) {
|
mcpCalls.add(toMcpCallEntity(agentJobId, callResult, createTime));
|
}
|
if (!aiAutoTuneMcpCallService.saveBatch(mcpCalls)) {
|
log.warn("Auto tune coordinator failed to save MCP call audit");
|
}
|
}
|
|
private AiAutoTuneMcpCall toMcpCallEntity(Long agentJobId,
|
AutoTuneAgentService.McpCallResult callResult,
|
Date createTime) {
|
AiAutoTuneMcpCall mcpCall = new AiAutoTuneMcpCall();
|
mcpCall.setAgentJobId(agentJobId);
|
mcpCall.setCallSeq(callResult.getCallSeq());
|
mcpCall.setToolName(callResult.getToolName());
|
mcpCall.setStatus(callResult.getStatus());
|
mcpCall.setDryRun(toTinyInt(callResult.getDryRun()));
|
mcpCall.setApplyJobId(callResult.getApplyJobId());
|
mcpCall.setSuccessCount(safeCount(callResult.getSuccessCount()));
|
mcpCall.setRejectCount(safeCount(callResult.getRejectCount()));
|
mcpCall.setDurationMs(callResult.getDurationMs());
|
mcpCall.setRequestJson(callResult.getRequestJson());
|
mcpCall.setResponseJson(callResult.getResponseJson());
|
mcpCall.setErrorMessage(callResult.getErrorMessage());
|
mcpCall.setCreateTime(createTime);
|
return mcpCall;
|
}
|
|
private Integer toTinyInt(Boolean value) {
|
if (value == null) {
|
return null;
|
}
|
return value ? 1 : 0;
|
}
|
|
private String resolveAuditStatus(AutoTuneAgentService.AutoTuneAgentResult agentResult) {
|
int successCount = safeCount(agentResult.getSuccessCount());
|
int rejectCount = safeCount(agentResult.getRejectCount());
|
if (!Boolean.TRUE.equals(agentResult.getSuccess())) {
|
if (successCount > 0 && rejectCount > 0) {
|
return AutoTuneJobStatus.PARTIAL_SUCCESS.getCode();
|
}
|
if (rejectCount > 0) {
|
return AutoTuneJobStatus.REJECTED.getCode();
|
}
|
return AutoTuneJobStatus.FAILED.getCode();
|
}
|
if (successCount > 0 && rejectCount > 0) {
|
return AutoTuneJobStatus.PARTIAL_SUCCESS.getCode();
|
}
|
if (rejectCount > 0) {
|
return AutoTuneJobStatus.REJECTED.getCode();
|
}
|
if (Boolean.TRUE.equals(agentResult.getActualApplyCalled())
|
|| Boolean.TRUE.equals(agentResult.getRollbackCalled())) {
|
return AutoTuneJobStatus.SUCCESS.getCode();
|
}
|
return AutoTuneJobStatus.NO_CHANGE.getCode();
|
}
|
|
private boolean isErrorAuditStatus(String status) {
|
return AutoTuneJobStatus.FAILED.getCode().equals(status)
|
|| AutoTuneJobStatus.REJECTED.getCode().equals(status)
|
|| AutoTuneJobStatus.PARTIAL_SUCCESS.getCode().equals(status);
|
}
|
|
private int safeCount(Integer value) {
|
return value == null ? 0 : value;
|
}
|
|
private int resolveHasActiveTasksForAudit() {
|
try {
|
return hasActiveTasks() ? 1 : 0;
|
} catch (RuntimeException exception) {
|
log.warn("Auto tune coordinator failed to query active tasks for audit", exception);
|
return 0;
|
}
|
}
|
|
private Integer toSafeInteger(Long value) {
|
if (value == null) {
|
return 0;
|
}
|
if (value > Integer.MAX_VALUE) {
|
return Integer.MAX_VALUE;
|
}
|
if (value < Integer.MIN_VALUE) {
|
return Integer.MIN_VALUE;
|
}
|
return value.intValue();
|
}
|
|
private void safeWriteOperateLog(AutoTuneAgentService.AutoTuneAgentResult agentResult) {
|
try {
|
writeOperateLog(agentResult);
|
} catch (Exception exception) {
|
log.warn("Auto tune coordinator failed to write operate log", exception);
|
}
|
}
|
|
private void writeOperateLog(AutoTuneAgentService.AutoTuneAgentResult agentResult) {
|
if (agentResult == null) {
|
return;
|
}
|
OperateLog operateLog = new OperateLog();
|
operateLog.setAction(resolveOperateLogAction(agentResult));
|
operateLog.setUserId(SYSTEM_USER_ID);
|
operateLog.setIp("system");
|
operateLog.setRequest(JSON.toJSONString(buildRequestSummary(agentResult)));
|
operateLog.setResponse(JSON.toJSONString(buildResponseSummary(agentResult)));
|
operateLog.setCreateTime(new Date());
|
operateLogService.save(operateLog);
|
}
|
|
private String resolveOperateLogAction(AutoTuneAgentService.AutoTuneAgentResult agentResult) {
|
if (agentResult != null && AutoTuneTriggerType.MANUAL.getCode().equals(agentResult.getTriggerType())) {
|
return "ai_auto_tune_manual_trigger";
|
}
|
return "ai_auto_tune_background_scheduler";
|
}
|
|
private Map<String, Object> buildRequestSummary(AutoTuneAgentService.AutoTuneAgentResult agentResult) {
|
Map<String, Object> request = new LinkedHashMap<>();
|
request.put("trigger", agentResult.getTriggerType());
|
request.put("analysisOnly", agentResult.getAnalysisOnly());
|
request.put("allowApply", agentResult.getAllowApply());
|
request.put("executionMode", agentResult.getExecutionMode());
|
return request;
|
}
|
|
private Map<String, Object> buildResponseSummary(AutoTuneAgentService.AutoTuneAgentResult agentResult) {
|
Map<String, Object> response = new LinkedHashMap<>();
|
response.put("success", agentResult.getSuccess());
|
response.put("summary", agentResult.getSummary());
|
response.put("analysisOnly", agentResult.getAnalysisOnly());
|
response.put("allowApply", agentResult.getAllowApply());
|
response.put("executionMode", agentResult.getExecutionMode());
|
response.put("toolCallCount", agentResult.getToolCallCount());
|
response.put("llmCallCount", agentResult.getLlmCallCount());
|
response.put("promptTokens", agentResult.getPromptTokens());
|
response.put("completionTokens", agentResult.getCompletionTokens());
|
response.put("totalTokens", agentResult.getTotalTokens());
|
response.put("maxRoundsReached", agentResult.getMaxRoundsReached());
|
response.put("actualApplyCalled", agentResult.getActualApplyCalled());
|
response.put("rollbackCalled", agentResult.getRollbackCalled());
|
response.put("successCount", agentResult.getSuccessCount());
|
response.put("rejectCount", agentResult.getRejectCount());
|
response.put("mcpCallCount", agentResult.getMcpCalls() == null ? 0 : agentResult.getMcpCalls().size());
|
return response;
|
}
|
}
|
