wxy/graduate-design
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
xingyou
2026-03-06 14:01:32 +08:00
commit def60e21c7
1074 changed files with 119423 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
orion-ops-api/orion-ops-runner/pom.xml Normal file
View File

@@ -0,0 +1,23 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>orion-ops-api</artifactId>
<groupId>cn.orionsec.ops</groupId>
<version>1.3.1</version>
</parent>
<name>orion-ops-runner</name>
<artifactId>orion-ops-runner</artifactId>
<modelVersion>4.0.0</modelVersion>
<dependencies>
<!-- service -->
<dependency>
<groupId>cn.orionsec.ops</groupId>
<artifactId>orion-ops-service</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>
</project>

54
orion-ops-api/orion-ops-runner/src/main/java/cn/orionsec/ops/runner/AppBuildStatusCleanRunner.java Normal file
View File

@@ -0,0 +1,54 @@
package cn.orionsec.ops.runner;
import cn.orionsec.ops.constant.app.ActionStatus;
import cn.orionsec.ops.constant.app.BuildStatus;
import cn.orionsec.ops.constant.app.StageType;
import cn.orionsec.ops.dao.ApplicationActionLogDAO;
import cn.orionsec.ops.dao.ApplicationBuildDAO;
import cn.orionsec.ops.entity.domain.ApplicationActionLogDO;
import cn.orionsec.ops.entity.domain.ApplicationBuildDO;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Date;
@Component
@Order(2300)
@Slf4j
public class AppBuildStatusCleanRunner implements CommandLineRunner {
@Resource
private ApplicationBuildDAO applicationBuildDAO;
@Resource
private ApplicationActionLogDAO applicationActionLogDAO;
@Override
public void run(String... args) {
log.info("重置应用构建状态-开始");
// 更新构建状态
Wrapper<ApplicationBuildDO> buildWrapper = new LambdaQueryWrapper<ApplicationBuildDO>()
.in(ApplicationBuildDO::getBuildStatus, BuildStatus.WAIT.getStatus(), BuildStatus.RUNNABLE.getStatus());
ApplicationBuildDO updateBuild = new ApplicationBuildDO();
updateBuild.setBuildStatus(BuildStatus.TERMINATED.getStatus());
updateBuild.setUpdateTime(new Date());
applicationBuildDAO.update(updateBuild, buildWrapper);
// 更新操作状态
LambdaQueryWrapper<ApplicationActionLogDO> actionWrapper = new LambdaQueryWrapper<ApplicationActionLogDO>()
.eq(ApplicationActionLogDO::getStageType, StageType.BUILD.getType())
.in(ApplicationActionLogDO::getRunStatus, ActionStatus.WAIT.getStatus(), ActionStatus.RUNNABLE.getStatus());
ApplicationActionLogDO updateAction = new ApplicationActionLogDO();
updateAction.setRunStatus(ActionStatus.TERMINATED.getStatus());
updateAction.setUpdateTime(new Date());
applicationActionLogDAO.update(updateAction, actionWrapper);
log.info("重置应用构建状态-结束");
}
}

105
orion-ops-api/orion-ops-runner/src/main/java/cn/orionsec/ops/runner/AppPipelineTaskRunner.java Normal file
View File

@@ -0,0 +1,105 @@
package cn.orionsec.ops.runner;
import cn.orionsec.ops.constant.app.PipelineDetailStatus;
import cn.orionsec.ops.constant.app.PipelineStatus;
import cn.orionsec.ops.dao.ApplicationPipelineTaskDAO;
import cn.orionsec.ops.dao.ApplicationPipelineTaskDetailDAO;
import cn.orionsec.ops.entity.domain.ApplicationPipelineTaskDO;
import cn.orionsec.ops.entity.domain.ApplicationPipelineTaskDetailDO;
import cn.orionsec.ops.service.api.ApplicationPipelineTaskDetailService;
import cn.orionsec.ops.task.TaskRegister;
import cn.orionsec.ops.task.TaskType;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
@Component
@Order(3400)
@Slf4j
public class AppPipelineTaskRunner implements CommandLineRunner {
@Resource
private ApplicationPipelineTaskDAO applicationPipelineTaskDAO;
@Resource
private ApplicationPipelineTaskDetailDAO applicationPipelineTaskDetailDAO;
@Resource
private ApplicationPipelineTaskDetailService applicationPipelineTaskDetailService;
@Resource
private TaskRegister taskRegister;
@Override
public void run(String... args) {
log.info("流水线任务初始化-开始");
// 更新执行任务状态
this.updateTaskStatus();
// 自动恢复任务
this.autoResumeTask();
log.info("流水线任务初始化-结束");
}
/**
* 更新任务执行状态
*/
private void updateTaskStatus() {
// 查询任务
Wrapper<ApplicationPipelineTaskDO> taskWrapper = new LambdaQueryWrapper<ApplicationPipelineTaskDO>()
.in(ApplicationPipelineTaskDO::getExecStatus, PipelineStatus.RUNNABLE.getStatus());
List<ApplicationPipelineTaskDO> taskList = applicationPipelineTaskDAO.selectList(taskWrapper);
if (taskList.isEmpty()) {
return;
}
List<Long> taskIdList = taskList.stream()
.map(ApplicationPipelineTaskDO::getId)
.collect(Collectors.toList());
// 更新任务状态
ApplicationPipelineTaskDO updateTask = new ApplicationPipelineTaskDO();
updateTask.setExecStatus(PipelineStatus.TERMINATED.getStatus());
updateTask.setUpdateTime(new Date());
applicationPipelineTaskDAO.update(updateTask, taskWrapper);
log.info("流水线任务初始化-重置任务状态 {}", taskIdList);
// 查询任务明细
List<ApplicationPipelineTaskDetailDO> details = applicationPipelineTaskDetailService.selectTaskDetails(taskIdList);
// 更新明细状态
for (ApplicationPipelineTaskDetailDO detail : details) {
ApplicationPipelineTaskDetailDO updateDetail = new ApplicationPipelineTaskDetailDO();
updateDetail.setId(detail.getId());
updateDetail.setUpdateTime(new Date());
switch (PipelineDetailStatus.of(detail.getExecStatus())) {
case WAIT:
case RUNNABLE:
updateDetail.setExecStatus(PipelineDetailStatus.TERMINATED.getStatus());
break;
default:
break;
}
applicationPipelineTaskDetailDAO.updateById(updateDetail);
}
}
/**
* 自动恢复任务
*/
private void autoResumeTask() {
Wrapper<ApplicationPipelineTaskDO> wrapper = new LambdaQueryWrapper<ApplicationPipelineTaskDO>()
.eq(ApplicationPipelineTaskDO::getExecStatus, PipelineStatus.WAIT_SCHEDULE.getStatus());
List<ApplicationPipelineTaskDO> taskList = applicationPipelineTaskDAO.selectList(wrapper);
for (ApplicationPipelineTaskDO task : taskList) {
Long id = task.getId();
log.info("重新加载流水线任务-提交 id: {}", id);
taskRegister.submit(TaskType.PIPELINE, task.getTimedExecTime(), id);
}
}
}

