qinyanlei
/
inspect
1
0
Fork 0
Code Issues 0 Pull Requests 0 Projects 0 Releases 0 Wiki Activity
Browse Source

还原“redis key对应巡视任务”的修改，等系统稳定了再改

master
lijiuwei 9 months ago
parent
25fb82f71a
commit
dfb8188113
8 changed files with 156 additions and 157 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +8
    -9
      inspect-base/inspect-base-core/src/main/java/com/inspect/base/core/constant/RedisConst.java
  2. +0
    -23
      inspect-base/inspect-base-redis/src/main/java/com/inspect/base/redis/service/RedisService.java
  3. +106
    -81
      inspect-job/src/main/java/com/inspect/job/task/JobMainTask.java
  4. +18
    -18
      inspect-main/inspect-main-task-exec/src/main/java/com/inspect/exec/controller/PatrolTaskExecController.java
  5. +7
    -9
      inspect-main/inspect-main-task-exec/src/main/java/com/inspect/exec/controller/PatrolTaskExecuteSchedulerController.java
  6. +4
    -4
      inspect-main/inspect-main-task/src/main/java/com/inspect/partrolresult/controller/PatrolResultController.java
  7. +1
    -1
      inspect-main/inspect-main-task/src/main/java/com/inspect/task/controller/PatrolTaskController.java
  8. +12
    -12
      inspect-main/inspect-main-task/src/main/java/com/inspect/taskstatus/controller/PatrolTaskStatusController.java

+ 8
- 9
inspect-base/inspect-base-core/src/main/java/com/inspect/base/core/constant/RedisConst.java View File

@ -1,17 +1,16 @@
package com.inspect.base.core.constant;
public class RedisConst {
// public static final String TASK_PATROL_ID_EX = "TASK+PATROL+ID@";//没有获取该key的地方
// public static final String TASK_PATROL_STOP = "PATROL_TASK_STOP";//没有获取该key的地方
public static final String TASK_CODE_EX = "TASK_CODE@*";//查询匹配用
public static final String TASK_PATROL_ID = "TASK_PATROL_ID@";
public static final String TASK_PATROL_STATE = "TASK_PATROL_STATE@";
public static final String TASK_PATROL_ID = "TASK_PATROL_ID";
public static final String TASK_PATROL_ID_EX = "TASK+PATROL+ID@";
public static final String TASK_PATROL_STATE = "TASK_PATROL_STATE";
public static final String TASK_PATROL_STOP = "PATROL_TASK_STOP";
public static final String TASK_CODE = "TASK_CODE@";
public static final String TASK_RECORD_CNT = "TASK_RECORD_CNT@";
public static final String TASK_CODE_EX = "TASK_CODE@*";
public static final String TASK_RECORD_CNT = "TASK_RECORD_CNT";
public static final String TASK_CURRENT_CODE = "TASK_CURRENT_CODE@";
public static final String TASK_REPEAT_CODE = "TASK_REPEAT_CODE@";
public static final String TASK_TIMER_CLOCK = "TASK_TIMER_CLOCK@";
public static final String IMMEDIATELY_EXEC_TASK_TIME = "IMMEDIATELY_EXEC_TASK_TIME@";
public static final String TASK_TIMER_CLOCK = "TASK_TIMER_CLOCK";
public static final String IMMEDIATELY_EXEC_TASK_TIME = "IMMEDIATELY_EXEC_TASK_TIME";
public static final String REQUEST_UUID = "REQUEST_UUID@";
}

+ 0
- 23
inspect-base/inspect-base-redis/src/main/java/com/inspect/base/redis/service/RedisService.java View File

@ -31,23 +31,11 @@ public class RedisService {
redisTemplate.opsForValue().set(key, value);
}
public <T> void setCacheObjectOfTask(String key, String taskCode, T value) {
//logger.info(Color.MAGENTA + "[GABRIEL] setCacheObject key: {}" + Color.END, key);
redisTemplate.opsForValue().set(key + taskCode, value);
logger.info("RedisService.trace setCacheObjectOfTask: {}", key + taskCode);
}
public <T> void setCacheObject(String key, T value, Long timeout, TimeUnit timeUnit) {
//logger.info(Color.MAGENTA + "[GABRIEL] setCacheObject2 key: {}" + Color.END, key);
redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
}
public <T> void setCacheObjectOfTask(String key, String taskCode, T value, Long timeout, TimeUnit timeUnit) {
//logger.info(Color.MAGENTA + "[GABRIEL] setCacheObject2 key: {}" + Color.END, key);
redisTemplate.opsForValue().set(key + taskCode, value, timeout, timeUnit);
logger.info("RedisService.trace setCacheObjectOfTask2: {}", key + taskCode);
}
public boolean expire(String key, long timeout) {
return expire(key, timeout, TimeUnit.SECONDS);
}
@ -69,21 +57,10 @@ public class RedisService {
return operation.get(key);
}
public <T> T getCacheObjectOfTask(String key, String taskCode) {
ValueOperations<String, T> operation = redisTemplate.opsForValue();
logger.info("RedisService.trace getCacheObjectOfTask: {}", key + taskCode);
return operation.get(key + taskCode);
}
public boolean deleteObject(String key) {
return redisTemplate.delete(key).booleanValue();
}
public boolean deleteObjectOfTask(String key, String taskCode) {
logger.info("RedisService.trace deleteObjectOfTask: {}", key + taskCode);
return redisTemplate.delete(key + taskCode).booleanValue();
}
public long deleteObject(Collection collection) {
return redisTemplate.delete(collection).longValue();
}


