cmhi
/
dispose
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

OCT 

REM:
1. 重构任务启动、停止逻辑
This commit is contained in:
HuangXin 2020-11-27 09:49:09 +08:00
parent 92ebf33ea0
commit e3b6d9f621
2 changed files with 215 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

262
src/main/java/com/dispose/service/impl/DeviceTaskManagerServiceImpl.java
View File

@ -1,6 +1,7 @@
package com.dispose.service.impl; package com.dispose.service.impl;
import com.dispose.common.DisposeConfigValue; import com.dispose.common.DisposeConfigValue;
import com.dispose.common.DisposeDeviceType;
import com.dispose.common.DisposeTaskStatus; import com.dispose.common.DisposeTaskStatus;
import com.dispose.common.DpTechAttackType; import com.dispose.common.DpTechAttackType;
import com.dispose.common.ErrorCode; import com.dispose.common.ErrorCode;
@ -69,26 +70,26 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STARTING); deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STARTING);
// 设置启动任务攻击类型状态 // 设置启动任务攻击类型状态
deviceTaskManager.setExecAttackType(deviceTask.getId(), NetflowDirection.DIRECTION_BI, deviceTaskManager.setExecAttackType(deviceTask.getId(), NetflowDirection.DIRECTION_BI,
deviceTask.getTaskAttackType()); deviceTask.getTaskAttackType());
// 调用设备执行处置任务 // 调用设备执行处置任务
ret = ai.getDb() ret = ai.getDb()
.runDispose(disposeTask.getDisposeObject(), disposeTask.getObjectType(), .runDispose(disposeTask.getDisposeObject(), disposeTask.getObjectType(),
disposeTask.getDisposeCapacity(), disposeTask.getDisposeCapacity(),
null, null, null); null, null, null);
if (ret.getFirstParam() == ErrorCode.ERR_OK) { if (ret.getFirstParam() == ErrorCode.ERR_OK) {
// 设置攻击类型任务启动结果 // 设置攻击类型任务启动结果
deviceTaskManager.setAttackTypeStatus(deviceTask.getId(), deviceTaskManager.setAttackTypeStatus(deviceTask.getId(),
disposeTask.getFlowDirection(), deviceTask.getTaskAttackType()); disposeTask.getFlowDirection(), deviceTask.getTaskAttackType());
// 更改处置任务状态为处置中 // 更改处置任务状态为处置中
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(),
DisposeTaskStatus.TASK_STARTED); DisposeTaskStatus.TASK_STARTED);
log.info("VIRTUAL_DISPOSE setup task succeed: {}", deviceTask); log.info("VIRTUAL_DISPOSE setup task succeed: {}", deviceTask);
} else { } else {
// 任务出错，不在重试，当做失败任务处理 // 任务出错，不在重试，当做失败任务处理
deviceTaskManager.setAttackTypeStatus(deviceTask.getId(), deviceTaskManager.setAttackTypeStatus(deviceTask.getId(),
disposeTask.getFlowDirection(), 0L); disposeTask.getFlowDirection(), 0L);
log.error("VIRTUAL_DISPOSE setup task error {}: {}", ret.getFirstParam(), deviceTask); log.error("VIRTUAL_DISPOSE setup task error {}: {}", ret.getFirstParam(), deviceTask);
} }
} }
@ -118,7 +119,6 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_FINISHED); deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_FINISHED);
} }
/** /**
* Hao han device task run. * Hao han device task run.
* *
@ -138,17 +138,17 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STARTING); deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STARTING);
// 设置启动任务攻击类型状态 // 设置启动任务攻击类型状态
deviceTaskManager.setExecAttackType(deviceTask.getId(), NetflowDirection.DIRECTION_BI, deviceTaskManager.setExecAttackType(deviceTask.getId(), NetflowDirection.DIRECTION_BI,
deviceTask.getTaskAttackType()); deviceTask.getTaskAttackType());
ret = ai.getDb() ret = ai.getDb()
.runDispose(disposeTask.getDisposeObject(), disposeTask.getObjectType(), .runDispose(disposeTask.getDisposeObject(), disposeTask.getObjectType(),
disposeTask.getDisposeCapacity(), null, disposeTask.getDisposeCapacity(), null,
null, (long) -(Helper.getTimestampDiffNow(disposeTask.getPlanEndTime()) / 60)); null, (long) -(Helper.getTimestampDiffNow(disposeTask.getPlanEndTime()) / 60));
if (ret.getFirstParam() == ErrorCode.ERR_OK) { if (ret.getFirstParam() == ErrorCode.ERR_OK) {
// 设置攻击类型任务启动结果 // 设置攻击类型任务启动结果
deviceTaskManager.setAttackTypeStatus(deviceTask.getId(), deviceTaskManager.setAttackTypeStatus(deviceTask.getId(),
disposeTask.getFlowDirection(), deviceTask.getTaskAttackType()); disposeTask.getFlowDirection(), deviceTask.getTaskAttackType());
// 更改处置任务状态为处置中 // 更改处置任务状态为处置中
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STARTED); deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STARTED);
@ -165,11 +165,11 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
// 记录任务出错重试次数 // 记录任务出错重试次数
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry() + 1); deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry() + 1);
log.error("HAOHAN_PLATFORM setup task times {} error {}: {}", deviceTask.getErrRetry(), log.error("HAOHAN_PLATFORM setup task times {} error {}: {}", deviceTask.getErrRetry(),
ret.getSecondParam(), deviceTask); ret.getSecondParam(), deviceTask);
} else { } else {
// 任务出错，不在重试，当做失败任务处理 // 任务出错，不在重试，当做失败任务处理
deviceTaskManager.setAttackTypeStatus(deviceTask.getId(), deviceTaskManager.setAttackTypeStatus(deviceTask.getId(),
disposeTask.getFlowDirection(), 0L); disposeTask.getFlowDirection(), 0L);
log.error("HAOHAN_PLATFORM setup task error {}: {}", ret.getFirstParam(), deviceTask); log.error("HAOHAN_PLATFORM setup task error {}: {}", ret.getFirstParam(), deviceTask);
} }
} }
@ -186,7 +186,7 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
// 停止处置任务 // 停止处置任务
ret = ai.getDb().stopDispose(disposeTask.getDisposeObject(), disposeTask.getDisposeCapacity(), null, null, ret = ai.getDb().stopDispose(disposeTask.getDisposeObject(), disposeTask.getDisposeCapacity(), null, null,
deviceTask.getExternId()); deviceTask.getExternId());
if (ret.getFirstParam() == ErrorCode.ERR_OK) { if (ret.getFirstParam() == ErrorCode.ERR_OK) {
log.info("HAOHAN_PLATFORM stop task succeed: {}, device taskId {}", deviceTask, ret.getSecondParam()); log.info("HAOHAN_PLATFORM stop task succeed: {}, device taskId {}", deviceTask, ret.getSecondParam());
@ -198,7 +198,7 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
// 记录任务出错重试次数 // 记录任务出错重试次数
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry() + 1); deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry() + 1);
log.error("HAOHAN_PLATFORM stop task times {} error {}: {}", deviceTask.getErrRetry(), log.error("HAOHAN_PLATFORM stop task times {} error {}: {}", deviceTask.getErrRetry(),
ret.getSecondParam(), deviceTask); ret.getSecondParam(), deviceTask);
} else { } else {
log.error("HAOHAN_PLATFORM stop task error {}: {}", ret.getFirstParam(), deviceTask); log.error("HAOHAN_PLATFORM stop task error {}: {}", ret.getFirstParam(), deviceTask);
} }
@ -227,16 +227,16 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
} }
// 设置启动任务攻击类型状态 // 设置启动任务攻击类型状态
deviceTaskManager.execAttackTypeSetBit(deviceTask.getId(), NetflowDirection.DIRECTION_OUT, deviceTaskManager.execAttackTypeSetBit(deviceTask.getId(), NetflowDirection.DIRECTION_OUT,
t.getValue()); t.getValue());
// 调用迪普设备启动处置任务 // 调用迪普设备启动处置任务
ret = ai.getDb().runDispose(disposeTask.getDisposeObject(), disposeTask.getObjectType(), ret = ai.getDb().runDispose(disposeTask.getDisposeObject(), disposeTask.getObjectType(),
disposeTask.getDisposeCapacity(), NetflowDirection.DIRECTION_OUT, disposeTask.getDisposeCapacity(), NetflowDirection.DIRECTION_OUT,
t.getValue(), null); t.getValue(), null);
if (ret.getFirstParam() == ErrorCode.ERR_OK) { if (ret.getFirstParam() == ErrorCode.ERR_OK) {
// 标志启动成功 // 标志启动成功
deviceTaskManager.attackTypeStatusSetBit(deviceTask.getId(), NetflowDirection.DIRECTION_OUT, deviceTaskManager.attackTypeStatusSetBit(deviceTask.getId(), NetflowDirection.DIRECTION_OUT,
t.getValue()); t.getValue());
log.info("DPTECH_UMC setup task {}, {} succeed: {}", t, NetflowDirection.DIRECTION_OUT, deviceTask); log.info("DPTECH_UMC setup task {}, {} succeed: {}", t, NetflowDirection.DIRECTION_OUT, deviceTask);
@ -248,12 +248,12 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry()); deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry());
//清除任务攻击类型启动标志 //清除任务攻击类型启动标志
deviceTaskManager.execAttackTypeCleanBit(deviceTask.getId(), NetflowDirection.DIRECTION_OUT, deviceTaskManager.execAttackTypeCleanBit(deviceTask.getId(), NetflowDirection.DIRECTION_OUT,
t.getValue()); t.getValue());
log.error("DPTECH_UMC setup task {}, {} times {} error: {}", t, log.error("DPTECH_UMC setup task {}, {} times {} error: {}", t,
NetflowDirection.DIRECTION_OUT, deviceTask.getErrRetry(), deviceTask); NetflowDirection.DIRECTION_OUT, deviceTask.getErrRetry(), deviceTask);
} else { } else {
log.error("DPTECH_UMC setup task {}, {} error {}: {}", t, log.error("DPTECH_UMC setup task {}, {} error {}: {}", t,
NetflowDirection.DIRECTION_OUT, ret.getFirstParam(), deviceTask); NetflowDirection.DIRECTION_OUT, ret.getFirstParam(), deviceTask);
} }
} }
@ -265,16 +265,16 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
} }
// 设置启动任务攻击类型状态 // 设置启动任务攻击类型状态
deviceTaskManager.execAttackTypeSetBit(deviceTask.getId(), NetflowDirection.DIRECTION_IN, deviceTaskManager.execAttackTypeSetBit(deviceTask.getId(), NetflowDirection.DIRECTION_IN,
t.getValue()); t.getValue());
// 调用迪普设备启动处置任务 // 调用迪普设备启动处置任务
ret = ai.getDb().runDispose(disposeTask.getDisposeObject(), disposeTask.getObjectType(), ret = ai.getDb().runDispose(disposeTask.getDisposeObject(), disposeTask.getObjectType(),
disposeTask.getDisposeCapacity(), NetflowDirection.DIRECTION_IN, disposeTask.getDisposeCapacity(), NetflowDirection.DIRECTION_IN,
t.getValue(), null); t.getValue(), null);
if (ret.getFirstParam() == ErrorCode.ERR_OK) { if (ret.getFirstParam() == ErrorCode.ERR_OK) {
// 标志启动成功 // 标志启动成功
deviceTaskManager.attackTypeStatusSetBit(deviceTask.getId(), NetflowDirection.DIRECTION_IN, deviceTaskManager.attackTypeStatusSetBit(deviceTask.getId(), NetflowDirection.DIRECTION_IN,
t.getValue()); t.getValue());
log.info("DPTECH_UMC setup task {}, {} succeed: {}", t, NetflowDirection.DIRECTION_IN, deviceTask); log.info("DPTECH_UMC setup task {}, {} succeed: {}", t, NetflowDirection.DIRECTION_IN, deviceTask);
@ -286,12 +286,12 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry()); deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry());
//清除任务攻击类型启动标志 //清除任务攻击类型启动标志
deviceTaskManager.execAttackTypeCleanBit(deviceTask.getId(), NetflowDirection.DIRECTION_IN, deviceTaskManager.execAttackTypeCleanBit(deviceTask.getId(), NetflowDirection.DIRECTION_IN,
t.getValue()); t.getValue());
log.error("DPTECH_UMC setup task {}, {} times {} error: {}", t, log.error("DPTECH_UMC setup task {}, {} times {} error: {}", t,
NetflowDirection.DIRECTION_IN, deviceTask.getErrRetry(), deviceTask); NetflowDirection.DIRECTION_IN, deviceTask.getErrRetry(), deviceTask);
} else { } else {
log.error("DPTECH_UMC setup task {}, {} error {}: {}", t, log.error("DPTECH_UMC setup task {}, {} error {}: {}", t,
NetflowDirection.DIRECTION_IN, ret.getFirstParam(), deviceTask); NetflowDirection.DIRECTION_IN, ret.getFirstParam(), deviceTask);
} }
} }
} }
@ -344,12 +344,12 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
if (disposeTask.getFlowDirection() != NetflowDirection.DIRECTION_IN) { if (disposeTask.getFlowDirection() != NetflowDirection.DIRECTION_IN) {
// 调用迪普设备停止处置任务 // 调用迪普设备停止处置任务
ret = ai.getDb().stopDispose(disposeTask.getDisposeObject(), disposeTask.getDisposeCapacity(), ret = ai.getDb().stopDispose(disposeTask.getDisposeObject(), disposeTask.getDisposeCapacity(),
NetflowDirection.DIRECTION_OUT, t.getValue(), null); NetflowDirection.DIRECTION_OUT, t.getValue(), null);
if (ret.getFirstParam() == ErrorCode.ERR_OK) { if (ret.getFirstParam() == ErrorCode.ERR_OK) {
// 标志停止成功 // 标志停止成功
deviceTaskManager.attackTypeStatusCleanBit(deviceTask.getId(), NetflowDirection.DIRECTION_OUT, deviceTaskManager.attackTypeStatusCleanBit(deviceTask.getId(), NetflowDirection.DIRECTION_OUT,
t.getValue()); t.getValue());
log.info("DPTECH_UMC stop task {}, {} succeed: {}", t, NetflowDirection.DIRECTION_OUT, deviceTask); log.info("DPTECH_UMC stop task {}, {} succeed: {}", t, NetflowDirection.DIRECTION_OUT, deviceTask);
@ -359,10 +359,10 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
deviceTask.setErrRetry(deviceTask.getErrRetry() + 1); deviceTask.setErrRetry(deviceTask.getErrRetry() + 1);
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry()); deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry());
log.error("DPTECH_UMC stop task {}, {} times {} error: {}", t, log.error("DPTECH_UMC stop task {}, {} times {} error: {}", t,
NetflowDirection.DIRECTION_OUT, deviceTask.getErrRetry(), deviceTask); NetflowDirection.DIRECTION_OUT, deviceTask.getErrRetry(), deviceTask);
} else { } else {
log.info("DPTECH_UMC stop task {}, {} error {}: {}", t, log.info("DPTECH_UMC stop task {}, {} error {}: {}", t,
NetflowDirection.DIRECTION_OUT, ret.getFirstParam(), deviceTask); NetflowDirection.DIRECTION_OUT, ret.getFirstParam(), deviceTask);
} }
} }
@ -370,15 +370,15 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
if (disposeTask.getFlowDirection() != NetflowDirection.DIRECTION_OUT) { if (disposeTask.getFlowDirection() != NetflowDirection.DIRECTION_OUT) {
// 调用迪普设备启动处置任务 // 调用迪普设备启动处置任务
ret = ai.getDb().stopDispose(disposeTask.getDisposeObject(), disposeTask.getDisposeCapacity(), ret = ai.getDb().stopDispose(disposeTask.getDisposeObject(), disposeTask.getDisposeCapacity(),
NetflowDirection.DIRECTION_IN, t.getValue(), null); NetflowDirection.DIRECTION_IN, t.getValue(), null);
if (ret.getFirstParam() == ErrorCode.ERR_OK) { if (ret.getFirstParam() == ErrorCode.ERR_OK) {
// 标志启动成功 // 标志启动成功
deviceTaskManager.attackTypeStatusCleanBit(deviceTask.getId(), NetflowDirection.DIRECTION_IN, deviceTaskManager.attackTypeStatusCleanBit(deviceTask.getId(), NetflowDirection.DIRECTION_IN,
t.getValue()); t.getValue());
log.info("DPTECH_UMC setup task {}, {} succeed: {}", t, log.info("DPTECH_UMC setup task {}, {} succeed: {}", t,
NetflowDirection.DIRECTION_IN, deviceTask); NetflowDirection.DIRECTION_IN, deviceTask);
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), 0); deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), 0);
} else if (deviceTask.getErrRetry() < DisposeConfigValue.CALL_ERROR_RETRY_TIMES * 10) { } else if (deviceTask.getErrRetry() < DisposeConfigValue.CALL_ERROR_RETRY_TIMES * 10) {
@ -386,10 +386,10 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
deviceTask.setErrRetry(deviceTask.getErrRetry() + 1); deviceTask.setErrRetry(deviceTask.getErrRetry() + 1);
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry()); deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry());
log.error("DPTECH_UMC stop task {}, {} times {} error: {}", t, log.error("DPTECH_UMC stop task {}, {} times {} error: {}", t,
NetflowDirection.DIRECTION_IN, deviceTask.getErrRetry(), deviceTask); NetflowDirection.DIRECTION_IN, deviceTask.getErrRetry(), deviceTask);
} else { } else {
log.info("DPTECH_UMC stop task {}, {} error {}: {}", t, log.info("DPTECH_UMC stop task {}, {} error {}: {}", t,
NetflowDirection.DIRECTION_IN, ret.getFirstParam(), deviceTask); NetflowDirection.DIRECTION_IN, ret.getFirstParam(), deviceTask);
} }
} }
} }
@ -443,17 +443,17 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STARTING); deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STARTING);
// 设置启动任务攻击类型状态 // 设置启动任务攻击类型状态
deviceTaskManager.setExecAttackType(deviceTask.getId(), NetflowDirection.DIRECTION_BI, deviceTaskManager.setExecAttackType(deviceTask.getId(), NetflowDirection.DIRECTION_BI,
deviceTask.getTaskAttackType()); deviceTask.getTaskAttackType());
ret = ai.getDb() ret = ai.getDb()
.runDispose(disposeTask.getDisposeObject(), disposeTask.getObjectType(), .runDispose(disposeTask.getDisposeObject(), disposeTask.getObjectType(),
disposeTask.getDisposeCapacity(), null, disposeTask.getDisposeCapacity(), null,
null, (long) -(Helper.getTimestampDiffNow(disposeTask.getPlanEndTime()) / 60)); null, (long) -(Helper.getTimestampDiffNow(disposeTask.getPlanEndTime()) / 60));
if (ret.getFirstParam() == ErrorCode.ERR_OK) { if (ret.getFirstParam() == ErrorCode.ERR_OK) {
// 设置攻击类型任务启动结果 // 设置攻击类型任务启动结果
deviceTaskManager.setAttackTypeStatus(deviceTask.getId(), deviceTaskManager.setAttackTypeStatus(deviceTask.getId(),
disposeTask.getFlowDirection(), deviceTask.getTaskAttackType()); disposeTask.getFlowDirection(), deviceTask.getTaskAttackType());
// 更改处置任务状态为处置中 // 更改处置任务状态为处置中
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STARTED); deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STARTED);
@ -471,19 +471,21 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
// 记录任务出错重试次数 // 记录任务出错重试次数
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry() + 1); deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry() + 1);
log.error("PENGXIN_PLATFORM setup task times {} error {}: {}", deviceTask.getErrRetry(), log.error("PENGXIN_PLATFORM setup task times {} error {}: {}", deviceTask.getErrRetry(),
ret.getSecondParam(), deviceTask); ret.getSecondParam(), deviceTask);
} else { } else {
// 任务出错，不在重试，当做失败任务处理 // 任务出错，不在重试，当做失败任务处理
deviceTaskManager.setAttackTypeStatus(deviceTask.getId(), deviceTaskManager.setAttackTypeStatus(deviceTask.getId(), disposeTask.getFlowDirection(), 0L);
disposeTask.getFlowDirection(), 0L);
// 设置该任务为启动失败 // 设置该任务为启动失败
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_NEW); deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(),
DisposeTaskStatus.TASK_START_FAILED);
//任务出错，设备任务状态为启动处置任务失败 //任务出错，设备任务状态为启动处置任务失败
deviceTaskManager.changeDisposeDeviceTaskInfoDevStatus(deviceTask.getId(), deviceTaskManager.changeDisposeDeviceTaskInfoDevStatus(deviceTask.getId(),
(long) PengXinTaskStatus.TASK_STARTED_FAILED.getValue()); (long) PengXinTaskStatus.TASK_STARTED_FAILED.getValue());
// 记录任务出错重试次数 // 记录任务出错重试次数
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry() + 1); deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), 0);
log.error("PENGXIN_PLATFORM setup task error {}: {}", ret.getFirstParam(), deviceTask); log.error("PENGXIN_PLATFORM setup task error {}: {}", ret.getFirstParam(), deviceTask);
} }
@ -500,13 +502,13 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
MulReturnType<ErrorCode, Long> ret; MulReturnType<ErrorCode, Long> ret;
// 重试错误次数过多 // 重试错误次数过多
if (deviceTask.getErrRetry() > DisposeConfigValue.CALL_ERROR_RETRY_TIMES * 2) { if (deviceTask.getErrRetry() > DisposeConfigValue.CALL_ERROR_RETRY_TIMES) {
return; return;
} }
// 停止处置任务 // 停止处置任务
ret = ai.getDb().stopDispose(disposeTask.getDisposeObject(), disposeTask.getDisposeCapacity(), null, null, ret = ai.getDb().stopDispose(disposeTask.getDisposeObject(), disposeTask.getDisposeCapacity(), null, null,
deviceTask.getExternId()); deviceTask.getExternId());
if (ret.getFirstParam() == ErrorCode.ERR_OK) { if (ret.getFirstParam() == ErrorCode.ERR_OK) {
log.info("PENGXIN_PLATFORM stop task succeed: {}, device taskId {}", deviceTask, ret.getSecondParam()); log.info("PENGXIN_PLATFORM stop task succeed: {}, device taskId {}", deviceTask, ret.getSecondParam());
@ -514,25 +516,23 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_FINISHED); deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_FINISHED);
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), 0); deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), 0);
deviceTaskManager.setAttackTypeStatus(deviceTask.getId(), disposeTask.getFlowDirection(), 0L); deviceTaskManager.setAttackTypeStatus(deviceTask.getId(), disposeTask.getFlowDirection(), 0L);
} else if (deviceTask.getErrRetry() < DisposeConfigValue.CALL_ERROR_RETRY_TIMES * 2) { } else if (deviceTask.getErrRetry() < DisposeConfigValue.CALL_ERROR_RETRY_TIMES) {
// 记录任务出错重试次数 // 记录任务出错重试次数
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry() + 1); deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry() + 1);
// 设置任务状态为处置中，待下次重试停止
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STARTED);
log.error("PENGXIN_PLATFORM stop task times {} error {}: {}", deviceTask.getErrRetry(), log.error("PENGXIN_PLATFORM stop task times {} error {}: {}", deviceTask.getErrRetry(),
ret.getSecondParam(), deviceTask); ret.getSecondParam(), deviceTask);
} else { } else {
// 记录任务出错重试次数 // 记录任务出错重试次数
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry() + 1); deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), 0);
// 设置该任务为停止失败 // 设置该任务为停止失败
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_FINISHED); deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STOP_FAILED);
log.error("PENGXIN_PLATFORM stop task error {}: {}", ret.getFirstParam(), deviceTask); log.error("PENGXIN_PLATFORM stop task error {}: {}", ret.getFirstParam(), deviceTask);
} }
} }
/** /**
* Huawei ATIC device task run. * Hua wei device task run.
* *
* @param ai the ai * @param ai the ai
* @param deviceTask the device task * @param deviceTask the device task
@ -550,17 +550,17 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STARTING); deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STARTING);
// 设置启动任务攻击类型状态 // 设置启动任务攻击类型状态
deviceTaskManager.setExecAttackType(deviceTask.getId(), NetflowDirection.DIRECTION_BI, deviceTaskManager.setExecAttackType(deviceTask.getId(), NetflowDirection.DIRECTION_BI,
deviceTask.getTaskAttackType()); deviceTask.getTaskAttackType());
ret = ai.getDb() ret = ai.getDb()
.runDispose(disposeTask.getDisposeObject(), disposeTask.getObjectType(), .runDispose(disposeTask.getDisposeObject(), disposeTask.getObjectType(),
disposeTask.getDisposeCapacity(), null, disposeTask.getDisposeCapacity(), null,
null, (long) -(Helper.getTimestampDiffNow(disposeTask.getPlanEndTime()) / 60)); null, (long) -(Helper.getTimestampDiffNow(disposeTask.getPlanEndTime()) / 60));
if (ret.getFirstParam() == ErrorCode.ERR_OK) { if (ret.getFirstParam() == ErrorCode.ERR_OK) {
// 设置攻击类型任务启动结果 // 设置攻击类型任务启动结果
deviceTaskManager.setAttackTypeStatus(deviceTask.getId(), deviceTaskManager.setAttackTypeStatus(deviceTask.getId(),
disposeTask.getFlowDirection(), deviceTask.getTaskAttackType()); disposeTask.getFlowDirection(), deviceTask.getTaskAttackType());
// 更改处置任务状态为处置中 // 更改处置任务状态为处置中
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STARTED); deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STARTED);
@ -574,17 +574,17 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
// 记录任务出错重试次数 // 记录任务出错重试次数
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry() + 1); deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry() + 1);
log.error("HUAWEI_PLATFORM setup task times {} error {}: {}", deviceTask.getErrRetry(), log.error("HUAWEI_PLATFORM setup task times {} error {}: {}", deviceTask.getErrRetry(),
ret.getSecondParam(), deviceTask); ret.getSecondParam(), deviceTask);
} else { } else {
// 任务出错，不在重试，当做失败任务处理 // 任务出错，不在重试，当做失败任务处理
deviceTaskManager.setAttackTypeStatus(deviceTask.getId(), deviceTaskManager.setAttackTypeStatus(deviceTask.getId(),
disposeTask.getFlowDirection(), 0L); disposeTask.getFlowDirection(), 0L);
log.error("HUAWEI_PLATFORM setup task error {}: {}", ret.getFirstParam(), deviceTask); log.error("HUAWEI_PLATFORM setup task error {}: {}", ret.getFirstParam(), deviceTask);
} }
} }
/** /**
* Huawei ATIC device task stop. * Hua wei device task stop.
* *
* @param ai the ai * @param ai the ai
* @param deviceTask the device task * @param deviceTask the device task
@ -595,7 +595,7 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
// 停止处置任务 // 停止处置任务
ret = ai.getDb().stopDispose(disposeTask.getDisposeObject(), disposeTask.getDisposeCapacity(), null, null, ret = ai.getDb().stopDispose(disposeTask.getDisposeObject(), disposeTask.getDisposeCapacity(), null, null,
deviceTask.getExternId()); deviceTask.getExternId());
if (ret.getFirstParam() == ErrorCode.ERR_OK) { if (ret.getFirstParam() == ErrorCode.ERR_OK) {
log.info("HUAWEI_PLATFORM stop task succeed: {}, device taskId {}", deviceTask, ret.getSecondParam()); log.info("HUAWEI_PLATFORM stop task succeed: {}, device taskId {}", deviceTask, ret.getSecondParam());
@ -607,12 +607,124 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
// 记录任务出错重试次数 // 记录任务出错重试次数
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry() + 1); deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry() + 1);
log.error("HUAWEI_PLATFORM stop task times {} error {}: {}", deviceTask.getErrRetry(), log.error("HUAWEI_PLATFORM stop task times {} error {}: {}", deviceTask.getErrRetry(),
ret.getSecondParam(), deviceTask); ret.getSecondParam(), deviceTask);
} else { } else {
log.error("HUAWEI_PLATFORM stop task error {}: {}", ret.getFirstParam(), deviceTask); log.error("HUAWEI_PLATFORM stop task error {}: {}", ret.getFirstParam(), deviceTask);
} }
} }
/**
* Restful device task run.
*
* @param ai the ai
* @param deviceTask the device task
* @param disposeTask the dispose task
* @param deviceType the device type
*/
private void restfulDeviceTaskRun(AbilityInfo ai, DeviceTask deviceTask, DisposeTask disposeTask,
DisposeDeviceType deviceType) {
MulReturnType<ErrorCode, String> ret;
// 重试错误次数过多
if (deviceTask.getErrRetry() > DisposeConfigValue.CALL_ERROR_RETRY_TIMES) {
return;
}
// 设置任务状态为启动中
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STARTING);
// 设置启动任务攻击类型状态
deviceTaskManager.setExecAttackType(deviceTask.getId(), NetflowDirection.DIRECTION_BI,
deviceTask.getTaskAttackType());
ret = ai.getDb()
.runDispose(disposeTask.getDisposeObject(), disposeTask.getObjectType(),
disposeTask.getDisposeCapacity(), null,
null, (long) -(Helper.getTimestampDiffNow(disposeTask.getPlanEndTime()) / 60));
if (ret.getFirstParam() == ErrorCode.ERR_OK) {
// 设置攻击类型任务启动结果
deviceTaskManager.setAttackTypeStatus(deviceTask.getId(),
disposeTask.getFlowDirection(), deviceTask.getTaskAttackType());
// 更改处置任务状态为处置中
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STARTED);
// 记录设备返回的任务ID
deviceTaskManager.setTaskExternId(deviceTask.getId(), ret.getSecondParam());
log.info("{} setup task succeed: {}, device taskId {}", deviceType, deviceTask, ret.getSecondParam());
// 重置错误尝试次数
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), 0);
} else if (deviceTask.getErrRetry() < DisposeConfigValue.CALL_ERROR_RETRY_TIMES) {
// 设置该任务为新任务，待下次重试启动
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_NEW);
// 记录任务出错重试次数
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry() + 1);
log.error("{} setup task times {} error {}: {}", deviceType, deviceTask.getErrRetry(),
ret.getSecondParam(),
deviceTask);
} else {
// 任务出错，不在重试，当做失败任务处理
deviceTaskManager.setAttackTypeStatus(deviceTask.getId(), disposeTask.getFlowDirection(), 0L);
// 设置该任务为启动失败
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(),
DisposeTaskStatus.TASK_START_FAILED);
//任务出错，设备任务状态为启动处置任务失败
deviceTaskManager.changeDisposeDeviceTaskInfoDevStatus(deviceTask.getId(),
(long) PengXinTaskStatus.TASK_STARTED_FAILED.getValue());
// 记录任务出错重试次数
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), 0);
log.error("{} setup task error {}: {}", deviceType, ret.getFirstParam(), deviceTask);
}
}
/**
* Restful device task stop.
*
* @param ai the ai
* @param deviceTask the device task
* @param disposeTask the dispose task
* @param deviceType the device type
*/
private void restfulDeviceTaskStop(AbilityInfo ai, DeviceTask deviceTask, DisposeTask disposeTask,
DisposeDeviceType deviceType) {
MulReturnType<ErrorCode, Long> ret;
// 重试错误次数过多
if (deviceTask.getErrRetry() > DisposeConfigValue.CALL_ERROR_RETRY_TIMES) {
return;
}
// 停止处置任务
ret = ai.getDb().stopDispose(disposeTask.getDisposeObject(), disposeTask.getDisposeCapacity(), null, null,
deviceTask.getExternId());
if (ret.getFirstParam() == ErrorCode.ERR_OK) {
log.info("{} stop task succeed: {}, device taskId {}", deviceType, deviceTask, ret.getSecondParam());
// 设置任务状态为结束
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_FINISHED);
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), 0);
deviceTaskManager.setAttackTypeStatus(deviceTask.getId(), disposeTask.getFlowDirection(), 0L);
} else if (deviceTask.getErrRetry() < DisposeConfigValue.CALL_ERROR_RETRY_TIMES) {
// 记录任务出错重试次数
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), deviceTask.getErrRetry() + 1);
log.error("{} stop task times {} error {}: {}", deviceType, deviceTask.getErrRetry(),
ret.getSecondParam(), deviceTask);
} else {
// 记录任务出错重试次数
deviceTaskManager.setTaskErrRetryTimes(deviceTask.getId(), 0);
// 设置该任务为停止失败
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(deviceTask.getId(), DisposeTaskStatus.TASK_STOP_FAILED);
log.error("{} stop task error {}: {}", deviceType, ret.getFirstParam(), deviceTask);
}
}
/** /**
* Dispose task manager schedule. * Dispose task manager schedule.
*/ */
@ -621,7 +733,7 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
// 清理过期任务 // 清理过期任务
for (DisposeTask v : disposeTaskManager.getExpiredTasks()) { for (DisposeTask v : disposeTaskManager.getExpiredTasks()) {
log.info("Task {} {} {} is expired, expect finished at {}", log.info("Task {} {} {} is expired, expect finished at {}",
v.getId(), v.getDisposeCapacity(), v.getDisposeObject(), v.getPlanEndTime()); v.getId(), v.getDisposeCapacity(), v.getDisposeObject(), v.getPlanEndTime());
// 设置任务状态，过期任务不再为设备创建处置任务 // 设置任务状态，过期任务不再为设备创建处置任务
disposeTaskManager.changeDisposeTaskStatus(v.getId(), DisposeTaskStatus.TASK_EXPIRED); disposeTaskManager.changeDisposeTaskStatus(v.getId(), DisposeTaskStatus.TASK_EXPIRED);
} }
@ -646,8 +758,8 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
log.info("Add dispose task for device: {}", d.getDev()); log.info("Add dispose task for device: {}", d.getDev());
if (!deviceTaskManager.addDisposeDeviceTaskInfo(v.getId(), d.getDev().getId(), if (!deviceTaskManager.addDisposeDeviceTaskInfo(v.getId(), d.getDev().getId(),
d.getDb() d.getDb()
.toDeviceAttackType(v.getAttackType()))) { .toDeviceAttackType(v.getAttackType()))) {
log.error("Add task {} to device {} error", v, d); log.error("Add task {} to device {} error", v, d);
} }
}); });
@ -702,7 +814,8 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
break; break;
case PENGXIN_PLATFORM: case PENGXIN_PLATFORM:
pengXinDeviceTaskRun(ai, v, task); //pengXinDeviceTaskRun(ai, v, task);
restfulDeviceTaskRun(ai, v, task, DisposeDeviceType.PENGXIN_PLATFORM);
break; break;
case HUAWEI_PLATFORM: case HUAWEI_PLATFORM:
@ -761,7 +874,7 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
// 设置标志，避免对同一个IP重复调用停止处置命令 // 设置标志，避免对同一个IP重复调用停止处置命令
taskCache.put(taskStopKey, true); taskCache.put(taskStopKey, true);
deviceTaskManager.changeDisposeDeviceTaskInfoStatus(v.getId(), DisposeTaskStatus.TASK_EXPIRED); //deviceTaskManager.changeDisposeDeviceTaskInfoStatus(v.getId(), DisposeTaskStatus.TASK_EXPIRED);
switch (ai.getDev().getDeviceType()) { switch (ai.getDev().getDeviceType()) {
case DPTECH_UMC: case DPTECH_UMC:
@ -777,7 +890,8 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
break; break;
case PENGXIN_PLATFORM: case PENGXIN_PLATFORM:
pengXinDeviceTaskStop(ai, v, task); //pengXinDeviceTaskStop(ai, v, task);
restfulDeviceTaskStop(ai, v, task, DisposeDeviceType.PENGXIN_PLATFORM);
break; break;
case HUAWEI_PLATFORM: case HUAWEI_PLATFORM:
@ -823,9 +937,9 @@ public class DeviceTaskManagerServiceImpl implements DeviceTaskManagerService {
if (ret.getFirstParam() == ErrorCode.ERR_OK) { if (ret.getFirstParam() == ErrorCode.ERR_OK) {
log.debug("id:{}, before devStatus:{}, after devStatus:{}", v.getId(), log.debug("id:{}, before devStatus:{}, after devStatus:{}", v.getId(),
v.getDevStatus(), ret.getSecondParam()); v.getDevStatus(), ret.getSecondParam());
deviceTaskManager.changeDisposeDeviceTaskInfoDevStatus(v.getId(), deviceTaskManager.changeDisposeDeviceTaskInfoDevStatus(v.getId(),
ret.getSecondParam()); ret.getSecondParam());
} }
} }

41
src/main/resources/mappers/DeviceTask.xml
View File

@ -55,18 +55,29 @@
<select id="getNewTaskInfos" resultMap="device_task"> <select id="getNewTaskInfos" resultMap="device_task">
SELECT * SELECT *
FROM device_task FROM device_task
WHERE status = ${@com.dispose.common.DisposeTaskStatus@TASK_NEW.getValue()} <choose>
OR status = ${@com.dispose.common.DisposeTaskStatus@TASK_STARTING.getValue()} <when test="status == @com.dispose.common.DisposeTaskStatus@TASK_START_FAILED">
OR status = ${@com.dispose.common.DisposeTaskStatus@TASK_START_FAILED.getValue()} WHERE CURRENT_TIMESTAMP - endTime > 300
</when>
<otherwise>
WHERE status = ${@com.dispose.common.DisposeTaskStatus@TASK_NEW.getValue()}
</otherwise>
</choose>
</select> </select>
<select id="getRunningTaskInfos" resultMap="device_task"> <select id="getRunningTaskInfos" resultMap="device_task">
SELECT * SELECT *
FROM device_task FROM device_task
WHERE status = ${@com.dispose.common.DisposeTaskStatus@TASK_NEW.getValue()} <choose>
OR status = ${@com.dispose.common.DisposeTaskStatus@TASK_STARTING.getValue()} <when test="status == @com.dispose.common.DisposeTaskStatus@TASK_STOP_FAILED">
OR status = ${@com.dispose.common.DisposeTaskStatus@TASK_STARTED.getValue()} WHERE CURRENT_TIMESTAMP - endTime > 300
OR status = ${@com.dispose.common.DisposeTaskStatus@TASK_STOP_FAILED.getValue()} </when>
<otherwise>
WHERE status = ${@com.dispose.common.DisposeTaskStatus@TASK_NEW.getValue()}
OR status = ${@com.dispose.common.DisposeTaskStatus@TASK_STARTING.getValue()}
OR status = ${@com.dispose.common.DisposeTaskStatus@TASK_STARTED.getValue()}
</otherwise>
</choose>
</select> </select>
<select id="getTaskByDetails" resultMap="device_task"> <select id="getTaskByDetails" resultMap="device_task">
@ -95,7 +106,8 @@
<update id="changeTaskDevStatus"> <update id="changeTaskDevStatus">
UPDATE device_task UPDATE device_task
SET devStatus = #{devStatus} SET devStatus = #{devStatus}
WHERE id = #{id} AND devStatus != #{devStatus} WHERE id = #{id}
AND devStatus != #{devStatus}
</update> </update>
<update id="changeExecAttackTypeInValue"> <update id="changeExecAttackTypeInValue">
@ -135,11 +147,12 @@
</update> </update>
<select id="getPengXinTask" resultType="com.dispose.pojo.entity.DeviceTask"> <select id="getPengXinTask" resultType="com.dispose.pojo.entity.DeviceTask">
SELECT dt.*, dd.* SELECT dt.*, dd.*
FROM device_task dt LEFT JOIN dispose_device dd ON dt.deviceId = dd.id FROM device_task dt
WHERE LEFT JOIN dispose_device dd ON dt.deviceId = dd.id
dd.deviceType = 2 WHERE dd.deviceType = 2
AND AND dt.devStatus != 2
dt.devStatus != 2 AND dt.devStatus != 3 AND dt.devStatus != 6 AND dt.devStatus != 3
AND dt.devStatus != 6
</select> </select>
</mapper> </mapper>