44
orion-ops-api/orion-ops-runner/src/main/java/cn/orionsec/ops/runner/AppReleaseTimedTaskRestoreRunner.java Normal file
View File

@@ -0,0 +1,44 @@
package cn.orionsec.ops.runner;
import cn.orionsec.ops.constant.app.ReleaseStatus;
import cn.orionsec.ops.dao.ApplicationReleaseDAO;
import cn.orionsec.ops.entity.domain.ApplicationReleaseDO;
import cn.orionsec.ops.task.TaskRegister;
import cn.orionsec.ops.task.TaskType;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.List;
@Component
@Order(3100)
@Slf4j
public class AppReleaseTimedTaskRestoreRunner implements CommandLineRunner {
@Resource
private ApplicationReleaseDAO applicationReleaseDAO;
@Resource
private TaskRegister register;
@Override
public void run(String... args) {
log.info("重新加载发布任务-开始");
Wrapper<ApplicationReleaseDO> wrapper = new LambdaQueryWrapper<ApplicationReleaseDO>()
.eq(ApplicationReleaseDO::getReleaseStatus, ReleaseStatus.WAIT_SCHEDULE.getStatus());
List<ApplicationReleaseDO> releaseList = applicationReleaseDAO.selectList(wrapper);
for (ApplicationReleaseDO release : releaseList) {
Long id = release.getId();
log.info("重新加载发布任务-提交 releaseId: {}", id);
register.submit(TaskType.RELEASE, release.getTimedReleaseTime(), id);
}
log.info("重新加载发布任务-结束");
}
}

81
orion-ops-api/orion-ops-runner/src/main/java/cn/orionsec/ops/runner/AppRepositoryStatusCleanRunner.java Normal file
View File

@@ -0,0 +1,81 @@
package cn.orionsec.ops.runner;
import cn.orionsec.kit.lang.utils.io.Files1;
import cn.orionsec.ops.constant.app.RepositoryStatus;
import cn.orionsec.ops.dao.ApplicationRepositoryDAO;
import cn.orionsec.ops.entity.domain.ApplicationRepositoryDO;
import cn.orionsec.ops.utils.Utils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.io.File;
import java.util.List;
@Component
@Order(2500)
@Slf4j
public class AppRepositoryStatusCleanRunner implements CommandLineRunner {
@Resource
private ApplicationRepositoryDAO applicationRepositoryDAO;
@Override
public void run(String... args) {
log.info("重置版本仓库状态-开始");
// 清空初始化中的数据
this.cleanInitializing();
// 检查已初始化的数据
this.checkFinished();
log.info("重置版本仓库状态-结束");
}
/**
* 清空初始化中的数据
*/
private void cleanInitializing() {
LambdaQueryWrapper<ApplicationRepositoryDO> wrapper = new LambdaQueryWrapper<ApplicationRepositoryDO>()
.eq(ApplicationRepositoryDO::getRepoStatus, RepositoryStatus.INITIALIZING.getStatus());
List<ApplicationRepositoryDO> repoList = applicationRepositoryDAO.selectList(wrapper);
for (ApplicationRepositoryDO repo : repoList) {
Long id = repo.getId();
// 更新状态
ApplicationRepositoryDO update = new ApplicationRepositoryDO();
update.setId(id);
update.setRepoStatus(RepositoryStatus.UNINITIALIZED.getStatus());
applicationRepositoryDAO.updateById(update);
// 删除文件夹
File clonePath = new File(Utils.getRepositoryEventDir(id));
Files1.delete(clonePath);
log.info("重置版本仓库状态-重置 id: {}, clonePath: {}", id, clonePath);
}
}
/**
* 检查已初始化的数据
*/
private void checkFinished() {
LambdaQueryWrapper<ApplicationRepositoryDO> wrapper = new LambdaQueryWrapper<ApplicationRepositoryDO>()
.eq(ApplicationRepositoryDO::getRepoStatus, RepositoryStatus.OK.getStatus());
List<ApplicationRepositoryDO> repoList = applicationRepositoryDAO.selectList(wrapper);
for (ApplicationRepositoryDO repo : repoList) {
// 检查是否存在
Long id = repo.getId();
File clonePath = new File(Utils.getRepositoryEventDir(id));
if (Files1.isDirectory(clonePath)) {
continue;
}
// 更新状态
ApplicationRepositoryDO update = new ApplicationRepositoryDO();
update.setId(id);
update.setRepoStatus(RepositoryStatus.UNINITIALIZED.getStatus());
applicationRepositoryDAO.updateById(update);
log.info("重置版本仓库状态-重置 id: {}, clonePath: {}", id, clonePath);
}
}
}