+ 106
- 81
inspect-job/src/main/java/com/inspect/job/task/JobMainTask.java View File

@ -71,7 +71,7 @@ public class JobMainTask {
private String BIG_FILE_POINT = "BIG_FILE_POINT";
private String API_CONTROL_PRESET = "/api/v1/control/preset";
private static Map<String, Integer> execRecordCounterMap = new HashMap<>();
private static int execRecordCounter = 0;
@Value("${liveSIPB.url}")
private String liveIVS_URL;
@ -164,7 +164,7 @@ public class JobMainTask {
week = intervalExecuteTime[i];
time = cycleExecuteTimes[i].replaceAll(StringUtils.COLON, StringUtils.EMPTY);
if (day == Integer.parseInt(week) && task.getCycleExecuteTime() != null) {
// redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
}
}
} else if (StringUtils.isNotEmpty(task.getCycleWeek())) {
@ -174,7 +174,7 @@ public class JobMainTask {
week = intervalExecuteTime[i];
time = cycleExecuteTimes[i].replaceAll(StringUtils.COLON, StringUtils.EMPTY);
if (currentWeek.equals(week)) {
// redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
}
}
}
@ -188,7 +188,7 @@ public class JobMainTask {
}
time = hour + minute + cycleExecuteTime[2];
// redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
}
} else if ("2".equals(task.getIntervalType())) {
for (j = 0; j < task.getIntervalNumber(); ++j) {
@ -196,7 +196,7 @@ public class JobMainTask {
intervalExecuteTime[0] = String.valueOf(Integer.parseInt(intervalExecuteTime[0]) + 1);
}
// redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
}
}
}
@ -893,37 +893,37 @@ public class JobMainTask {
// return value;
// }
private void resetTaskTimerClock(String taskPatrolId) {
redisService.setCacheObjectOfTask(RedisConst.TASK_TIMER_CLOCK, taskPatrolId, System.currentTimeMillis());
private void resetTaskTimerClock() {
redisService.setCacheObject(RedisConst.TASK_TIMER_CLOCK, System.currentTimeMillis());
}
private void resetExecRecordCounter(String taskPatrolId) {
execRecordCounterMap.put(taskPatrolId, 0);
private void resetExecRecordCounter() {
execRecordCounter = 0;
}
synchronized private void taskStartInitialize(String taskPatrolId) {
resetTaskTimerClock(taskPatrolId);
resetExecRecordCounter(taskPatrolId);
synchronized private void taskStartInitialize() {
resetTaskTimerClock();
resetExecRecordCounter();
}
synchronized private void resetRecordCounter(String taskPatrolId) {
resetExecRecordCounter(taskPatrolId);
redisService.setCacheObjectOfTask(RedisConst.TASK_RECORD_CNT, taskPatrolId, 0);
synchronized private void resetRecordCounter() {
resetExecRecordCounter();
redisService.setCacheObject(RedisConst.TASK_RECORD_CNT, 0);
}
synchronized private void resetRedisCurrentCode(String taskPatrolId) {
final String taskCode = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskPatrolId);
synchronized private void resetRedisCurrentCode() {
final String taskCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
if (StringUtils.isNotEmpty(taskCode)) {
redisService.deleteObject(taskCode);
}
redisService.deleteObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskPatrolId);
redisService.deleteObject(RedisConst.TASK_CURRENT_CODE);
}
synchronized private void calcExecCostTime(final String oldPatrolId) {
Long startTime = redisService.getCacheObjectOfTask(RedisConst.TASK_TIMER_CLOCK, oldPatrolId);
Long startTime = redisService.getCacheObject(RedisConst.TASK_TIMER_CLOCK);
if (startTime != null) {
log.info(Color.MAGENTA + "[JOB] TASK: [{}], COST: [{} ms]" + Color.END, oldPatrolId, System.currentTimeMillis() - startTime);
redisService.setCacheObjectOfTask(RedisConst.TASK_TIMER_CLOCK, oldPatrolId, 0L);
redisService.setCacheObject(RedisConst.TASK_TIMER_CLOCK, 0L);
}
}
@ -934,9 +934,7 @@ public class JobMainTask {
final int finish = execRecord.getFinishNumber();
log.info(Color.GREEN + "[JOB] cursor:{}, finish:{}, total:{}, patrolId:{}" + Color.END, cursor, finish, total, taskPatrolId);
if (cursor == total) {
Integer execRecordCounter = execRecordCounterMap.get(taskPatrolId);
execRecordCounter++;
execRecordCounterMap.put(taskPatrolId, execRecordCounter);
execRecord.setEndTime(new Date());
if (finish == total) { // record下的点全部执行成功
//仅仅靠一个record成功执行不能代表所有的record都执行成功,只能设置该record执行成功标记
@ -954,19 +952,19 @@ public class JobMainTask {
totalProgress,
TaskStatus.DONE.getCode()
);
final Integer redisRecCnt = redisService.getCacheObjectOfTask(RedisConst.TASK_RECORD_CNT, taskPatrolId);
final Integer redisRecCnt = redisService.getCacheObject(RedisConst.TASK_RECORD_CNT);
log.info(Color.MAGENTA + "RECORD ROUND, patrolId: {}, recordCounter: {}, redisRecCnt: {}" + Color.END, taskPatrolId, execRecordCounter, redisRecCnt);
if (execRecordCounter == redisRecCnt) { // 最后一个record
resetRecordCounter(taskPatrolId);
final String repeatCode = redisService.getCacheObjectOfTask(RedisConst.TASK_REPEAT_CODE, taskPatrolId);
resetRecordCounter();
final String repeatCode = redisService.getCacheObject(RedisConst.TASK_REPEAT_CODE);
if (StringUtils.isEmpty(repeatCode)) {
//所有的records都完美的执行成功, 要把redis标记清除，不然以后的任务如何执行？
resetRedisCurrentCode(taskPatrolId);
resetRedisCurrentCode();
}
String redisImmediatelyExecTaskTime = redisService.getCacheObjectOfTask(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, taskPatrolId);
String redisImmediatelyExecTaskTime = redisService.getCacheObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME);
if (!StringUtils.isEmpty(redisImmediatelyExecTaskTime)) {
redisService.deleteObjectOfTask(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, taskPatrolId);
redisService.deleteObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME);
}
calcExecCostTime(execRecord.getOldTaskPatrolId());
}
@ -976,17 +974,17 @@ public class JobMainTask {
times--;
execRecord.setRebootTimes(times);
execRecord.setCursorNumber(0);
final int redisRecCnt = redisService.getCacheObjectOfTask(RedisConst.TASK_RECORD_CNT, taskPatrolId);
final int redisRecCnt = redisService.getCacheObject(RedisConst.TASK_RECORD_CNT);
log.info(Color.MAGENTA + "[JOB] TIMES > 0, taskPatrolId: {}, execRecordCounter: {}, redisRecCnt: {}" + Color.END, taskPatrolId, execRecordCounter, redisRecCnt);
if (execRecordCounter == redisRecCnt) {//最后一个record, 复位
resetRecordCounter(taskPatrolId);
resetRecordCounter();
calcExecCostTime(execRecord.getOldTaskPatrolId());
}
final String repeatCode = redisService.getCacheObjectOfTask(RedisConst.TASK_REPEAT_CODE, taskPatrolId);
final String repeatCode = redisService.getCacheObject(RedisConst.TASK_REPEAT_CODE);
if (StringUtils.isEmpty(repeatCode)) {
log.info(Color.MAGENTA + "[JOB] SET REPEAT FLAG patrolId: {}" + Color.END, taskPatrolId);
String taskRepeatCode = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskPatrolId);
redisService.setCacheObjectOfTask(RedisConst.TASK_REPEAT_CODE, taskPatrolId, taskRepeatCode);
String taskRepeatCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
redisService.setCacheObject(RedisConst.TASK_REPEAT_CODE, taskRepeatCode);
}
} else if (times == 0) {//一个record的尝试次数为0，其它的record正在执行中
//设置本record的执行状态为终止
@ -1003,11 +1001,11 @@ public class JobMainTask {
TaskStatus.DONE.getCode()
);
//在不知道其它record是否执行完毕的情况下，不能把TASK_CURRENT_CODE锁删除
final int redisRecCnt = redisService.getCacheObjectOfTask(RedisConst.TASK_RECORD_CNT, execRecord.getTaskPatrolId());
final int redisRecCnt = redisService.getCacheObject(RedisConst.TASK_RECORD_CNT);
log.info(Color.MAGENTA + "[JOB] TIMES 0, execRecordCounter: {}, redisRecCnt: {}" + Color.END, execRecordCounter, redisRecCnt);
if (execRecordCounter == redisRecCnt) {
resetRecordCounter(execRecord.getTaskPatrolId());
resetRedisCurrentCode(taskPatrolId);
resetRecordCounter();
resetRedisCurrentCode();
calcExecCostTime(execRecord.getOldTaskPatrolId());
}
}
@ -1071,7 +1069,7 @@ public class JobMainTask {
}
//unused
@SuppressWarnings({"unused"})
private void prePointExceSilenceControl(PatrolTask task, List<PatrolTaskInfo> patrolTaskInfoList, SimpleDateFormat sdf) {
if (patrolTaskInfoList != null && !patrolTaskInfoList.isEmpty()) {
PatrolTaskInfo patrolTaskInfo = patrolTaskInfoList.get(0);
@ -1387,22 +1385,22 @@ public class JobMainTask {
@PostMapping({"/immediatelyExecTask"})
public void immediatelyExecTask(@RequestBody PatrolTask patrolTask) {
String taskCode = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, patrolTask.getTaskId().toString());
// if (StringUtils.isNotEmpty(taskCode)) {
// log.info(Color.CYAN + "[JOB] TASK SLOT IS TAKEN BY: {}" + Color.END, taskCode);
// return;
// }
String taskCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
if (StringUtils.isNotEmpty(taskCode)) {
log.info(Color.CYAN + "[JOB] TASK SLOT IS TAKEN BY: {}" + Color.END, taskCode);
return;
}
PatrolTaskInfo patrolTaskInfo = new PatrolTaskInfo();
List<PatrolTask> patrolTaskList = new ArrayList<>();
patrolTaskList.add(patrolTask);
List<PatrolTask> cameraPatrolTasks = new ArrayList<>();
assembleVideoTask(patrolTaskList, cameraPatrolTasks);
String redisImmediatelyExecTaskTime = redisService.getCacheObjectOfTask(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, patrolTask.getTaskCode());
// if (redisImmediatelyExecTaskTime != null) {
// log.info(Color.RED + "[JOB IMMEDIATE] IMMEDIATELY_EXEC_TASK_TIME TASK TAKEN :{}" + Color.END, redisImmediatelyExecTaskTime);
// return;
// }
String redisImmediatelyExecTaskTime = redisService.getCacheObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME);
if (redisImmediatelyExecTaskTime != null) {
log.info(Color.RED + "[JOB IMMEDIATE] IMMEDIATELY_EXEC_TASK_TIME TASK TAKEN :{}" + Color.END, redisImmediatelyExecTaskTime);
return;
}
if (shaoXinBigModel.isSwitchStatus()) {
log.info("[BIG] Temporary gathering, close bigSwitch in nacos");
@ -1410,15 +1408,14 @@ public class JobMainTask {
}
String immediatelyExecTaskTime = DateUtils.parseDateToStr(DateUtils.yyyyMMddHHmmss, new Date());
redisService.setCacheObjectOfTask(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, patrolTask.getTaskCode(), immediatelyExecTaskTime);
log.info(Color.CYAN + "[JOB IMMEDIATE] TASK_CURRENT_CODE: {}, value: {}" + Color.END, RedisConst.TASK_CURRENT_CODE + patrolTask.getTaskCode(), RedisConst.TASK_CODE + patrolTask.getTaskCode() + StringUtils.AT + immediatelyExecTaskTime);
redisService.setCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, patrolTask.getTaskCode(), RedisConst.TASK_CODE + patrolTask.getTaskCode() + StringUtils.AT + immediatelyExecTaskTime);
taskStartInitialize(patrolTask.getTaskCode());
redisService.setCacheObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, immediatelyExecTaskTime);
log.info(Color.CYAN + "[JOB IMMEDIATE] TASK_CURRENT_CODE: {}, value: {}" + Color.END, RedisConst.TASK_CURRENT_CODE, RedisConst.TASK_CODE + patrolTask.getTaskCode() + StringUtils.AT + immediatelyExecTaskTime);
redisService.setCacheObject(RedisConst.TASK_CURRENT_CODE, RedisConst.TASK_CODE + patrolTask.getTaskCode() + StringUtils.AT + immediatelyExecTaskTime);
taskStartInitialize();
log.info(Color.CYAN + "[JOB IMMEDIATE] TASK REC CNT: {}" + Color.END, cameraPatrolTasks.size());
setRedisRecordCount(patrolTask.getTaskCode(), cameraPatrolTasks.size());
setRedisRecordCount(cameraPatrolTasks.size());
for (PatrolTask task : cameraPatrolTasks) {
List<PatrolTaskInfo> taskInfos = getInfosByRecord(PatrolTaskExecRecord.builder().devNo(task.getDevNo()).taskId(task.getTaskId()).build());
PatrolTaskExecRecord patrolTaskExecRecord = new PatrolTaskExecRecord();
Date time = task.getFixedStartTime();
String timeStr = time == null ? immediatelyExecTaskTime : DateUtils.parseDateToStr(DateUtils.yyyyMMddHHmmss, time);
@ -1460,7 +1457,6 @@ public class JobMainTask {
.devType("2")
.build());
return patrolTaskInfoMaintainAreaRemove(patrolTaskInfoList);
} catch (Exception e) {
log.error("[JOB] getInfosByTaskCode exception: {}", e.getMessage());
return patrolTaskInfoList;
@ -1481,21 +1477,21 @@ public class JobMainTask {
}
}
private void incrementRedisRecordCounter(String patrolTaskCode) {
Integer redisRecCnt = redisService.getCacheObjectOfTask(RedisConst.TASK_RECORD_CNT, patrolTaskCode);
private void incrementRedisRecordCounter() {
Integer redisRecCnt = redisService.getCacheObject(RedisConst.TASK_RECORD_CNT);
if (redisRecCnt == null) {
redisRecCnt = 1;
redisService.setCacheObjectOfTask(RedisConst.TASK_RECORD_CNT, patrolTaskCode, redisRecCnt);
redisService.setCacheObject(RedisConst.TASK_RECORD_CNT, redisRecCnt);
} else {
redisRecCnt++;
redisService.setCacheObjectOfTask(RedisConst.TASK_RECORD_CNT, patrolTaskCode, redisRecCnt);
redisService.setCacheObject(RedisConst.TASK_RECORD_CNT, redisRecCnt);
}
log.info(Color.GREEN + "[JOB] redisRecCnt: {}" + Color.END, redisRecCnt);
}
private void setRedisRecordCount(String patrolTaskCode, final int size) {
redisService.setCacheObjectOfTask(RedisConst.TASK_RECORD_CNT, patrolTaskCode, size);
private void setRedisRecordCount(final int size) {
redisService.setCacheObject(RedisConst.TASK_RECORD_CNT, size);
}
private String getTaskPatrolId(final PatrolTask patrolTask) {
@ -1509,10 +1505,10 @@ public class JobMainTask {
}
public void execEveryDayTask(List<PatrolTask> patrolTaskList) {
setRedisRecordCount(patrolTaskList.size());
for (PatrolTask patrolTask : patrolTaskList) {
List<PatrolTaskInfo> taskInfos = getInfosByRecord(PatrolTaskExecRecord.builder().devNo(patrolTask.getDevNo()).taskId(patrolTask.getTaskId()).build());
final String taskPatrolId = getTaskPatrolId(patrolTask);
setRedisRecordCount(taskPatrolId,patrolTaskList.size());
final String oldTaskPatrolId = getOldTaskPatrolId(patrolTask);
log.info(Color.GREEN + "[JOB] NEW EXEC RECORD: {}, OLD: {}" + Color.END, taskPatrolId, oldTaskPatrolId);
PatrolTaskExecRecord patrolTaskExecRecord = PatrolTaskExecRecord.builder()
@ -1568,7 +1564,7 @@ public class JobMainTask {
int times = execRecord.getRebootTimes();
if (finish < total) {
log.info(Color.GREEN + "[JOB] REPEAT EXEC RECORD: id: {}, finish: {}, total: {}, times: {}, progress: {}" + Color.END, execRecord.getTaskPatrolId(), finish, total, times, execRecord.getTaskProgress());
incrementRedisRecordCounter(taskPatrolId);
incrementRedisRecordCounter();
threadPool.submit(() -> {
log.info(Color.MAGENTA + "[JOB] REPEAT START devNo: {}, taskId: {}" + Color.END, execRecord.getDevNo(), execRecord.getTaskId());
prePointExecImmediate(execRecord);
@ -1675,7 +1671,6 @@ public class JobMainTask {
}
log.info("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!resList size: {}", resList.size());
return resList;
}
@ -1877,50 +1872,80 @@ public class JobMainTask {
return nf.format(decimalFormatNum * 100.0F);
}
private boolean isTaskSlotEmpty(String taskCode) {
String taskCurrentCode = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskCode);
String taskRepeatCode = redisService.getCacheObjectOfTask(RedisConst.TASK_REPEAT_CODE, taskCode); //repeat空了就不执行
Integer redisRecCnt = redisService.getCacheObjectOfTask(RedisConst.TASK_RECORD_CNT, taskCode);
@SuppressWarnings({"unused"})
public void execEveryDayTask() {
if (isTaskSlotEmpty()) {
Collection<String> redisKeys = redisService.keys(RedisConst.TASK_CODE_EX);
for (String redisKey : redisKeys) {
String[] keywords = StringUtils.split(redisKey, StringUtils.AT);
if (keywords.length == 3) {
String taskCode = keywords[1];
String fixedStartTime = keywords[2];
long currentDays = TimeUnit.MILLISECONDS.toDays(System.currentTimeMillis());
long fixedDays = TimeUnit.MILLISECONDS.toDays(DateUtils.parse(DateUtils.yyyyMMddHHmmss2, fixedStartTime).getTime());
long currentMinutes = TimeUnit.MILLISECONDS.toMinutes(System.currentTimeMillis());
long fixedStartMinutes = TimeUnit.MILLISECONDS.toMinutes(DateUtils.parse(DateUtils.yyyyMMddHHmmss2, fixedStartTime).getTime());
if (currentDays == fixedDays && currentMinutes >= fixedStartMinutes) {
//if ("1220".equals(taskCode))
{
//log.info("[GABRIEL] key: {}, curMin: {}, fixedMin:{}\n , curDay: {}, fixedDay:{}!", key, currentMinutes, fixedStartMinutes, currentDays, fixedDays);
extractRedisTask(redisKey);
}
}
}
}
} else {
// log.info(Color.YELLOW + "[JOB] CUR: [{}] IS TAKEN, REPEAT: {}, redisRecCnt: {}" + Color.END,
// redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE),
// redisService.getCacheObject(RedisConst.TASK_REPEAT_CODE),
// redisService.getCacheObject(RedisConst.TASK_RECORD_CNT));
}
}
private boolean isTaskSlotEmpty() {
String taskCurrentCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
String taskRepeatCode = redisService.getCacheObject(RedisConst.TASK_REPEAT_CODE); //repeat空了就不执行
Integer redisRecCnt = redisService.getCacheObject(RedisConst.TASK_RECORD_CNT);
log.info(Color.YELLOW + "[JOB] TASK_CURRENT_CODE@: [{}] TAKEN, TASK_REPEAT_CODE@: {}, TASK_RECORD_CNT: {}" + Color.END, taskCurrentCode, taskRepeatCode, redisRecCnt);
return StringUtils.isEmpty(taskCurrentCode) ||
!StringUtils.isEmpty(taskCurrentCode) && !StringUtils.isEmpty(taskRepeatCode) && (redisRecCnt == null || redisRecCnt == 0);
}
private boolean isTaskRunning(String taskCode) {
final String taskCurrentCode = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskCode);
private boolean isTaskRunning() {
final String taskCurrentCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
return StringUtils.isNotEmpty(taskCurrentCode);
}
private boolean isTaskRepeatPending(String taskCode) {
final String taskCurrentCode = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskCode);
final String taskRepeatCode = redisService.getCacheObjectOfTask(RedisConst.TASK_REPEAT_CODE, taskCode);
private boolean isTaskRepeatPending() {
final String taskCurrentCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
final String taskRepeatCode = redisService.getCacheObject(RedisConst.TASK_REPEAT_CODE);
return StringUtils.isNotEmpty(taskCurrentCode)
&& StringUtils.isNotEmpty(taskRepeatCode)
&& taskCurrentCode.equals(taskRepeatCode);
}
private void clearRepeatTask(String taskCode) {
redisService.deleteObjectOfTask(RedisConst.TASK_REPEAT_CODE, taskCode);
private void clearRepeatTask() {
redisService.deleteObject(RedisConst.TASK_REPEAT_CODE);
}
synchronized private void extractRedisTask(String taskCode, String redisKey) {
if (!isTaskRunning(taskCode)) {/*执行新任务*/
synchronized private void extractRedisTask(String redisKey) {
if (!isTaskRunning()) {/*执行新任务*/
List<PatrolTask> patrolTaskList = JSON.parseArray(redisService.getCacheObject(redisKey), PatrolTask.class);
if (patrolTaskList != null && !patrolTaskList.isEmpty()) {
log.info(Color.GREEN + "[JOB] ADD NEW TASK [{}], TASK LIST SIZE: {}" + Color.END, redisKey, patrolTaskList.size());
redisService.setCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskCode, redisKey);
taskStartInitialize(patrolTaskList.get(0).getTaskCode());
redisService.setCacheObject(RedisConst.TASK_CURRENT_CODE, redisKey);
taskStartInitialize();
execEveryDayTask(patrolTaskList);
}
}
if (isTaskRunning(taskCode) && isTaskRepeatPending(taskCode)) {/*执行需要再次执行的任务*/
clearRepeatTask(taskCode);
if (isTaskRunning() && isTaskRepeatPending()) {/*执行需要再次执行的任务*/
clearRepeatTask();
log.info(Color.GREEN + "[JOB] REPEAT TASK [{}]" + Color.END, redisKey);
List<PatrolTask> patrolTaskList = JSON.parseArray(redisService.getCacheObject(redisKey), PatrolTask.class);
if (patrolTaskList != null && !patrolTaskList.isEmpty()) {
taskStartInitialize(patrolTaskList.get(0).getTaskCode());
taskStartInitialize();
execRepeatDayTask(patrolTaskList);
}
}


+ 18
- 18
inspect-main/inspect-main-task-exec/src/main/java/com/inspect/exec/controller/PatrolTaskExecController.java View File

@ -286,27 +286,27 @@ public class PatrolTaskExecController extends BaseController {
updateTaskExecRecord(TaskStatus.RUNNING.getCode(), execRecords);
} else if (TaskStatus.HALTED.getCode().equals(state)) {
updateTaskExecRecord(TaskStatus.HALTED.getCode(), execRecords);
String redisImmediatelyExecTaskTime = redisService.getCacheObjectOfTask(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, taskCode);
String redisImmediatelyExecTaskTime = redisService.getCacheObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME);
if (StringUtils.isNotEmpty(redisImmediatelyExecTaskTime)) {
redisService.deleteObjectOfTask(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, taskCode);
redisService.deleteObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME);
}
Integer redisTaskPatrolState = redisService.getCacheObjectOfTask(RedisConst.TASK_PATROL_STATE, taskCode);
Integer redisTaskPatrolState = redisService.getCacheObject(RedisConst.TASK_PATROL_STATE);
if (redisTaskPatrolState != null) {
redisService.deleteObjectOfTask(RedisConst.TASK_PATROL_STATE, taskCode);
redisService.deleteObject(RedisConst.TASK_PATROL_STATE);
}
String redisTaskPatrolId = redisService.getCacheObjectOfTask(RedisConst.TASK_PATROL_ID, taskCode);
String redisTaskPatrolId = redisService.getCacheObject(RedisConst.TASK_PATROL_ID);
if (!StringUtils.isEmpty(redisTaskPatrolId)) {
redisService.deleteObjectOfTask(RedisConst.TASK_PATROL_ID, taskCode);
redisService.deleteObject(RedisConst.TASK_PATROL_ID);
}
String key = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskCode);
String key = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
if (key != null) {
log.info("[TASK] [{}] FINISH", key);
redisService.deleteObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskCode);
boolean b = redisService.deleteObject(key);
log.info("[TASK] [{}] REMOVE FROM QUEUE:{}", key, b);
redisService.deleteObject(RedisConst.TASK_CURRENT_CODE);
log.info("[TASK] [{}] REMOVE FROM QUEUE", key);
redisService.deleteObject(key);
}
}
}
@ -350,7 +350,7 @@ public class PatrolTaskExecController extends BaseController {
//log.info("[TASK] MODIFY SUCCESS state:{}", state);
if (TaskStatus.PAUSED.getCode().equals(state)) {
//log.info("[TASK] MODIFY ADD STOP TIME, state:{}", state);
// redisService.setCacheMapValue(RedisConst.TASK_PATROL_STOP, execRecord.getDevNo() + "&" + execRecord.getTaskPatrolId(), new Date());
redisService.setCacheMapValue(RedisConst.TASK_PATROL_STOP, execRecord.getDevNo() + "&" + execRecord.getTaskPatrolId(), new Date());
}
}
@ -392,7 +392,7 @@ public class PatrolTaskExecController extends BaseController {
execRecord.setManualPauseState("1");
this.patrolTaskExecRecordService.updatePatrolTaskExecRecord(execRecord);
this.log.info("[EXEC] STOP TASK: {}", JSONObject.toJSONString(execRecord));
// this.redisService.setCacheMapValue(RedisConst.TASK_PATROL_STOP, execRecord.getDevNo() + "&" + execRecord.getTaskPatrolId(), new Date());
this.redisService.setCacheMapValue(RedisConst.TASK_PATROL_STOP, execRecord.getDevNo() + "&" + execRecord.getTaskPatrolId(), new Date());
return true;
}
@ -641,10 +641,10 @@ public class PatrolTaskExecController extends BaseController {
@PostMapping({"/execCurrentDayTask"})
public void execCurrentDayTask() throws ParseException {
// String taskCodeStr = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
// if (!StringUtils.isEmpty(taskCodeStr)) {
// this.log.info(" 【当前正在执行的任务：{}, 其它任务不能执行！！！】", taskCodeStr);
// } else {
String taskCodeStr = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
if (!StringUtils.isEmpty(taskCodeStr)) {
this.log.info(" 【当前正在执行的任务：{}, 其它任务不能执行！！！】", taskCodeStr);
} else {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
for (String key : this.redisService.keys(RedisConst.TASK_CODE_EX)) {
String fixedStartTime = key.split(StringUtils.AT)[2];
@ -656,12 +656,12 @@ public class PatrolTaskExecController extends BaseController {
extracted(key, key);
}
}
// }
}
}
private void extracted(String key, String taskCode) {
log.info(Color.RED + "[EXEC] Add new task [{}]" + Color.END, key);
redisService.setCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, taskCode, key);
redisService.setCacheObject(RedisConst.TASK_CURRENT_CODE, key);
log.info("[EXEC] key: {}", key);
List<PatrolTask> cameraPatrolTasks = redisService.getCacheObject(key);
if (!cameraPatrolTasks.isEmpty()) {


+ 7
- 9
inspect-main/inspect-main-task-exec/src/main/java/com/inspect/exec/controller/PatrolTaskExecuteSchedulerController.java View File

@ -127,14 +127,12 @@ public class PatrolTaskExecuteSchedulerController extends BaseController {
String immediatelyExecTaskTime = "";
Iterator iterator = cameraPatrolTasks.iterator();
while (true) {
PatrolTask task = null;
PatrolTask task;
while (true) {
do {
if (!iterator.hasNext()) {
if (immediatelyExecTaskTime != null && !immediatelyExecTaskTime.isEmpty()) {
if(task != null) {
this.redisService.deleteObjectOfTask(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, task.getTaskCode());
}
this.redisService.deleteObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME);
}
return;
@ -165,20 +163,20 @@ public class PatrolTaskExecuteSchedulerController extends BaseController {
this.log.info("暂停当前执行任务 {} ", "taskName:" + patrolTaskExecRecord.getTaskName() + " taskCode:" + patrolTaskExecRecord.getTaskCode() + " execPointId:" + patrolTaskExecRecord.getExecPointId() + " deviceId:" + patrolTaskPointExecRecord.getDeviceId());
patrolTaskExecRecord.setTaskState("3");
this.taskExecClient.updatePatrolTaskExecRecord(patrolTaskExecRecord);
// this.log.info("修改执行状态成功=state:3 ");
// this.log.info("====================暂停添加时间记录=state:3");
// this.redisService.setCacheMapValue(RedisConst.TASK_PATROL_STOP, patrolTaskExecRecord.getDevNo() + "&" + patrolTaskExecRecord.getTaskPatrolId(), new Date());
this.log.info("修改执行状态成功=state:3 ");
this.log.info("====================暂停添加时间记录=state:3");
this.redisService.setCacheMapValue(RedisConst.TASK_PATROL_STOP, patrolTaskExecRecord.getDevNo() + "&" + patrolTaskExecRecord.getTaskPatrolId(), new Date());
break;
}
}
PatrolTaskExecRecord patrolTaskExecRecord = new PatrolTaskExecRecord();
if (immediatelyExecTaskTime != null && !immediatelyExecTaskTime.isEmpty()) {
immediatelyExecTaskTime = this.redisService.getCacheObjectOfTask(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, patrolTaskExecRecord.getTaskPatrolId());
immediatelyExecTaskTime = this.redisService.getCacheObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME);
} else {
SimpleDateFormat sdfOld = new SimpleDateFormat("yyyyMMddHHmmss");
immediatelyExecTaskTime = sdfOld.format(new Date());
this.redisService.setCacheObjectOfTask(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, patrolTaskExecRecord.getTaskPatrolId(), immediatelyExecTaskTime);
this.redisService.setCacheObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME, immediatelyExecTaskTime);
}
Date time = task.getFixedStartTime();


+ 4
- 4
inspect-main/inspect-main-task/src/main/java/com/inspect/partrolresult/controller/PatrolResultController.java View File

@ -1274,9 +1274,9 @@ public class PatrolResultController extends BaseController {
if (str.equals("13")) {
datetype = "3";
} else if (!str.equals("1") && !str.equals("2") && !str.equals("3")) {
datetype = str.equals("14") ? "4" : "1";
datetype = str.equals("14") ? "4" : "2";
} else {
datetype = "2";
datetype = "1";
}
}
}
@ -1388,9 +1388,9 @@ public class PatrolResultController extends BaseController {
if (strfile.equals("13")) {
arr.setDataType("3");
} else if (!strfile.equals("1") && !strfile.equals("2") && !strfile.equals("3")) {
arr.setDataType(strfile.equals("14") ? "4" : "1");
arr.setDataType(strfile.equals("14") ? "4" : "2");
} else {
arr.setDataType("2");
arr.setDataType("1");
}
}
}


+ 1
- 1
inspect-main/inspect-main-task/src/main/java/com/inspect/task/controller/PatrolTaskController.java View File

@ -397,7 +397,7 @@ public class PatrolTaskController extends BaseController {
List<PatrolTask> eqList = toPatrolTaskList(parseObject, flag);
makeupPatrolTaskDetails(eqList, flag);
PatrolTask patrolTask = eqList.get(0);
String key = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, patrolTask.getTaskId().toString());
String key = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
if (key != null && key.contains(String.valueOf(patrolTask.getTaskId()))) {
return AjaxResult.error("Task is executing, modify forbidden!");
}


+ 12
- 12
inspect-main/inspect-main-task/src/main/java/com/inspect/taskstatus/controller/PatrolTaskStatusController.java View File

@ -514,7 +514,7 @@ public class PatrolTaskStatusController extends BaseController {
//立即执行任务
@GetMapping({"/controlChange"})
public AjaxResult controlChange(PatrolTask patrolTask) {
String taskCode = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, patrolTask.getTaskId().toString());
String taskCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
if (!StringUtils.isEmpty(taskCode)) {
log.info("[TASK] CURRENT EXEC TASK: {}", taskCode);
return AjaxResult.error(501, "THERE TASK IS RUNNING!");
@ -548,7 +548,7 @@ public class PatrolTaskStatusController extends BaseController {
private void extracted(PatrolTask patrolTask) throws InterruptedException {
Thread.sleep(20000L);
String taskCode = redisService.getCacheObjectOfTask(RedisConst.TASK_CURRENT_CODE, patrolTask.getTaskId().toString());
String taskCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
if (taskCode != null && taskCode.contains(String.valueOf(patrolTask.getTaskId()))) {
this.log.info("[TASK STATUS] UPDATE TASK: {} STATUS to IMMEDIATE", taskCode);
PatrolTaskStatus patrolTaskStatus = new PatrolTaskStatus();
@ -713,24 +713,24 @@ public class PatrolTaskStatusController extends BaseController {
if (!TaskStatus.DONE.getCode().equals(patrolTaskStatus.getCommand())) {
if (TaskStatus.RUNNING.getCode().equals(patrolTaskStatus.getCommand())) {
cmd = TaskStatus.PAUSED.getCode();
redisService.setCacheObjectOfTask(RedisConst.TASK_PATROL_ID, patrolTaskStatus.getTaskCode(), patrolTaskStatus.getTaskPatrolledId());
redisService.setCacheObjectOfTask(RedisConst.TASK_PATROL_STATE, patrolTaskStatus.getTaskCode(), cmd);
redisService.setCacheObject(RedisConst.TASK_PATROL_ID, patrolTaskStatus.getTaskPatrolledId());
redisService.setCacheObject(RedisConst.TASK_PATROL_STATE, cmd);
log.info("[TASK] PAUSE, UPDATE STATUS STATE: {}, patrolId: {}", DescUtil.getTaskStatusDesc(cmd), patrolTaskStatus.getTaskPatrolledId());
} else if (TaskStatus.PAUSED.getCode().equals(patrolTaskStatus.getCommand())) {
cmd = TaskStatus.RUNNING.getCode();
redisService.deleteObjectOfTask(RedisConst.TASK_PATROL_ID, patrolTaskStatus.getTaskCode());
redisService.deleteObjectOfTask(RedisConst.TASK_PATROL_STATE, patrolTaskStatus.getTaskCode());
redisTaskPatrolId = redisService.getCacheObjectOfTask(RedisConst.TASK_PATROL_ID, patrolTaskStatus.getTaskCode());
String redisTaskPatrolState = redisService.getCacheObjectOfTask(RedisConst.TASK_PATROL_STATE, patrolTaskStatus.getTaskCode());
redisService.deleteObject(RedisConst.TASK_PATROL_ID);
redisService.deleteObject(RedisConst.TASK_PATROL_STATE);
redisTaskPatrolId = redisService.getCacheObject(RedisConst.TASK_PATROL_ID);
String redisTaskPatrolState = redisService.getCacheObject(RedisConst.TASK_PATROL_STATE);
log.info("[TASK] CONTINUE, UPDATE STATUS STATE: {}, patrolId: {}", DescUtil.getTaskStatusDesc(redisTaskPatrolState), redisTaskPatrolId);
if (!StringUtils.isEmpty(redisTaskPatrolId) && TaskStatus.PAUSED.getCode().equals(redisTaskPatrolState)) {
redisService.deleteObjectOfTask(RedisConst.TASK_PATROL_ID, patrolTaskStatus.getTaskCode());
redisService.deleteObjectOfTask(RedisConst.TASK_PATROL_STATE, patrolTaskStatus.getTaskCode());
redisService.deleteObject(RedisConst.TASK_PATROL_ID);
redisService.deleteObject(RedisConst.TASK_PATROL_STATE);
}
} else if (TaskStatus.HALTED.getCode().equals(patrolTaskStatus.getCommand())) {
cmd = TaskStatus.HALTED.getCode();
redisService.setCacheObjectOfTask(RedisConst.TASK_PATROL_ID, patrolTaskStatus.getTaskCode(), patrolTaskStatus.getTaskPatrolledId());
redisService.setCacheObjectOfTask(RedisConst.TASK_PATROL_STATE, patrolTaskStatus.getTaskCode(), cmd);
redisService.setCacheObject(RedisConst.TASK_PATROL_ID, patrolTaskStatus.getTaskPatrolledId());
redisService.setCacheObject(RedisConst.TASK_PATROL_STATE, cmd);
log.info("[TASK] HALT, UPDATE STATUS STATE: [{}], ID: [{}]", cmd, patrolTaskStatus.getTaskPatrolledId());
}
}


Write Preview
Loading…
Cancel
Save