89
orion-ops-api/orion-ops-runner/src/main/java/cn/orionsec/ops/runner/ApplicationStartArgsRunner.java Normal file
View File

@@ -0,0 +1,89 @@
package cn.orionsec.ops.runner;
import cn.orionsec.ops.constant.common.EnableType;
import cn.orionsec.ops.constant.system.SystemEnvAttr;
import cn.orionsec.ops.service.api.SystemService;
import cn.orionsec.ops.service.api.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Arrays;
@Component
@Order(4000)
@Slf4j
public class ApplicationStartArgsRunner implements CommandLineRunner {
/**
* 关闭ip过滤器
*/
private static final String DISABLE_IP_FILTER = "--disable-ip-filter";
/**
* 自动生成默认管理员账号
*/
private static final String GENERATOR_ADMIN = "--generator-admin";
/**
* 重置默认管理员密码
*/
private static final String RESET_ADMIN = "--reset-admin";
@Resource
private SystemService systemService;
@Resource
private UserService userService;
@Override
public void run(String... args) {
log.info("应用启动参数: {}", Arrays.toString(args));
for (String arg : args) {
switch (arg) {
case DISABLE_IP_FILTER:
// 关闭ip过滤器
this.disableIpFilter();
break;
case GENERATOR_ADMIN:
// 生成默认管理员账号
this.generatorDefaultAdminUser();
break;
case RESET_ADMIN:
// 重置默认管理员密码
this.resetDefaultAdminUser();
break;
default:
break;
}
}
}
/**
* 关闭ip过滤器
*/
private void disableIpFilter() {
systemService.updateSystemOption(SystemEnvAttr.ENABLE_IP_FILTER, EnableType.DISABLED.getLabel());
log.info("启动参数-IP过滤器已关闭");
}
/**
* 生成默认管理员账号
*/
private void generatorDefaultAdminUser() {
userService.generatorDefaultAdminUser();
log.info("启动参数-默认管理员用户已初始化");
}
/**
* 重置默认管理员密码
*/
private void resetDefaultAdminUser() {
userService.resetDefaultAdminUserPassword();
log.info("启动参数-默认管理员密码已重置");
}
}

64
orion-ops-api/orion-ops-runner/src/main/java/cn/orionsec/ops/runner/CacheKeyCleanRunner.java Normal file
View File

@@ -0,0 +1,64 @@
package cn.orionsec.ops.runner;
import cn.orionsec.kit.lang.utils.Strings;
import cn.orionsec.kit.lang.utils.collect.Lists;
import cn.orionsec.ops.constant.Const;
import cn.orionsec.ops.constant.KeyConst;
import cn.orionsec.ops.utils.RedisUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.List;
@Component
@Order(1200)
@Slf4j
public class CacheKeyCleanRunner implements CommandLineRunner {
@Resource
private RedisTemplate<String, Object> redisTemplate;
@Override
public void run(String... args) {
log.info("重启清除缓存-开始");
List<String> scanKeys = Lists.of(
// terminal访问token
Strings.format(KeyConst.TERMINAL_ACCESS_TOKEN, "*"),
// terminal监视token
Strings.format(KeyConst.TERMINAL_WATCHER_TOKEN, "*"),
// 文件tail访问token
Strings.format(KeyConst.FILE_TAIL_ACCESS_TOKEN, "*"),
// 文件下载token
Strings.format(KeyConst.FILE_DOWNLOAD_TOKEN, "*"),
// sftp会话token
Strings.format(KeyConst.SFTP_SESSION_TOKEN, "*"),
// sftp上传请求token
Strings.format(KeyConst.SFTP_UPLOAD_ACCESS_TOKEN, "*"),
// 首页统计key
Strings.format(KeyConst.HOME_STATISTICS_COUNT_KEY, "*"),
// 调度统计key
Strings.format(KeyConst.SCHEDULER_TASK_STATISTICS_KEY, "*"),
// 环境缓存key
KeyConst.DATA_PROFILE_KEY,
// 数据导入缓存key
Strings.format(KeyConst.DATA_IMPORT_TOKEN, "*", "*"),
// 机器分组数据key
KeyConst.MACHINE_GROUP_DATA_KEY,
// 机器分组关联key
KeyConst.MACHINE_GROUP_REL_KEY
);
// 查询删除缓存key
scanKeys.stream()
.map(key -> RedisUtils.scanKeys(redisTemplate, key, Const.N_10000))
.filter(Lists::isNotEmpty)
.peek(keys -> keys.forEach(key -> log.info("重启清除缓存-处理 key: {}", key)))
.forEach(keys -> redisTemplate.delete(keys));
log.info("重启清除缓存-结束");
}
}

37
orion-ops-api/orion-ops-runner/src/main/java/cn/orionsec/ops/runner/CommandExecStatusCleanRunner.java Normal file
View File

@@ -0,0 +1,37 @@
package cn.orionsec.ops.runner;
import cn.orionsec.ops.constant.command.ExecStatus;
import cn.orionsec.ops.dao.CommandExecDAO;
import cn.orionsec.ops.entity.domain.CommandExecDO;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Date;
@Component
@Order(2200)
@Slf4j
public class CommandExecStatusCleanRunner implements CommandLineRunner {
@Resource
private CommandExecDAO commandExecDAO;
@Override
public void run(String... args) {
log.info("重置命令执行状态-开始");
LambdaQueryWrapper<CommandExecDO> wrapper = new LambdaQueryWrapper<CommandExecDO>()
.in(CommandExecDO::getExecStatus, ExecStatus.WAITING.getStatus(), ExecStatus.RUNNABLE.getStatus());
// 更新执行状态
CommandExecDO update = new CommandExecDO();
update.setExecStatus(ExecStatus.TERMINATED.getStatus());
update.setUpdateTime(new Date());
commandExecDAO.update(update, wrapper);
log.info("重置命令执行状态-结束");
}
}

67
orion-ops-api/orion-ops-runner/src/main/java/cn/orionsec/ops/runner/HostMachineInitializeRunner.java Normal file
View File

@@ -0,0 +1,67 @@
package cn.orionsec.ops.runner;
import cn.orionsec.kit.lang.utils.Systems;
import cn.orionsec.kit.lang.utils.net.IPs;
import cn.orionsec.ops.constant.Const;
import cn.orionsec.ops.constant.machine.MachineAuthType;
import cn.orionsec.ops.dao.MachineInfoDAO;
import cn.orionsec.ops.entity.domain.MachineInfoDO;
import cn.orionsec.ops.service.api.MachineEnvService;
import cn.orionsec.ops.utils.ValueMix;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
@Component
@Order(1600)
@Slf4j
public class HostMachineInitializeRunner implements CommandLineRunner {
private static final String DEFAULT_PASSWORD = "orionadmin";
@Resource
private MachineInfoDAO machineInfoDAO;
@Resource
private MachineEnvService machineEnvService;
@Override
public void run(String... args) {
log.info("初始化宿主机配置-开始");
this.initMachine();
log.info("初始化宿主机配置-结束");
}
/**
* 初始化宿主机
*/
private void initMachine() {
LambdaQueryWrapper<MachineInfoDO> wrapper = new LambdaQueryWrapper<MachineInfoDO>()
.eq(MachineInfoDO::getId, Const.HOST_MACHINE_ID);
MachineInfoDO machineInfo = machineInfoDAO.selectOne(wrapper);
if (machineInfo == null) {
// 插入机器
MachineInfoDO insert = new MachineInfoDO();
insert.setMachineName(Systems.HOST_NAME);
insert.setMachineTag(Const.HOST_MACHINE_TAG);
insert.setMachineHost(IPs.IP);
insert.setSshPort(22);
insert.setDescription("宿主机");
insert.setUsername(Systems.USER_NAME);
insert.setPassword(ValueMix.encrypt(DEFAULT_PASSWORD));
insert.setAuthType(MachineAuthType.PASSWORD.getType());
insert.setMachineStatus(Const.ENABLE);
machineInfoDAO.insert(insert);
machineInfoDAO.setId(insert.getId(), Const.HOST_MACHINE_ID);
log.info("宿主机已初始化");
// 初始化环境变量
machineEnvService.initEnv(Const.HOST_MACHINE_ID);
}
}
}

60
orion-ops-api/orion-ops-runner/src/main/java/cn/orionsec/ops/runner/LoadIpFilterRunner.java Normal file
View File

@@ -0,0 +1,60 @@
package cn.orionsec.ops.runner;
import cn.orionsec.ops.constant.common.EnableType;
import cn.orionsec.ops.constant.system.SystemEnvAttr;
import cn.orionsec.ops.interceptor.IpFilterInterceptor;
import cn.orionsec.ops.service.api.SystemEnvService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
@Component
@Order(1300)
@Slf4j
public class LoadIpFilterRunner implements CommandLineRunner {
@Resource
private SystemEnvService systemEnvService;
@Resource
private IpFilterInterceptor ipFilterInterceptor;
@Override
public void run(String... args) {
log.info("加载IP黑白名单-开始");
this.load();
log.info("加载IP黑白名单-结束");
}
/**
* 加载
*/
private void load() {
// 启用状态
String enableIpFilter = systemEnvService.getEnvValue(SystemEnvAttr.ENABLE_IP_FILTER.getKey());
if (!EnableType.of(enableIpFilter).getValue()) {
log.info("加载IP黑白名单-未启用");
return;
}
// 规则类型
String enableWhiteIpList = systemEnvService.getEnvValue(SystemEnvAttr.ENABLE_WHITE_IP_LIST.getKey());
boolean enableWhite = EnableType.of(enableWhiteIpList).getValue();
String loadFilterKey;
if (enableWhite) {
loadFilterKey = SystemEnvAttr.WHITE_IP_LIST.getKey();
log.info("加载IP黑白名单-加载白名单");
} else {
loadFilterKey = SystemEnvAttr.BLACK_IP_LIST.getKey();
log.info("加载IP黑白名单-加载黑名单");
}
String filter = systemEnvService.getEnvValue(loadFilterKey);
log.info("加载IP黑白名单-过滤规则:\n{}", filter);
// 加载
ipFilterInterceptor.set(true, enableWhite, filter);
}
}

88
orion-ops-api/orion-ops-runner/src/main/java/cn/orionsec/ops/runner/MachineMonitorStatusRunner.java Normal file
View File

@@ -0,0 +1,88 @@
package cn.orionsec.ops.runner;
import cn.orionsec.kit.lang.utils.Strings;
import cn.orionsec.kit.lang.utils.Threads;
import cn.orionsec.ops.constant.monitor.MonitorConst;
import cn.orionsec.ops.constant.monitor.MonitorStatus;
import cn.orionsec.ops.dao.MachineMonitorDAO;
import cn.orionsec.ops.entity.domain.MachineMonitorDO;
import cn.orionsec.ops.entity.dto.MachineMonitorDTO;
import cn.orionsec.ops.entity.query.MachineMonitorQuery;
import cn.orionsec.ops.service.api.MachineMonitorService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
@Component
@Order(4000)
@Slf4j
public class MachineMonitorStatusRunner implements CommandLineRunner {
@Resource
private MachineMonitorDAO machineMonitorDAO;
@Resource
private MachineMonitorService machineMonitorService;
@Override
public void run(String... args) throws Exception {
log.info("重置机器监控插件状态-开始");
// 清除启动中的状态
this.clearStartingStatus();
// 异步检查插件状态及版本
Threads.start(this::checkMonitorStatus);
log.info("重置机器监控插件状态-结束");
}
/**
* 清除启动中的状态
*/
private void clearStartingStatus() {
MachineMonitorDO update = new MachineMonitorDO();
update.setMonitorStatus(MonitorStatus.NOT_START.getStatus());
update.setUpdateTime(new Date());
LambdaQueryWrapper<MachineMonitorDO> wrapper = new LambdaQueryWrapper<MachineMonitorDO>()
.eq(MachineMonitorDO::getMonitorStatus, MonitorStatus.STARTING.getStatus());
machineMonitorDAO.update(update, wrapper);
}
/**
* 检查插件状态及版本
*/
private void checkMonitorStatus() {
List<MachineMonitorDTO> monitors = machineMonitorDAO.selectMonitorList(new MachineMonitorQuery(), null);
for (MachineMonitorDTO monitor : monitors) {
log.info("检测机器监控插件状态-开始 {} ({})", monitor.getMachineName(), monitor.getMachineHost());
MachineMonitorDO update = new MachineMonitorDO();
update.setId(monitor.getId());
String monitorUrl = monitor.getMonitorUrl();
String accessToken = monitor.getAccessToken();
// 不存在则设置默认值
if (Strings.isBlank(monitorUrl)) {
monitorUrl = Strings.format(MonitorConst.DEFAULT_URL_FORMAT, monitor.getMachineHost());
accessToken = MonitorConst.DEFAULT_ACCESS_TOKEN;
update.setMonitorUrl(monitorUrl);
update.setAccessToken(accessToken);
}
// 同步并且获取插件版本
String monitorVersion = machineMonitorService.syncMonitorAgent(monitor.getMachineId(), monitorUrl, accessToken);
if (monitorVersion == null) {
// 未启动
update.setMonitorStatus(MonitorStatus.NOT_START.getStatus());
} else {
update.setAgentVersion(monitorVersion);
update.setMonitorStatus(MonitorStatus.RUNNING.getStatus());
}
log.info("检测机器监控插件状态-完成 {} ({}), {}", monitor.getMachineName(), monitor.getMachineHost(), update.getMonitorStatus());
machineMonitorDAO.updateById(update);
}
}
}

88
orion-ops-api/orion-ops-runner/src/main/java/cn/orionsec/ops/runner/ReleaseStatusCleanRunner.java Normal file
View File

@@ -0,0 +1,88 @@
package cn.orionsec.ops.runner;
import cn.orionsec.ops.constant.app.ActionStatus;
import cn.orionsec.ops.constant.app.ReleaseStatus;
import cn.orionsec.ops.constant.app.StageType;
import cn.orionsec.ops.dao.ApplicationReleaseDAO;
import cn.orionsec.ops.dao.ApplicationReleaseMachineDAO;
import cn.orionsec.ops.entity.domain.ApplicationReleaseDO;
import cn.orionsec.ops.entity.domain.ApplicationReleaseMachineDO;
import cn.orionsec.ops.service.api.ApplicationActionLogService;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
@Component
@Order(2400)
@Slf4j
public class ReleaseStatusCleanRunner implements CommandLineRunner {
@Resource
private ApplicationReleaseDAO applicationReleaseDAO;
@Resource
private ApplicationReleaseMachineDAO applicationReleaseMachineDAO;
@Resource
private ApplicationActionLogService applicationActionLogService;
@Override
public void run(String... args) {
log.info("重置应用发布状态-开始");
Wrapper<ApplicationReleaseDO> wrapper = new LambdaQueryWrapper<ApplicationReleaseDO>()
.eq(ApplicationReleaseDO::getReleaseStatus, ReleaseStatus.RUNNABLE.getStatus());
List<ApplicationReleaseDO> releaseList = applicationReleaseDAO.selectList(wrapper);
for (ApplicationReleaseDO release : releaseList) {
Long releaseId = release.getId();
ApplicationReleaseDO update = new ApplicationReleaseDO();
update.setId(releaseId);
update.setReleaseStatus(ReleaseStatus.TERMINATED.getStatus());
update.setUpdateTime(new Date());
applicationReleaseDAO.updateById(update);
// 设置机器状态
this.resetMachineStatus(releaseId);
log.info("重置应用发布状态-执行 {}", releaseId);
}
log.info("重置应用发布状态-结束");
}
/**
* 设置机器状态
*
* @param releaseId releaseId
*/
private void resetMachineStatus(Long releaseId) {
// 查询机器
Wrapper<ApplicationReleaseMachineDO> wrapper = new LambdaQueryWrapper<ApplicationReleaseMachineDO>()
.eq(ApplicationReleaseMachineDO::getReleaseId, releaseId);
List<ApplicationReleaseMachineDO> machines = applicationReleaseMachineDAO.selectList(wrapper);
// 修改状态
for (ApplicationReleaseMachineDO machine : machines) {
ApplicationReleaseMachineDO update = new ApplicationReleaseMachineDO();
Long releaseMachineId = machine.getId();
update.setId(releaseMachineId);
update.setUpdateTime(new Date());
switch (ActionStatus.of(machine.getRunStatus())) {
case WAIT:
case RUNNABLE:
update.setRunStatus(ActionStatus.TERMINATED.getStatus());
break;
default:
break;
}
applicationReleaseMachineDAO.updateById(update);
// 设置操作状态
applicationActionLogService.resetActionStatus(releaseMachineId, StageType.RELEASE);
}
}
}

127
orion-ops-api/orion-ops-runner/src/main/java/cn/orionsec/ops/runner/SchedulerTaskRunner.java Normal file
View File

@@ -0,0 +1,127 @@
package cn.orionsec.ops.runner;
import cn.orionsec.ops.constant.Const;
import cn.orionsec.ops.constant.common.EnableType;
import cn.orionsec.ops.constant.scheduler.SchedulerTaskMachineStatus;
import cn.orionsec.ops.constant.scheduler.SchedulerTaskStatus;
import cn.orionsec.ops.constant.system.SystemEnvAttr;
import cn.orionsec.ops.dao.SchedulerTaskDAO;
import cn.orionsec.ops.dao.SchedulerTaskMachineRecordDAO;
import cn.orionsec.ops.dao.SchedulerTaskRecordDAO;
import cn.orionsec.ops.entity.domain.SchedulerTaskDO;
import cn.orionsec.ops.entity.domain.SchedulerTaskMachineRecordDO;
import cn.orionsec.ops.entity.domain.SchedulerTaskRecordDO;
import cn.orionsec.ops.task.TaskRegister;
import cn.orionsec.ops.task.TaskType;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
@Component
@Order(3300)
@Slf4j
public class SchedulerTaskRunner implements CommandLineRunner {
@Resource
private SchedulerTaskDAO schedulerTaskDAO;
@Resource
private SchedulerTaskRecordDAO schedulerTaskRecordDAO;
@Resource
private SchedulerTaskMachineRecordDAO schedulerTaskMachineRecordDAO;
@Resource
private TaskRegister taskRegister;
@Override
public void run(String... args) {
log.info("调度任务初始化-开始");
// 更新开始状态
this.updateTaskStatus();
// 更新执行记录状态
this.updateTaskRecordStatus();
// 自动恢复
this.autoResumeTask();
log.info("调度任务初始化-结束");
}
/**
* 更新任务状态
*/
private void updateTaskStatus() {
Boolean autoResume = EnableType.of(SystemEnvAttr.RESUME_ENABLE_SCHEDULER_TASK.getValue()).getValue();
List<SchedulerTaskDO> tasks = schedulerTaskDAO.selectList(null);
for (SchedulerTaskDO task : tasks) {
SchedulerTaskDO update = new SchedulerTaskDO();
update.setId(task.getId());
if (!autoResume || !Const.ENABLE.equals(task.getEnableStatus())) {
update.setEnableStatus(Const.DISABLE);
}
update.setUpdateTime(new Date());
// 最近状态
SchedulerTaskStatus status = SchedulerTaskStatus.of(task.getLatelyStatus());
switch (status) {
case WAIT:
case RUNNABLE:
update.setLatelyStatus(SchedulerTaskStatus.TERMINATED.getStatus());
break;
default:
break;
}
// 更新
schedulerTaskDAO.updateById(update);
}
}
/**
* 更新任务执行状态
*/
private void updateTaskRecordStatus() {
// 重置任务明细
Wrapper<SchedulerTaskRecordDO> recordWrapper = new LambdaQueryWrapper<SchedulerTaskRecordDO>()
.in(SchedulerTaskRecordDO::getTaskStatus, SchedulerTaskStatus.WAIT.getStatus(), SchedulerTaskStatus.RUNNABLE.getStatus());
SchedulerTaskRecordDO updateRecord = new SchedulerTaskRecordDO();
updateRecord.setTaskStatus(SchedulerTaskStatus.TERMINATED.getStatus());
updateRecord.setUpdateTime(new Date());
schedulerTaskRecordDAO.update(updateRecord, recordWrapper);
// 重置机器明细
Wrapper<SchedulerTaskMachineRecordDO> machineWrapper = new LambdaQueryWrapper<SchedulerTaskMachineRecordDO>()
.in(SchedulerTaskMachineRecordDO::getExecStatus, SchedulerTaskMachineStatus.WAIT.getStatus(), SchedulerTaskMachineStatus.RUNNABLE.getStatus());
SchedulerTaskMachineRecordDO updateMachine = new SchedulerTaskMachineRecordDO();
updateMachine.setExecStatus(SchedulerTaskMachineStatus.TERMINATED.getStatus());
updateMachine.setUpdateTime(new Date());
schedulerTaskMachineRecordDAO.update(updateMachine, machineWrapper);
}
/**
* 自动恢复任务
*/
private void autoResumeTask() {
Boolean autoResume = EnableType.of(SystemEnvAttr.RESUME_ENABLE_SCHEDULER_TASK.getValue()).getValue();
if (!autoResume) {
return;
}
// 查询启用的定时任务
LambdaQueryWrapper<SchedulerTaskDO> wrapper = new LambdaQueryWrapper<SchedulerTaskDO>()
.eq(SchedulerTaskDO::getEnableStatus, Const.ENABLE);
List<SchedulerTaskDO> taskList = schedulerTaskDAO.selectList(wrapper);
// 启用
for (SchedulerTaskDO task : taskList) {
Long id = task.getId();
log.info("调度任务自动恢复 id: {}, name: {}", id, task.getTaskName());
taskRegister.submit(TaskType.SCHEDULER_TASK, task.getExpression(), id);
}
}
}

48
orion-ops-api/orion-ops-runner/src/main/java/cn/orionsec/ops/runner/SftpTransferStatusCleanRunner.java Normal file
View File

@@ -0,0 +1,48 @@
package cn.orionsec.ops.runner;
import cn.orionsec.ops.constant.sftp.SftpTransferStatus;
import cn.orionsec.ops.constant.sftp.SftpTransferType;
import cn.orionsec.ops.dao.FileTransferLogDAO;
import cn.orionsec.ops.entity.domain.FileTransferLogDO;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Date;
@Component
@Order(2100)
@Slf4j
public class SftpTransferStatusCleanRunner implements CommandLineRunner {
@Resource
private FileTransferLogDAO fileTransferLogDAO;
@Override
public void run(String... args) {
log.info("重置传输状态-开始");
// 更新可打包传输状态
LambdaQueryWrapper<FileTransferLogDO> packageWrapper = new LambdaQueryWrapper<FileTransferLogDO>()
.eq(FileTransferLogDO::getTransferType, SftpTransferType.PACKAGE.getType())
.in(FileTransferLogDO::getTransferStatus, SftpTransferStatus.WAIT.getStatus(), SftpTransferStatus.RUNNABLE.getStatus());
FileTransferLogDO updatePackage = new FileTransferLogDO();
updatePackage.setTransferStatus(SftpTransferStatus.CANCEL.getStatus());
updatePackage.setUpdateTime(new Date());
fileTransferLogDAO.update(updatePackage, packageWrapper);
// 更新可恢复传输状态
LambdaQueryWrapper<FileTransferLogDO> resumeWrapper = new LambdaQueryWrapper<FileTransferLogDO>()
.ne(FileTransferLogDO::getTransferType, SftpTransferType.PACKAGE.getType())
.in(FileTransferLogDO::getTransferStatus, SftpTransferStatus.WAIT.getStatus(), SftpTransferStatus.RUNNABLE.getStatus());
FileTransferLogDO updateResume = new FileTransferLogDO();
updateResume.setTransferStatus(SftpTransferStatus.PAUSE.getStatus());
updateResume.setUpdateTime(new Date());
fileTransferLogDAO.update(updateResume, resumeWrapper);
log.info("重置传输状态-结束");
}
}

152
orion-ops-api/orion-ops-runner/src/main/java/cn/orionsec/ops/runner/SystemEnvInitializeRunner.java Normal file
View File

@@ -0,0 +1,152 @@
package cn.orionsec.ops.runner;
import cn.orionsec.kit.lang.utils.io.Files1;
import cn.orionsec.ops.constant.Const;
import cn.orionsec.ops.constant.common.EnableType;
import cn.orionsec.ops.constant.history.HistoryOperator;
import cn.orionsec.ops.constant.history.HistoryValueType;
import cn.orionsec.ops.constant.system.SystemEnvAttr;
import cn.orionsec.ops.constant.tail.FileTailMode;
import cn.orionsec.ops.dao.SystemEnvDAO;
import cn.orionsec.ops.entity.domain.SystemEnvDO;
import cn.orionsec.ops.service.api.HistoryValueService;
import cn.orionsec.ops.utils.PathBuilders;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.List;
@Component
@Order(1500)
@Slf4j
public class SystemEnvInitializeRunner implements CommandLineRunner {
@Resource
private SystemEnvDAO systemEnvDAO;
@Resource
private HistoryValueService historyValueService;
@Override
public void run(String... args) {
log.info("初始化系统环境初始化-开始");
this.initEnv();
log.info("初始化系统环境初始化-结束");
}
/**
* 初始化环境
*/
private void initEnv() {
// 查询所有的key
List<String> keys = SystemEnvAttr.getKeys();
LambdaQueryWrapper<SystemEnvDO> wrapper = new LambdaQueryWrapper<SystemEnvDO>()
.in(SystemEnvDO::getAttrKey, keys);
List<SystemEnvDO> envList = systemEnvDAO.selectList(wrapper);
// 初始化数据
for (String key : keys) {
SystemEnvAttr attr = SystemEnvAttr.of(key);
SystemEnvDO env = envList.stream()
.filter(s -> s.getAttrKey().equals(key))
.findFirst()
.orElse(null);
if (env == null) {
// 插入数据
String value = this.getAttrValue(attr);
SystemEnvDO insert = new SystemEnvDO();
insert.setAttrKey(key);
insert.setAttrValue(value);
insert.setDescription(attr.getDescription());
insert.setSystemEnv(attr.isSystemEnv() ? Const.IS_SYSTEM : Const.NOT_SYSTEM);
systemEnvDAO.insert(insert);
log.info("初始化系统变量 {} - {}", key, value);
// 插入历史值
Long id = insert.getId();
historyValueService.addHistory(id, HistoryValueType.SYSTEM_ENV, HistoryOperator.ADD, null, insert.getAttrValue());
// 设置本地值
attr.setValue(value);
} else {
// 设置本地值
attr.setValue(env.getAttrValue());
}
}
}
/**
* 获取属性值
*
* @param attr attr
* @return value
*/
private String getAttrValue(SystemEnvAttr attr) {
switch (attr) {
case KEY_PATH:
return createOrionOpsPath(Const.KEYS_PATH);
case PIC_PATH:
return createOrionOpsPath(Const.PIC_PATH);
case SWAP_PATH:
return createOrionOpsPath(Const.SWAP_PATH);
case SCREEN_PATH:
return createOrionOpsPath(Const.SCREEN_PATH);
case LOG_PATH:
return createOrionOpsPath(Const.LOG_PATH);
case TEMP_PATH:
return createOrionOpsPath(Const.TEMP_PATH);
case REPO_PATH:
return createOrionOpsPath(Const.REPO_PATH);
case DIST_PATH:
return createOrionOpsPath(Const.DIST_PATH);
case MACHINE_MONITOR_AGENT_PATH:
return createOrionOpsPath(Const.MACHINE_MONITOR_AGENT_PATH);
case TAIL_FILE_UPLOAD_PATH:
return createOrionOpsPath(Const.TAIL_FILE_PATH);
case TAIL_MODE:
return FileTailMode.TRACKER.getMode();
case TRACKER_DELAY_TIME:
return Const.TRACKER_DELAY_MS + Const.EMPTY;
case ENABLE_IP_FILTER:
case ENABLE_WHITE_IP_LIST:
case ENABLE_AUTO_CLEAN_FILE:
case ALLOW_MULTIPLE_LOGIN:
case RESUME_ENABLE_SCHEDULER_TASK:
case TERMINAL_ACTIVE_PUSH_HEARTBEAT:
case LOGIN_IP_BIND:
return EnableType.DISABLED.getLabel();
case LOGIN_FAILURE_LOCK:
case LOGIN_TOKEN_AUTO_RENEW:
return EnableType.ENABLED.getLabel();
case LOGIN_TOKEN_EXPIRE:
return Const.DEFAULT_LOGIN_TOKEN_EXPIRE_HOUR + Const.EMPTY;
case LOGIN_FAILURE_LOCK_THRESHOLD:
case STATISTICS_CACHE_EXPIRE:
return Const.N_5 + Const.EMPTY;
case LOGIN_TOKEN_AUTO_RENEW_THRESHOLD:
return Const.N_2 + Const.EMPTY;
case FILE_CLEAN_THRESHOLD:
return Const.DEFAULT_FILE_CLEAN_THRESHOLD + Const.EMPTY;
case SFTP_UPLOAD_THRESHOLD:
return Const.SFTP_UPLOAD_THRESHOLD + Const.EMPTY;
default:
return null;
}
}
/**
* 创建项目目录
*
* @param path path
* @return path
*/
public static String createOrionOpsPath(String path) {
String dir = PathBuilders.getHostEnvPath(path);
dir = Files1.getPath(dir);
Files1.mkdirs(dir);
return dir;
}
}

34
orion-ops-api/orion-ops-runner/src/main/java/cn/orionsec/ops/runner/SystemSpaceAnalysisRunner.java Normal file
View File

@@ -0,0 +1,34 @@
package cn.orionsec.ops.runner;
import cn.orionsec.kit.lang.utils.Threads;
import cn.orionsec.kit.lang.utils.time.Dates;
import cn.orionsec.ops.service.api.SystemService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
@Slf4j
@Component
@Order(3200)
public class SystemSpaceAnalysisRunner implements CommandLineRunner {
@Resource
private SystemService systemService;
@Override
public void run(String... args) {
try {
log.info("runner-执行占用磁盘空间统计-开始 {}", Dates.current());
// 不考虑多线程计算
Threads.start(systemService::analysisSystemSpace);
log.info("runner-执行占用磁盘空间统计-结束 {}", Dates.current());
} catch (Exception e) {
log.error("runner-执行占用磁盘空间统计-失败 {}", Dates.current(), e);
}
}
}