mianbin/ops-pro
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: mianbin:56150c156b5131186312b68b7a9eb55b7e2ccd02
Branches Tags
mianbin:master
mianbin:jenkins-engin
mianbin:temp
..
compare: mianbin:926c1af1e1a5cbc92f9aff8a78a409d28e4332e6
Branches Tags
mianbin:master
mianbin:jenkins-engin
mianbin:temp

2 Commits
56150c156b ... 926c1af1e1

Author SHA1 Message Date
唐潇凯
926c1af1e1 机器环境变量管理规范化 2025-06-06 11:37:11 +08:00
唐潇凯
f28fe4ecdf 机器环境变量管理规范化 2025-06-06 11:35:57 +08:00
35 changed files with 1830 additions and 1961 deletions
Show Stats Expand all files Collapse all files

5
modules/module-ci-machine/src/main/java/cd/casic/module/machine/contants/CommonConstants.java
View File

@ -1,5 +0,0 @@
package cd.casic.module.machine.contants;
public interface CommonConstants {
String DEFAULT_PACKAGE_NAME = "com.casic";
}

27
modules/module-ci-machine/src/main/java/cd/casic/module/machine/contants/MachineErrorCodeConstants.java Normal file
View File

@ -0,0 +1,27 @@
package cd.casic.module.machine.contants;
import cd.casic.framework.commons.exception.ErrorCode;
/**
* 机器报错
*/
public interface MachineErrorCodeConstants {
// ========== 机器模块 1-003-000-000 ==========
ErrorCode MACHINE_INFO_NULL = new ErrorCode(1_003_000_000, "机器信息为空");
ErrorCode UPLOADING_FILE_FAIL = new ErrorCode(1_003_000_001, "上传文件失败");
ErrorCode DOWNLOAD_FILE_FAIL = new ErrorCode(1_003_000_002, "下载失败");
ErrorCode FILENAME_NULL = new ErrorCode(1_003_000_003, "文件名为空");
ErrorCode READ_FILE_FAIL = new ErrorCode(1_003_000_004, "读取文件失败");
ErrorCode DELETE_FILE_FAIL = new ErrorCode(1_003_000_005, "删除文件失败");
ErrorCode MACHINE_PROXY_DTO_NULL = new ErrorCode(1_003_000_006, "MachineProxyDTO对象为空");
ErrorCode MACHINE_PROXY_NULL = new ErrorCode(1_003_000_007, "MachineProxy代理不存在");
ErrorCode PARAMETER_ERROR = new ErrorCode(1_003_000_008, "参数错误");
ErrorCode MACHINE_ENV_NULL = new ErrorCode(1_003_000_009, "机器环境变量为空");
ErrorCode MACHINE_ENV_NOT_EXISTS = new ErrorCode(1_003_000_009, "机器不存在");
ErrorCode MACHINE_ENV_EXISTS = new ErrorCode(1_003_000_009, "机器已存在");
ErrorCode MACHINE_ENV_KEY_ILLEGAL = new ErrorCode(1_003_000_010, "机器环境变量键不合法");
ErrorCode OSS_PARAM_NULL = new ErrorCode(1_003_000_011, "oss参数无法读取");
ErrorCode SECRETKEY_NULL = new ErrorCode(1_003_000_012, "密钥为空");
}

58
modules/module-ci-machine/src/main/java/cd/casic/module/machine/controller/MachineEnvController.java
View File

@ -1,69 +1,83 @@
package cd.casic.module.machine.controller; package cd.casic.module.machine.controller;
import cd.casic.framework.commons.pojo.CommonResult; import cd.casic.framework.commons.pojo.CommonResult;
import cd.casic.framework.commons.pojo.PageResult;
import cd.casic.framework.commons.util.object.BeanUtils;
import cd.casic.module.machine.dal.dataobject.MachineEnvDO;
import cd.casic.module.machine.service.MachineEnvService; import cd.casic.module.machine.service.MachineEnvService;
import cd.casic.module.machine.dto.MachineEnvDTO; import cd.casic.module.machine.controller.vo.MachineEnvVO;
import cn.hutool.core.collection.CollUtil;
import io.swagger.v3.oas.annotations.Operation; import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag; import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource; import jakarta.annotation.Resource;
import jakarta.validation.Valid;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import static cd.casic.framework.commons.pojo.CommonResult.success; import static cd.casic.framework.commons.pojo.CommonResult.success;
/** /**
* 环境变量控制器 * 环境变量控制器
*/ */
@RestController
@RequestMapping("/api/machineEnv")
@Tag(name = "环境变量管理") @Tag(name = "环境变量管理")
@RequiredArgsConstructor @RestController
@RequestMapping("/ci/machineEnv")
@Validated
public class MachineEnvController { public class MachineEnvController {
@Resource @Resource
private MachineEnvService machineEnvService; private MachineEnvService machineEnvService;
@PostMapping("/add") @PostMapping("/create")
@Operation(summary = "新增环境变量") @Operation(summary = "新增环境变量")
public CommonResult add(@RequestBody MachineEnvDTO machineEnvDTO) { @PreAuthorize("@ss.hasPermission('ci:machineEnv:create')")
machineEnvService.add(machineEnvDTO); public CommonResult<Long> createEnv(@Valid @RequestBody MachineEnvVO machineEnvVO) {
return success(true); Long id = machineEnvService.createEnv(machineEnvVO);
return success(id);
} }
@PutMapping("/update") @PutMapping("/update")
@Operation(summary = "修改环境变量") @Operation(summary = "修改环境变量")
public CommonResult update(@RequestBody MachineEnvDTO machineEnvDTO) { @PreAuthorize("@ss.hasPermission('ci:machineEnv:update')")
machineEnvService.update(machineEnvDTO); public CommonResult<Boolean> updateEnv(@Valid@RequestBody MachineEnvVO machineEnvVO) {
machineEnvService.updateEnv(machineEnvVO);
return success(true); return success(true);
} }
@DeleteMapping("/delete") @DeleteMapping("/delete")
@Operation(summary = "删除机器的环境变量") @Operation(summary = "删除机器的环境变量")
public CommonResult deleteByMachineId(@RequestParam Long machineEvnId) { @PreAuthorize("@ss.hasPermission('ci:machineEnv:delete')")
machineEnvService.deleteByMachineId(machineEvnId); public CommonResult<Boolean> deleteEnv(@RequestParam("id") Long id) {
machineEnvService.deleteEnv(id);
return success(true); return success(true);
} }
@DeleteMapping("/deleteList") @DeleteMapping("/deleteList")
@Operation(summary = "批量删除机器环境变量") @Operation(summary = "批量删除机器环境变量")
public CommonResult deleteList(@RequestParam String ids) { @PreAuthorize("@ss.hasPermission('ci:machineEnv:delete')")
machineEnvService.deleteList(ids); public CommonResult<Boolean> deleteEnvList(@RequestParam("ids") String ids) {
machineEnvService.deleteEnvList(ids);
return success(true); return success(true);
} }
@GetMapping("/getByMachineId") @GetMapping("/getEnv")
@Operation(summary = "获取机器的环境变量") @Operation(summary = "获取机器的环境变量")
public CommonResult getByMachineId(@RequestParam Long machineId) { public CommonResult<MachineEnvVO> getEnv(@RequestParam("id") Long id) {
return success(machineEnvService.getByMachineId(machineId)); MachineEnvVO machineEnvVO = machineEnvService.getEnv(id);
return success(machineEnvVO);
} }
@PostMapping("/list") @PostMapping("/list")
@Operation(summary = "获取环境变量列表") @Operation(summary = "获取环境变量列表")
public CommonResult list(@RequestBody MachineEnvDTO machineEnvDTO) { public CommonResult<PageResult<MachineEnvVO>> getEnvPage(@Valid @RequestBody MachineEnvVO machineEnvVO) {
return success(machineEnvService.listEnv(machineEnvDTO)); PageResult<MachineEnvDO> pageResult = machineEnvService.getEnvPage(machineEnvVO);
if (CollUtil.isEmpty(pageResult.getList())) {
return success(new PageResult<>(pageResult.getTotal()));
}
return success(BeanUtils.toBean(pageResult, MachineEnvVO.class));
} }
} }

252
modules/module-ci-machine/src/main/java/cd/casic/module/machine/controller/MachineInfoController.java
View File

@ -1,126 +1,126 @@
package cd.casic.module.machine.controller; //package cd.casic.module.machine.controller;
//
import cd.casic.framework.commons.pojo.CommonResult; //import cd.casic.framework.commons.pojo.CommonResult;
import cd.casic.module.machine.entity.MachineInfo; //import cd.casic.framework.commons.pojo.PageResult;
import cd.casic.module.machine.enums.ConnectionStatus; //import cd.casic.module.machine.dal.dataobject.MachineInfo;
import cd.casic.module.machine.service.MachineInfoService; //import cd.casic.module.machine.enums.ConnectionStatus;
import cd.casic.module.machine.dto.MachineInfoDto; //import cd.casic.module.machine.service.MachineInfoService;
import cd.casic.module.machine.utils.PageResult; //import cd.casic.module.machine.controller.vo.MachineInfoDto;
import io.swagger.v3.oas.annotations.Operation; //import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag; //import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource; //import jakarta.annotation.Resource;
import org.springframework.web.bind.annotation.*; //import org.springframework.web.bind.annotation.*;
//
import java.util.Map; //import java.util.Map;
//
import static cd.casic.framework.commons.pojo.CommonResult.success; //import static cd.casic.framework.commons.pojo.CommonResult.success;
//
@RestController //@RestController
@Tag(name = "机器信息管理") //@Tag(name = "机器信息管理")
@RequestMapping("/api/machineInfo") //@RequestMapping("/api/machineInfo")
public class MachineInfoController { //public class MachineInfoController {
@Resource // @Resource
private MachineInfoService machineInfoService; // private MachineInfoService machineInfoService;
//
@PostMapping("/add") // @PostMapping("/add")
@Operation(summary = "新增机器信息") // @Operation(summary = "新增机器信息")
public CommonResult<Boolean> add(@RequestBody MachineInfoDto machineInfoDto) { // public CommonResult<Boolean> add(@RequestBody MachineInfoDto machineInfoDto) {
return success(machineInfoService.addMachineInfo(machineInfoDto)); // return success(machineInfoService.addMachineInfo(machineInfoDto));
} // }
//
//
@PostMapping("/list") // @PostMapping("/list")
@Operation(summary = "获取机器信息列表") // @Operation(summary = "获取机器信息列表")
public CommonResult<PageResult<MachineInfoDto>> list(@RequestBody MachineInfoDto machineInfoDto) { // public CommonResult<PageResult<MachineInfoDto>> list(@RequestBody MachineInfoDto machineInfoDto) {
return success(machineInfoService.listMachineInfo(machineInfoDto)); // return success(machineInfoService.listMachineInfo(machineInfoDto));
} // }
//
@PutMapping("/update") // @PutMapping("/update")
@Operation(summary = "编辑机器信息") // @Operation(summary = "编辑机器信息")
public CommonResult<Boolean> update(@RequestBody MachineInfoDto machineInfoDto) { // public CommonResult<Boolean> update(@RequestBody MachineInfoDto machineInfoDto) {
return success(machineInfoService.updateMachineInfo(machineInfoDto)); // return success(machineInfoService.updateMachineInfo(machineInfoDto));
} // }
//
@PutMapping("/updateStatus") // @PutMapping("/updateStatus")
@Operation(summary = "机器启用/停用") // @Operation(summary = "机器启用/停用")
public CommonResult<Boolean> updateStatus(@RequestBody MachineInfoDto machineInfoDto) { // public CommonResult<Boolean> updateStatus(@RequestBody MachineInfoDto machineInfoDto) {
return success(machineInfoService.updateStatus(machineInfoDto)); // return success(machineInfoService.updateStatus(machineInfoDto));
} // }
//
@PutMapping("/bindingSecretKey") // @PutMapping("/bindingSecretKey")
@Operation(summary = "绑定密钥") // @Operation(summary = "绑定密钥")
public CommonResult<Boolean> bindingSecretKey(@RequestBody MachineInfoDto machineInfoDto) { // public CommonResult<Boolean> bindingSecretKey(@RequestBody MachineInfoDto machineInfoDto) {
return success(machineInfoService.bindingSecretKey(machineInfoDto)); // return success(machineInfoService.bindingSecretKey(machineInfoDto));
} // }
//
@DeleteMapping("/delete") // @DeleteMapping("/delete")
@Operation(summary = "机器信息删除") // @Operation(summary = "机器信息删除")
public CommonResult<Boolean> delete(@RequestParam Long machineInfoId) { // public CommonResult<Boolean> delete(@RequestParam Long machineInfoId) {
machineInfoService.deleteMachineInfo(machineInfoId); // machineInfoService.deleteMachineInfo(machineInfoId);
return success(true); // return success(true);
} // }
//
@DeleteMapping("/deleteList") // @DeleteMapping("/deleteList")
@Operation(summary = "批量删除机器信息") // @Operation(summary = "批量删除机器信息")
public CommonResult<Boolean> deleteList(@RequestParam String machineInfoIds) { // public CommonResult<Boolean> deleteList(@RequestParam String machineInfoIds) {
machineInfoService.deleteList(machineInfoIds); // machineInfoService.deleteList(machineInfoIds);
return success(true); // return success(true);
} // }
//
@PostMapping("/test") // @PostMapping("/test")
@Operation(summary = "测试机器连接") // @Operation(summary = "测试机器连接")
public CommonResult<Boolean> testConnection(@RequestParam Long id) { // public CommonResult<Boolean> testConnection(@RequestParam Long id) {
return success(machineInfoService.testConnection(id)); // return success(machineInfoService.testConnection(id));
} // }
//
@GetMapping("/status/{machineName}") // @GetMapping("/status/{machineName}")
@Operation(summary = "获取机器连接状态") // @Operation(summary = "获取机器连接状态")
public CommonResult<ConnectionStatus> getConnectionStatus(@PathVariable String machineName) { // public CommonResult<ConnectionStatus> getConnectionStatus(@PathVariable String machineName) {
return success(machineInfoService.getConnectionStatus(machineName)); // return success(machineInfoService.getConnectionStatus(machineName));
} // }
//
@GetMapping("/status/all") // @GetMapping("/status/all")
@Operation(summary = "获取所有机器连接状态") // @Operation(summary = "获取所有机器连接状态")
public CommonResult<Map<String, ConnectionStatus>> getAllConnectionStatus() { // public CommonResult<Map<String, ConnectionStatus>> getAllConnectionStatus() {
return success(machineInfoService.getAllConnectionStatus()); // return success(machineInfoService.getAllConnectionStatus());
} // }
//
@PostMapping("/connect") // @PostMapping("/connect")
@Operation(summary = "建立机器连接") // @Operation(summary = "建立机器连接")
public CommonResult<String> connect(@RequestBody MachineInfo machineInfo) { // public CommonResult<String> connect(@RequestBody MachineInfo machineInfo) {
return success(machineInfoService.connect(machineInfo)); // return success(machineInfoService.connect(machineInfo));
} // }
//
@PostMapping("/disconnect/{sessionId}") // @PostMapping("/disconnect/{sessionId}")
@Operation(summary = "断开机器连接") // @Operation(summary = "断开机器连接")
public CommonResult<Boolean> disconnect(@PathVariable String sessionId) { // public CommonResult<Boolean> disconnect(@PathVariable String sessionId) {
return success(machineInfoService.disconnect(sessionId)); // return success(machineInfoService.disconnect(sessionId));
} // }
//
@PostMapping("/execute/{sessionId}") // @PostMapping("/execute/{sessionId}")
@Operation(summary = "执行远程命令") // @Operation(summary = "执行远程命令")
public CommonResult<String> executeCommand( // public CommonResult<String> executeCommand(
@PathVariable String sessionId, // @PathVariable String sessionId,
@RequestBody String command) { // @RequestBody String command) {
//
return success(machineInfoService.executeCommand(sessionId, command)); // return success(machineInfoService.executeCommand(sessionId, command));
} // }
//
@PostMapping("/upload/{sessionId}") // @PostMapping("/upload/{sessionId}")
@Operation(summary = "上传文件到远程机器") // @Operation(summary = "上传文件到远程机器")
public CommonResult<Boolean> uploadFile( // public CommonResult<Boolean> uploadFile(
@PathVariable String sessionId, // @PathVariable String sessionId,
@RequestParam String localFilePath, // @RequestParam String localFilePath,
@RequestParam String remoteFilePath) { // @RequestParam String remoteFilePath) {
return success(machineInfoService.uploadFile(sessionId, localFilePath, remoteFilePath)); // return success(machineInfoService.uploadFile(sessionId, localFilePath, remoteFilePath));
} // }
//
@PostMapping("/download/{sessionId}") // @PostMapping("/download/{sessionId}")
@Operation(summary = "从远程机器下载文件") // @Operation(summary = "从远程机器下载文件")
public CommonResult<Boolean> downloadFile( // public CommonResult<Boolean> downloadFile(
@PathVariable String sessionId, // @PathVariable String sessionId,
@RequestParam String remoteFilePath, // @RequestParam String remoteFilePath,
@RequestParam String localFilePath) { // @RequestParam String localFilePath) {
return success(machineInfoService.downloadFile(sessionId, remoteFilePath, localFilePath)); // return success(machineInfoService.downloadFile(sessionId, remoteFilePath, localFilePath));
} // }
} //}

134
modules/module-ci-machine/src/main/java/cd/casic/module/machine/controller/MachineProxyController.java
View File

@ -1,67 +1,67 @@
package cd.casic.module.machine.controller; //package cd.casic.module.machine.controller;
//
import cd.casic.framework.commons.pojo.CommonResult; //import cd.casic.framework.commons.pojo.CommonResult;
import cd.casic.module.machine.service.MachineProxyService; //import cd.casic.module.machine.service.MachineProxyService;
import cd.casic.module.machine.dto.MachineProxyDTO; //import cd.casic.module.machine.controller.vo.MachineProxyDTO;
//
import io.swagger.v3.oas.annotations.Operation; //import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag; //import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource; //import jakarta.annotation.Resource;
import lombok.RequiredArgsConstructor; //import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*; //import org.springframework.web.bind.annotation.*;
//
import static cd.casic.framework.commons.pojo.CommonResult.success; //import static cd.casic.framework.commons.pojo.CommonResult.success;
//
/** ///**
* 机器代理控制器 // * 机器代理控制器
*/ // */
@RestController //@RestController
@RequestMapping("/api/machineProxy") //@RequestMapping("/api/machineProxy")
@Tag(name = "机器代理管理") //@Tag(name = "机器代理管理")
@RequiredArgsConstructor //@RequiredArgsConstructor
public class MachineProxyController { //public class MachineProxyController {
//
@Resource // @Resource
private MachineProxyService machineProxyService; // private MachineProxyService machineProxyService;
//
@PostMapping("/register") // @PostMapping("/register")
@Operation(summary = "注册新的机器代理") // @Operation(summary = "注册新的机器代理")
public CommonResult register(@RequestBody MachineProxyDTO machineProxyDTO) { // public CommonResult register(@RequestBody MachineProxyDTO machineProxyDTO) {
machineProxyService.register(machineProxyDTO); // machineProxyService.register(machineProxyDTO);
return success(true); // return success(true);
} // }
//
@PostMapping("/list") // @PostMapping("/list")
@Operation(summary = "获取代理列表") // @Operation(summary = "获取代理列表")
public CommonResult list(@RequestBody MachineProxyDTO machineProxyDTO) { // public CommonResult list(@RequestBody MachineProxyDTO machineProxyDTO) {
return success(machineProxyService.list(machineProxyDTO)); // return success(machineProxyService.list(machineProxyDTO));
} // }
//
@PutMapping("/updateStatus") // @PutMapping("/updateStatus")
@Operation(summary = "更新代理状态") // @Operation(summary = "更新代理状态")
public CommonResult updateStatus(@RequestBody MachineProxyDTO machineProxyDTO) { // public CommonResult updateStatus(@RequestBody MachineProxyDTO machineProxyDTO) {
machineProxyService.updateStatus(machineProxyDTO); // machineProxyService.updateStatus(machineProxyDTO);
return success(true); // return success(true);
} // }
//
@GetMapping("/statistics/status") // @GetMapping("/statistics/status")
@Operation(summary = "获取所有代理的状态统计") // @Operation(summary = "获取所有代理的状态统计")
public CommonResult getStatusStatistics() { // public CommonResult getStatusStatistics() {
return success(machineProxyService.getStatusStatistics()); // return success(machineProxyService.getStatusStatistics());
} // }
//
@PutMapping("/update") // @PutMapping("/update")
@Operation(summary = "更新代理信息") // @Operation(summary = "更新代理信息")
public CommonResult updateConfig(@RequestBody MachineProxyDTO machineProxyDTO) { // public CommonResult updateConfig(@RequestBody MachineProxyDTO machineProxyDTO) {
machineProxyService.update(machineProxyDTO); // machineProxyService.update(machineProxyDTO);
return success(true); // return success(true);
} // }
//
@DeleteMapping("/batch") // @DeleteMapping("/batch")
@Operation(summary = "批量删除代理") // @Operation(summary = "批量删除代理")
public CommonResult deleteBatch(@RequestParam String ids) { // public CommonResult deleteBatch(@RequestParam String ids) {
machineProxyService.delete(ids); // machineProxyService.delete(ids);
return success(true); // return success(true);
} // }
//
} //}

114
modules/module-ci-machine/src/main/java/cd/casic/module/machine/controller/SecretKeyController.java
View File

@ -1,58 +1,56 @@
package cd.casic.module.machine.controller; //package cd.casic.module.machine.controller;
//
import cd.casic.framework.commons.pojo.CommonResult; //import cd.casic.framework.commons.pojo.CommonResult;
import cd.casic.module.machine.entity.SecretKey; //import cd.casic.framework.commons.pojo.PageResult;
import cd.casic.module.machine.service.SecretKeyService; //import cd.casic.module.machine.dal.dataobject.SecretKey;
import cd.casic.module.machine.dto.SecretKeyDto; //import cd.casic.module.machine.service.SecretKeyService;
import cd.casic.module.machine.utils.PageResult; //import cd.casic.module.machine.controller.vo.SecretKeyDto;
import io.swagger.v3.oas.annotations.Operation; //import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag; //import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource; //import jakarta.annotation.Resource;
import org.springframework.core.io.InputStreamResource; //import org.springframework.web.bind.annotation.*;
import org.springframework.web.bind.annotation.*; //
import org.springframework.web.multipart.MultipartFile; //import java.util.List;
//
import java.util.List; //import static cd.casic.framework.commons.pojo.CommonResult.success;
//
import static cd.casic.framework.commons.pojo.CommonResult.success; //@RestController
//@RequestMapping("/api/secretKey")
@RestController //@Tag(name = "密钥管理")
@RequestMapping("/api/secretKey") //public class SecretKeyController {
@Tag(name = "密钥管理") // @Resource
public class SecretKeyController { // private SecretKeyService secretKeyService;
@Resource //
private SecretKeyService secretKeyService; // @PostMapping(value = "/add")
// @Operation(summary = "新增密钥")
@PostMapping(value = "/add") // public CommonResult<Boolean> add(@RequestBody SecretKeyDto secretKeyDto) throws Exception {
@Operation(summary = "新增密钥") // return success(secretKeyService.addSecretKey(secretKeyDto));
public CommonResult<Boolean> add(@RequestBody SecretKeyDto secretKeyDto) throws Exception { // }
return success(secretKeyService.addSecretKey(secretKeyDto)); //
} // @PutMapping("/bindingMachine")
// @Operation(summary = "绑定机器")
@PutMapping("/bindingMachine") // public CommonResult<Boolean> bindingMachine(@RequestParam("secretKeyId") Long secretKeyId, @RequestParam("machineIds") List<Long> machineIds) {
@Operation(summary = "绑定机器") // secretKeyService.bindingMachine(secretKeyId, machineIds);
public CommonResult<Boolean> bindingMachine(@RequestParam("secretKeyId") Long secretKeyId, @RequestParam("machineIds") List<Long> machineIds) { // return success(true);
secretKeyService.bindingMachine(secretKeyId, machineIds); // }
return success(true); //
} // @PutMapping("/update")
// @Operation(summary = "编辑密钥信息")
@PutMapping("/update") // public CommonResult<Boolean> update(@RequestBody SecretKeyDto secretKeyDto) {
@Operation(summary = "编辑密钥信息") // return success(secretKeyService.updateSecretKey(secretKeyDto));
public CommonResult<Boolean> update(@RequestBody SecretKeyDto secretKeyDto) { // }
return success(secretKeyService.updateSecretKey(secretKeyDto)); //
} // @DeleteMapping("/deleteList")
// @Operation(summary = "批量删除密钥")
@DeleteMapping("/deleteList") // public CommonResult<Boolean> deleteList(@RequestParam("secretKeyId") List<Long> secretKeyIds) {
@Operation(summary = "批量删除密钥") // return success(secretKeyService.deleteList(secretKeyIds));
public CommonResult<Boolean> deleteList(@RequestParam("secretKeyId") List<Long> secretKeyIds) { // }
return success(secretKeyService.deleteList(secretKeyIds)); //
} // @PostMapping("/list")
// @Operation(summary = "获取密钥信息列表")
@PostMapping("/list") // public CommonResult<PageResult<SecretKey>> list(@RequestBody SecretKeyDto secretKeyDto) {
@Operation(summary = "获取密钥信息列表") // return success(secretKeyService.listSecretKey(secretKeyDto));
public CommonResult<PageResult<SecretKey>> list(@RequestBody SecretKeyDto secretKeyDto) { // }
return success(secretKeyService.listSecretKey(secretKeyDto)); //
} //
//}
}

35
modules/module-ci-machine/src/main/java/cd/casic/module/machine/controller/vo/MachineEnvVO.java Normal file
View File

@ -0,0 +1,35 @@
package cd.casic.module.machine.controller.vo;
import cd.casic.framework.commons.pojo.PageParam;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import lombok.experimental.Accessors;
import java.time.LocalDateTime;
@Schema(description = "管理后台 - 机器环境变量信息 Response VO")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true) // 添加链式调用支持
public class MachineEnvVO extends PageParam{
@Schema(description = "环境变量ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
private Long id;
@Schema(description = "环境变量键", requiredMode = Schema.RequiredMode.REQUIRED, example = "JAVA_HOME")
private String envKey;
@Schema(description = "环境变量值", requiredMode = Schema.RequiredMode.REQUIRED, example = "/usr/java/jdk1.8.0_271")
private String envValue;
@Schema(description = "环境变量描述", example = "Java运行环境路径")
private String description;
@Schema(description = "关联的机器ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
private Long machineId;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED, example = "2023-06-15T10:30:00")
private LocalDateTime createTime;
@Schema(description = "更新时间", example = "2023-06-15T10:30:00")
private LocalDateTime updateTime;
}

2
modules/module-ci-machine/src/main/java/cd/casic/module/machine/dto/MachineInfoDto.java → modules/module-ci-machine/src/main/java/cd/casic/module/machine/controller/vo/MachineInfoDto.java
View File

@ -1,4 +1,4 @@
package cd.casic.module.machine.dto; package cd.casic.module.machine.controller.vo;
import lombok.AllArgsConstructor; import lombok.AllArgsConstructor;
import lombok.Data; import lombok.Data;

4
modules/module-ci-machine/src/main/java/cd/casic/module/machine/dto/MachineProxyDTO.java → modules/module-ci-machine/src/main/java/cd/casic/module/machine/controller/vo/MachineProxyVO.java
View File

@ -1,4 +1,4 @@
package cd.casic.module.machine.dto; package cd.casic.module.machine.controller.vo;
import cd.casic.module.machine.enums.MachineProxyStatus; import cd.casic.module.machine.enums.MachineProxyStatus;
import lombok.*; import lombok.*;
@ -15,7 +15,7 @@ import java.util.Objects;
@Builder @Builder
@NoArgsConstructor @NoArgsConstructor
@AllArgsConstructor @AllArgsConstructor
public class MachineProxyDTO extends PageDto implements Serializable { public class MachineProxyVO extends PageDto implements Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
private Long id; private Long id;

2
modules/module-ci-machine/src/main/java/cd/casic/module/machine/dto/PageDto.java → modules/module-ci-machine/src/main/java/cd/casic/module/machine/controller/vo/PageDto.java
View File

@ -1,4 +1,4 @@
package cd.casic.module.machine.dto; package cd.casic.module.machine.controller.vo;
import lombok.Data; import lombok.Data;

3
modules/module-ci-machine/src/main/java/cd/casic/module/machine/dto/SecretKeyDto.java → modules/module-ci-machine/src/main/java/cd/casic/module/machine/controller/vo/SecretKeyDto.java
View File

@ -1,10 +1,9 @@
package cd.casic.module.machine.dto; package cd.casic.module.machine.controller.vo;
import lombok.AllArgsConstructor; import lombok.AllArgsConstructor;
import lombok.Data; import lombok.Data;
import lombok.EqualsAndHashCode; import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor; import lombok.NoArgsConstructor;
import org.springframework.web.multipart.MultipartFile;
import java.util.Date; import java.util.Date;
import java.util.List; import java.util.List;

24
modules/module-ci-machine/src/main/java/cd/casic/module/machine/convert/MachineEnvConvert.java Normal file
View File

@ -0,0 +1,24 @@
package cd.casic.module.machine.convert;
import cd.casic.module.machine.controller.vo.MachineEnvVO;
import cd.casic.module.machine.dal.dataobject.MachineEnvDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
@Mapper
public interface MachineEnvConvert {
MachineEnvConvert INSTANCE = Mappers.getMapper(MachineEnvConvert.class);
// 转换实体为VO
default MachineEnvVO convertToVO(MachineEnvDO machineEnvDO) {
MachineEnvVO VO = new MachineEnvVO();
VO.setId(machineEnvDO.getId());
VO.setEnvKey(machineEnvDO.getEnvKey());
VO.setEnvValue(machineEnvDO.getEnvValue());
VO.setDescription(machineEnvDO.getDescription());
VO.setCreateTime(machineEnvDO.getCreateTime());
VO.setUpdateTime(machineEnvDO.getUpdateTime());
return VO;
}
}

17
modules/module-ci-machine/src/main/java/cd/casic/module/machine/entity/MachineEnv.java → modules/module-ci-machine/src/main/java/cd/casic/module/machine/dal/dataobject/MachineEnvDO.java
View File

@ -1,8 +1,10 @@
package cd.casic.module.machine.entity; package cd.casic.module.machine.dal.dataobject;
import cd.casic.framework.mybatis.core.dataobject.BaseDO;
import com.baomidou.mybatisplus.annotation.*; import com.baomidou.mybatisplus.annotation.*;
import lombok.*; import lombok.*;
import lombok.experimental.Accessors;
import java.io.Serializable; import java.io.Serializable;
@ -12,13 +14,20 @@ import java.io.Serializable;
@EqualsAndHashCode(callSuper = true) @EqualsAndHashCode(callSuper = true)
@Data @Data
@Accessors(chain = true)
@TableName("machine_env")
@Builder
@NoArgsConstructor @NoArgsConstructor
@AllArgsConstructor @AllArgsConstructor
@TableName("machine_env") public class MachineEnvDO extends BaseDO {
public class MachineEnv extends BaseEntity implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 环境变量id
*/
@TableId
private Long id;
/** /**
* 机器ID（唯一关联） * 机器ID（唯一关联）
*/ */

2
modules/module-ci-machine/src/main/java/cd/casic/module/machine/entity/MachineInfo.java → modules/module-ci-machine/src/main/java/cd/casic/module/machine/dal/dataobject/MachineInfo.java
View File

@ -1,4 +1,4 @@
package cd.casic.module.machine.entity; package cd.casic.module.machine.dal.dataobject;
import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName;

4
modules/module-ci-machine/src/main/java/cd/casic/module/machine/entity/MachineProxy.java → modules/module-ci-machine/src/main/java/cd/casic/module/machine/dal/dataobject/MachineProxy.java
View File

@ -1,10 +1,8 @@
package cd.casic.module.machine.entity; package cd.casic.module.machine.dal.dataobject;
import cd.casic.module.machine.enums.MachineProxyStatus; import cd.casic.module.machine.enums.MachineProxyStatus;
import com.baomidou.mybatisplus.annotation.*; import com.baomidou.mybatisplus.annotation.*;
import cd.casic.module.machine.enums.MachineInfoStatus;
import cd.casic.module.machine.enums.MachineProxyType; import cd.casic.module.machine.enums.MachineProxyType;
import jakarta.validation.Valid;
import lombok.*; import lombok.*;
import java.io.Serializable; import java.io.Serializable;

2
modules/module-ci-machine/src/main/java/cd/casic/module/machine/entity/SecretKey.java → modules/module-ci-machine/src/main/java/cd/casic/module/machine/dal/dataobject/SecretKey.java
View File

@ -1,4 +1,4 @@
package cd.casic.module.machine.entity; package cd.casic.module.machine.dal.dataobject;
import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName;

28
modules/module-ci-machine/src/main/java/cd/casic/module/machine/dal/mysql/MachineEnvMapper.java Normal file
View File

@ -0,0 +1,28 @@
package cd.casic.module.machine.dal.mysql;
import cd.casic.framework.mybatis.core.mapper.BaseMapperX;
import cd.casic.module.machine.controller.vo.MachineEnvVO;
import cd.casic.module.machine.dal.dataobject.MachineEnvDO;
import cd.casic.framework.commons.pojo.PageResult;
import cd.casic.framework.mybatis.core.query.LambdaQueryWrapperX;
import org.apache.ibatis.annotations.Mapper;
import java.time.LocalDateTime;
/**
* 环境变量Mapper接口
*/
@Mapper
public interface MachineEnvMapper extends BaseMapperX<MachineEnvDO> {
default PageResult<MachineEnvDO>selectPage(MachineEnvVO machineEnvVO){
return selectPage(machineEnvVO,new LambdaQueryWrapperX<MachineEnvDO>()
.likeIfPresent(MachineEnvDO::getEnvKey, machineEnvVO.getEnvKey())
.likeIfPresent(MachineEnvDO::getDescription, machineEnvVO.getDescription())
.inIfPresent(MachineEnvDO::getMachineId, machineEnvVO.getMachineId())
.orderByDesc( MachineEnvDO::getMachineId));
}
default void deleteBatchByIds(String ids) {
this.delete(new LambdaQueryWrapperX<MachineEnvDO>()
.in(MachineEnvDO::getId, ids.split(","))
);
}
}

11
modules/module-ci-machine/src/main/java/cd/casic/module/machine/dal/mysql/MachineInfoMapper.java Normal file
View File

@ -0,0 +1,11 @@
package cd.casic.module.machine.dal.mysql;
import cd.casic.framework.mybatis.core.mapper.BaseMapperX;
import cd.casic.module.machine.dal.dataobject.MachineEnvDO;
import cd.casic.module.machine.dal.dataobject.MachineInfo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface MachineInfoMapper extends BaseMapperX<MachineInfo> {
}

4
modules/module-ci-machine/src/main/java/cd/casic/module/machine/mapper/MachineProxyMapper.java → modules/module-ci-machine/src/main/java/cd/casic/module/machine/dal/mysql/MachineProxyMapper.java
View File

@ -1,5 +1,5 @@
package cd.casic.module.machine.mapper; package cd.casic.module.machine.dal.mysql;
import cd.casic.module.machine.entity.MachineProxy; import cd.casic.module.machine.dal.dataobject.MachineProxy;
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Mapper;

4
modules/module-ci-machine/src/main/java/cd/casic/module/machine/mapper/SecretServiceMapper.java → modules/module-ci-machine/src/main/java/cd/casic/module/machine/dal/mysql/SecretServiceMapper.java
View File

@ -1,6 +1,6 @@
package cd.casic.module.machine.mapper; package cd.casic.module.machine.dal.mysql;
import cd.casic.module.machine.entity.SecretKey; import cd.casic.module.machine.dal.dataobject.SecretKey;
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Mapper;

28
modules/module-ci-machine/src/main/java/cd/casic/module/machine/dto/MachineEnvDTO.java
View File

@ -1,28 +0,0 @@
package cd.casic.module.machine.dto;
import lombok.*;
import java.io.Serializable;
import java.util.Date;
/**
* 环境变量数据传输对象
*/
@EqualsAndHashCode(callSuper = true)
@Data
@NoArgsConstructor
@AllArgsConstructor
public class MachineEnvDTO extends PageDto implements Serializable {
private static final long serialVersionUID = 1L;
private Long id;
private String envKey;
private String envValue;
private String description;
private Long machineId;
private Date createDate;
private Date updateDate;
private String sortField;
private String sortDirection;
}

28
modules/module-ci-machine/src/main/java/cd/casic/module/machine/entity/BaseEntity.java
View File

@ -1,28 +0,0 @@
package cd.casic.module.machine.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class BaseEntity {
@TableId
private Long id;
@TableField(value = "create_date")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createDate;
@TableField(value = "update_date")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateDate;
}

55
modules/module-ci-machine/src/main/java/cd/casic/module/machine/exception/ServiceException.java
View File

@ -1,55 +0,0 @@
package cd.casic.module.machine.exception;
import cd.casic.module.machine.entity.SecretKey;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
/**
* 业务逻辑异常 Exception
*/
@EqualsAndHashCode(callSuper = true)
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ServiceException extends RuntimeException {
//机器信息为空
public static final int MACHINE_INFO_NULL = 555;
//上传文件失败
public static final int UPLOADING_FILE_FAIL = 556;
//下载失败
public static final int DOWNLOAD_FILE_FAIL = 557;
//文件名为空
public static final int FILENAME_NULL = 558;
//读取文件失败
public static final int READ_FILE_FAIL = 559;
//删除文件失败
public static final int DELETE_FILE_FAIL = 560;
//MachineProxyDTO对象为空
public static final int MACHINE_PROXY_DTO_NULL = 561;
//MachineProxy代理不存在
public static final int MACHINE_PROXY_NULL = 562;
//参数错误
public static final int PARAMETER_ERROR = 563;
//机器环境变量为空
public static final int MACHINE_ENV_NULL = 564;
//机器环境变量键不合法
public static final int MACHINE_ENV_KEY_ILLEGAL = 565;
//oss参数无法读取
public static final int OSS_PARAM_NULL = 1001;
//密钥为空
public static final int SECRETKEY_NULL = 1002;
/**
* 业务错误码
* 区间
* machine-management-module模块(555-1000)
* common-module模块(1001-2000)
*/
private Integer code;
/**
* 错误提示
*/
private String message;
}

1276
modules/module-ci-machine/src/main/java/cd/casic/module/machine/handler/ConnectionSession.java
View File

File diff suppressed because it is too large Load Diff

14
modules/module-ci-machine/src/main/java/cd/casic/module/machine/mapper/MachineEnvMapper.java
View File

@ -1,14 +0,0 @@
package cd.casic.module.machine.mapper;
import cd.casic.module.machine.entity.MachineEnv;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
* 环境变量Mapper接口
*/
@Mapper
public interface MachineEnvMapper extends BaseMapper<MachineEnv> {
}

9
modules/module-ci-machine/src/main/java/cd/casic/module/machine/mapper/MachineInfoMapper.java
View File

@ -1,9 +0,0 @@
package cd.casic.module.machine.mapper;
import cd.casic.module.machine.entity.MachineInfo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface MachineInfoMapper extends BaseMapper<MachineInfo> {
}

31
modules/module-ci-machine/src/main/java/cd/casic/module/machine/service/MachineEnvService.java
View File

@ -1,26 +1,23 @@
package cd.casic.module.machine.service; package cd.casic.module.machine.service;
import cd.casic.framework.commons.pojo.PageResult;
import cd.casic.module.machine.entity.MachineEnv; import cd.casic.module.machine.controller.vo.MachineEnvVO;
import cd.casic.module.machine.dto.MachineEnvDTO; import cd.casic.module.machine.dal.dataobject.MachineEnvDO;
import cd.casic.module.machine.utils.PageResult; import jakarta.validation.Valid;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/** /**
* 环境变量服务接口 * 环境变量服务接口
*/ */
public interface MachineEnvService extends IService<MachineEnv> { public interface MachineEnvService {
/** /**
* 创建或更新机器的环境变量（一对一关系） * 创建或更新机器的环境变量（一对一关系）
*/ */
boolean add(MachineEnvDTO machineEnvDTO); Long createEnv(@Valid MachineEnvVO machineEnvVO);
/** /**
* 删除机器的环境变量 * 删除机器的环境变量
*/ */
void deleteByMachineId(Long machineEvnId); void deleteEnv(Long machineEvnId);
/** /**
* 获取机器的环境变量 * 获取机器的环境变量
@ -28,14 +25,20 @@ public interface MachineEnvService extends IService<MachineEnv> {
* @param machineId 机器ID * @param machineId 机器ID
* @return 环境变量DTO * @return 环境变量DTO
*/ */
MachineEnvDTO getByMachineId(Long machineId); MachineEnvVO getEnv(Long machineId);
/** /**
* @return 环境变量列表 * @return 环境变量列表
*/ */
PageResult<MachineEnvDTO> listEnv(MachineEnvDTO machineEnvDTO); PageResult<MachineEnvDO> getEnvPage(@Valid MachineEnvVO machineEnvVO);
void deleteList(String ids); /**
* 批量删除
*/
void deleteEnvList(String ids);
boolean update(MachineEnvDTO machineEnvDTO); /*
* 修改环境变量
*/
void updateEnv(@Valid MachineEnvVO machineEnvVO);
} }

9
modules/module-ci-machine/src/main/java/cd/casic/module/machine/service/MachineInfoService.java
View File

@ -1,15 +1,14 @@
package cd.casic.module.machine.service; package cd.casic.module.machine.service;
import cd.casic.module.machine.dto.MachineInfoDto; import cd.casic.framework.commons.pojo.PageResult;
import cd.casic.module.machine.entity.MachineInfo; import cd.casic.module.machine.controller.vo.MachineInfoDto;
import cd.casic.module.machine.dal.dataobject.MachineInfo;
import cd.casic.module.machine.enums.ConnectionStatus; import cd.casic.module.machine.enums.ConnectionStatus;
import cd.casic.module.machine.utils.PageResult;
import com.baomidou.mybatisplus.extension.service.IService; import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
import java.util.Map; import java.util.Map;
public interface MachineInfoService extends IService<MachineInfo> { public interface MachineInfoService {
boolean addMachineInfo(MachineInfoDto MachineInfoDto); boolean addMachineInfo(MachineInfoDto MachineInfoDto);
PageResult<MachineInfoDto> listMachineInfo(MachineInfoDto MachineInfoDto); PageResult<MachineInfoDto> listMachineInfo(MachineInfoDto MachineInfoDto);

15
modules/module-ci-machine/src/main/java/cd/casic/module/machine/service/MachineProxyService.java
View File

@ -1,11 +1,10 @@
package cd.casic.module.machine.service; package cd.casic.module.machine.service;
import cd.casic.module.machine.dto.MachineProxyDTO; import cd.casic.framework.commons.pojo.PageResult;
import cd.casic.module.machine.entity.MachineProxy; import cd.casic.module.machine.controller.vo.MachineProxyVO;
import cd.casic.module.machine.utils.PageResult; import cd.casic.module.machine.dal.dataobject.MachineProxy;
import com.baomidou.mybatisplus.extension.service.IService; import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
import java.util.Map; import java.util.Map;
/** /**
@ -15,12 +14,12 @@ public interface MachineProxyService extends IService<MachineProxy> {
/** /**
* 注册新的机器代理 * 注册新的机器代理
*/ */
boolean register(MachineProxyDTO machineProxyDTO); boolean register(MachineProxyVO machineProxyVO);
/** /**
* 更新代理状态 * 更新代理状态
*/ */
boolean updateStatus(MachineProxyDTO machineProxyDTO); boolean updateStatus(MachineProxyVO machineProxyVO);
/** /**
@ -33,7 +32,7 @@ public interface MachineProxyService extends IService<MachineProxy> {
/** /**
* 更新代理配置 * 更新代理配置
*/ */
void update(MachineProxyDTO machineProxyDTO); void update(MachineProxyVO machineProxyVO);
/** /**
@ -43,5 +42,5 @@ public interface MachineProxyService extends IService<MachineProxy> {
*/ */
void delete(String proxyIds); void delete(String proxyIds);
PageResult<MachineProxyDTO> list(MachineProxyDTO machineProxyDTO); PageResult<MachineProxyVO> list(MachineProxyVO machineProxyVO);
} }

9
modules/module-ci-machine/src/main/java/cd/casic/module/machine/service/SecretKeyService.java
View File

@ -1,12 +1,9 @@
package cd.casic.module.machine.service; package cd.casic.module.machine.service;
import cd.casic.module.machine.entity.SecretKey; import cd.casic.framework.commons.pojo.PageResult;
import cd.casic.module.machine.dto.SecretKeyDto; import cd.casic.module.machine.dal.dataobject.SecretKey;
import cd.casic.module.machine.utils.PageResult; import cd.casic.module.machine.controller.vo.SecretKeyDto;
import com.baomidou.mybatisplus.extension.service.IService; import com.baomidou.mybatisplus.extension.service.IService;
import org.springframework.core.io.InputStreamResource;
import org.springframework.http.ResponseEntity;
import org.springframework.web.multipart.MultipartFile;
import java.util.List; import java.util.List;

183
modules/module-ci-machine/src/main/java/cd/casic/module/machine/service/impl/MachineEnvServiceImpl.java
View File

@ -1,174 +1,97 @@
package cd.casic.module.machine.service.impl; package cd.casic.module.machine.service.impl;
import cd.casic.module.machine.convert.MachineEnvConvert;
import cd.casic.module.machine.dto.MachineEnvDTO; import cd.casic.module.machine.controller.vo.MachineEnvVO;
import cd.casic.module.machine.entity.MachineEnv; import cd.casic.module.machine.dal.dataobject.MachineEnvDO;
import cd.casic.module.machine.exception.ServiceException; import cd.casic.module.machine.dal.mysql.MachineEnvMapper;
import cd.casic.module.machine.mapper.MachineEnvMapper;
import cd.casic.module.machine.service.MachineEnvService; import cd.casic.module.machine.service.MachineEnvService;
import cd.casic.module.machine.utils.PageResult; import cd.casic.framework.commons.pojo.PageResult;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.google.common.annotations.VisibleForTesting;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import jakarta.annotation.Resource; import jakarta.annotation.Resource;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils; import cd.casic.framework.commons.util.object.BeanUtils;
import static cd.casic.framework.commons.exception.util.ServiceExceptionUtil.exception;
import java.util.Arrays; import static cd.casic.module.machine.contants.MachineErrorCodeConstants.*;
import java.util.List;
import java.util.stream.Collectors;
/** /**
* 环境变量服务实现类 * 环境变量服务实现类
*/ */
@Service @Service("machineEnvService")
public class MachineEnvServiceImpl extends ServiceImpl<MachineEnvMapper, MachineEnv> implements MachineEnvService { public class MachineEnvServiceImpl implements MachineEnvService {
@Resource @Resource
private MachineEnvMapper machineEnvMapper; private MachineEnvMapper machineEnvMapper;
@Override @Override
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public boolean add(MachineEnvDTO machineEnvDTO) { public Long createEnv(MachineEnvVO machineEnvVO) {
// 参数校验 validateMachineEnvAdd(machineEnvVO);
if (machineEnvDTO == null) {
throw new ServiceException(ServiceException.MACHINE_ENV_NULL, "环境变量不能为空");
}
// 检查键是否合法 // 检查键是否合法
if (!isValidKey(machineEnvDTO.getEnvKey())) { validateKey(machineEnvVO.getEnvKey());
throw new ServiceException(ServiceException.MACHINE_ENV_KEY_ILLEGAL, "环境变量键不合法"); MachineEnvDO machineEnvDO = BeanUtils.toBean(machineEnvVO, MachineEnvDO.class);
} machineEnvMapper.insert(machineEnvDO);
return machineEnvDO.getId();
// 判断是否敏感变量
boolean isSensitive = isSensitive(machineEnvDTO.getEnvKey());
MachineEnv machineEnv = new MachineEnv();
BeanUtils.copyProperties(machineEnvDTO, machineEnv);
return save(machineEnv);
} }
@Override @Override
public void deleteByMachineId(Long machineEvnId) { public void deleteEnv(Long machineEvnId) {
this.removeById(machineEvnId); machineEnvMapper.deleteById(machineEvnId);
} }
@Override @Override
public MachineEnvDTO getByMachineId(Long machineId) { public MachineEnvVO getEnv(Long machineId) {
if (machineId == null) { if (machineId == null) {
return null; return null;
} }
MachineEnvDO machineEnvDO = machineEnvMapper.selectById(machineId);
MachineEnv machineEnv = getOne( return machineEnvDO != null ? MachineEnvConvert.INSTANCE.convertToVO(machineEnvDO) : null;
new LambdaQueryWrapper<MachineEnv>()
.eq(MachineEnv::getMachineId, machineId)
);
return machineEnv != null ? convertToDTO(machineEnv) : null;
} }
@Override @Override
public PageResult<MachineEnvDTO> listEnv(MachineEnvDTO machineEnvDTO) { public PageResult<MachineEnvDO> getEnvPage(MachineEnvVO machineEnvVO) {
return machineEnvMapper.selectPage(machineEnvVO);
// 构建查询条件
LambdaQueryWrapper<MachineEnv> queryWrapper = new LambdaQueryWrapper<>();
// 环境变量键模糊查询
if (!StringUtils.isEmpty(machineEnvDTO.getEnvKey())) {
queryWrapper.like(MachineEnv::getEnvKey, machineEnvDTO.getEnvKey());
}
// 机器ID模糊查询
if (!StringUtils.isEmpty(machineEnvDTO.getMachineId())) {
queryWrapper.like(MachineEnv::getMachineId, machineEnvDTO.getMachineId());
}
// 创建时间范围查询
if (!StringUtils.isEmpty(machineEnvDTO.getCreateDate())) {
queryWrapper.ge(MachineEnv::getCreateDate, machineEnvDTO.getCreateDate());
}
// 排序
if (!StringUtils.isEmpty(machineEnvDTO.getSortField())) {
boolean isAsc = "asc".equalsIgnoreCase(machineEnvDTO.getSortDirection());
switch (machineEnvDTO.getSortField()) {
case "envKey":
queryWrapper.orderBy(true, isAsc, MachineEnv::getEnvKey);
break;
case "machineId":
queryWrapper.orderBy(true, isAsc, MachineEnv::getMachineId);
break;
case "createTime":
default:
queryWrapper.orderBy(true, isAsc, MachineEnv::getCreateDate);
break;
}
}
// 分页查询
Page<MachineEnv> page = machineEnvMapper.selectPage(new Page<>(machineEnvDTO.getPageIndex(), machineEnvDTO.getPageSize()), queryWrapper);
// 转换结果
List<MachineEnvDTO> dtoList = page.getRecords().stream()
.map(this::convertToDTO)
.collect(Collectors.toList());
// 构建分页结果
return PageResult.<MachineEnvDTO>builder()
.pageNum(page.getCurrent())
.pageSize(page.getSize())
.total(page.getTotal())
.pages(page.getPages())
.list(dtoList)
.build();
} }
@Override @Override
public void deleteList(String ids) { public void deleteEnvList(String ids) {
List<Long> machineEnvIds = Arrays.stream(ids.split(",")) machineEnvMapper.deleteBatchByIds(ids);
.map(String::trim)
.filter(s -> !s.isEmpty())
.map(Long::parseLong)
.toList();
this.machineEnvMapper.deleteBatchIds(machineEnvIds);
} }
@Override @Override
public boolean update(MachineEnvDTO machineEnvDTO) { public void updateEnv(MachineEnvVO machineEnvVO) {
MachineEnv machineEnv = new MachineEnv(); MachineEnvDO machineEnvDO = validateMachineEnvExists(machineEnvVO.getId());
BeanUtils.copyProperties(machineEnvDTO, machineEnv); BeanUtils.copyProperties(machineEnvVO, machineEnvDO);
return this.updateById(machineEnv); machineEnvMapper.updateById(machineEnvDO);
} }
// 转换实体为DTO @VisibleForTesting
private MachineEnvDTO convertToDTO(MachineEnv machineEnv) { MachineEnvDO validateMachineEnvExists(Long id) {
MachineEnvDTO dto = new MachineEnvDTO(); if (id == null) {
dto.setId(machineEnv.getId()); return null;
dto.setEnvKey(machineEnv.getEnvKey());
dto.setEnvValue(machineEnv.getEnvValue());
dto.setDescription(machineEnv.getDescription());
dto.setCreateDate(machineEnv.getCreateDate());
dto.setUpdateDate(machineEnv.getUpdateDate());
return dto;
} }
MachineEnvDO machineEnvDO = machineEnvMapper.selectById(id);
if (machineEnvDO == null) {
throw exception(MACHINE_ENV_NOT_EXISTS);
}
return machineEnvDO;
}
@VisibleForTesting
void validateMachineEnvAdd(MachineEnvVO machineEnvVO) {
if (machineEnvVO.getEnvKey()==null||machineEnvVO.getEnvValue()==null) {
throw exception(MACHINE_ENV_NULL);
}
}
// 检查环境变量键是否合法 // 检查环境变量键是否合法
private boolean isValidKey(String key) { @VisibleForTesting
return key.matches("^[a-zA-Z_][a-zA-Z0-9_]*$"); private void validateKey(String key) {
if (!key.matches("^[a-zA-Z_][a-zA-Z0-9_]*$")) {
throw exception(MACHINE_ENV_KEY_ILLEGAL);
}
} }
// 判断是否为敏感变量
private boolean isSensitive(String key) {
if (key == null) {
return false;
}
String upperKey = key.toUpperCase();
return upperKey.contains("PASSWORD") || upperKey.contains("SECRET") ||
upperKey.contains("TOKEN") || upperKey.contains("KEY");
}
} }

323
modules/module-ci-machine/src/main/java/cd/casic/module/machine/service/impl/MachineProxyServiceImpl.java
View File

@ -1,162 +1,161 @@
package cd.casic.module.machine.service.impl; //package cd.casic.module.machine.service.impl;
//
import cd.casic.module.machine.dto.MachineProxyDTO; //import cd.casic.module.machine.controller.vo.MachineProxyDTO;
import cd.casic.module.machine.entity.MachineProxy; //import cd.casic.module.machine.dal.dataobject.MachineProxy;
import cd.casic.module.machine.enums.MachineProxyStatus; //import cd.casic.module.machine.enums.MachineProxyStatus;
import cd.casic.module.machine.enums.MachineProxyType; //import cd.casic.module.machine.enums.MachineProxyType;
import cd.casic.module.machine.exception.ServiceException; //import cd.casic.module.machine.exception.ServiceException;
import cd.casic.module.machine.mapper.MachineProxyMapper; //import cd.casic.module.machine.dal.mysql.MachineProxyMapper;
import cd.casic.module.machine.service.MachineProxyService; //import cd.casic.module.machine.service.MachineProxyService;
import cd.casic.module.machine.utils.EnumUtils; //import cd.casic.module.machine.utils.EnumUtils;
import cd.casic.module.machine.utils.PageResult; //import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; //import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; //import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; //import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; //
//import jakarta.annotation.Resource;
import jakarta.annotation.Resource; //import org.springframework.beans.BeanUtils;
import org.springframework.beans.BeanUtils; //import org.springframework.stereotype.Service;
import org.springframework.stereotype.Service; //import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.annotation.Transactional; //import org.springframework.util.CollectionUtils;
import org.springframework.util.CollectionUtils; //
//import java.util.*;
import java.util.*; //import java.util.function.Function;
import java.util.function.Function; //import java.util.stream.Collectors;
import java.util.stream.Collectors; //
///**
/** // * 机器代理服务实现类
* 机器代理服务实现类 // */
*/ //@Service
@Service //public class MachineProxyServiceImpl extends ServiceImpl<MachineProxyMapper, MachineProxy> implements MachineProxyService {
public class MachineProxyServiceImpl extends ServiceImpl<MachineProxyMapper, MachineProxy> implements MachineProxyService { // @Resource
@Resource // private MachineProxyMapper machineProxyMapper;
private MachineProxyMapper machineProxyMapper; //
// @Override
@Override // @Transactional(rollbackFor = Exception.class)
@Transactional(rollbackFor = Exception.class) // public boolean register(MachineProxyDTO machineProxyDTO) {
public boolean register(MachineProxyDTO machineProxyDTO) { // // 创建代理记录
// 创建代理记录 // MachineProxy proxy = new MachineProxy();
MachineProxy proxy = new MachineProxy(); // BeanUtils.copyProperties(machineProxyDTO, proxy);
BeanUtils.copyProperties(machineProxyDTO, proxy); // proxy.setProxyTypeCode(EnumUtils.getEnumByMessage(machineProxyDTO.getProxyType(), MachineProxyType.class).getCode());
proxy.setProxyTypeCode(EnumUtils.getEnumByMessage(machineProxyDTO.getProxyType(), MachineProxyType.class).getCode()); // proxy.setVersion("1.0.0");
proxy.setVersion("1.0.0"); // proxy.setStatusCode(MachineProxyStatus.ONLINE.getCode());
proxy.setStatusCode(MachineProxyStatus.ONLINE.getCode()); // return save(proxy);
return save(proxy); // }
} //
// @Override
@Override // public boolean updateStatus(MachineProxyDTO machineProxyDTO) {
public boolean updateStatus(MachineProxyDTO machineProxyDTO) { // // 参数校验
// 参数校验 // if (machineProxyDTO == null) {
if (machineProxyDTO == null) { // throw new ServiceException(ServiceException.MACHINE_PROXY_DTO_NULL, "MachineProxyDTO对象为空");
throw new ServiceException(ServiceException.MACHINE_PROXY_DTO_NULL, "MachineProxyDTO对象为空"); // }
} //
// // 查询代理
// 查询代理 // MachineProxy proxy = this.getById(machineProxyDTO.getId());
MachineProxy proxy = this.getById(machineProxyDTO.getId()); //
// if (proxy == null) {
if (proxy == null) { // throw new ServiceException(ServiceException.MACHINE_PROXY_NULL, "代理不存在");
throw new ServiceException(ServiceException.MACHINE_PROXY_NULL, "代理不存在"); // }
} //
// // 更新状态
// 更新状态 // proxy.setStatusCode(EnumUtils.getEnumByMessage(machineProxyDTO.getStatus(), MachineProxyStatus.class).getCode());
proxy.setStatusCode(EnumUtils.getEnumByMessage(machineProxyDTO.getStatus(), MachineProxyStatus.class).getCode()); // proxy.setUpdateTime(new Date());
proxy.setUpdateDate(new Date()); // return updateById(proxy);
return updateById(proxy); // }
} //
//
// @Override
@Override // public Map<String, Long> getStatusStatistics() {
public Map<String, Long> getStatusStatistics() { // List<MachineProxy> proxyList = list();
List<MachineProxy> proxyList = list(); //
// if (CollectionUtils.isEmpty(proxyList)) {
if (CollectionUtils.isEmpty(proxyList)) { // return Collections.emptyMap();
return Collections.emptyMap(); // }
} // return proxyList.stream()
return proxyList.stream() // .map(proxy -> EnumUtils.getEnumByCode(proxy.getStatusCode(), MachineProxyStatus.class).getMessage())
.map(proxy -> EnumUtils.getEnumByCode(proxy.getStatusCode(), MachineProxyStatus.class).getMessage()) // .collect(Collectors.groupingBy(
.collect(Collectors.groupingBy( // Function.identity(),
Function.identity(), // Collectors.counting() // 统计每个分组的元素数量
Collectors.counting() // 统计每个分组的元素数量 // ));
)); // }
} //
// @Override
@Override // public void update(MachineProxyDTO machineProxyDTO) {
public void update(MachineProxyDTO machineProxyDTO) { // // 参数校验
// 参数校验 // if (machineProxyDTO == null) {
if (machineProxyDTO == null) { // throw new ServiceException(ServiceException.MACHINE_PROXY_DTO_NULL, "MachineProxyDTO对象为空");
throw new ServiceException(ServiceException.MACHINE_PROXY_DTO_NULL, "MachineProxyDTO对象为空"); // }
} // MachineProxy machineProxy = new MachineProxy();
MachineProxy machineProxy = new MachineProxy(); // BeanUtils.copyProperties(machineProxyDTO, machineProxy);
BeanUtils.copyProperties(machineProxyDTO, machineProxy); // if (machineProxyDTO.getProxyType() != null && !machineProxyDTO.getProxyType().isEmpty()) {
if (machineProxyDTO.getProxyType() != null && !machineProxyDTO.getProxyType().isEmpty()) { // machineProxy.setProxyTypeCode(EnumUtils.getEnumByMessage(machineProxyDTO.getProxyType(), MachineProxyType.class).getCode());
machineProxy.setProxyTypeCode(EnumUtils.getEnumByMessage(machineProxyDTO.getProxyType(), MachineProxyType.class).getCode()); // }
} // if (machineProxyDTO.getStatus() != null && !machineProxyDTO.getStatus().isEmpty()) {
if (machineProxyDTO.getStatus() != null && !machineProxyDTO.getStatus().isEmpty()) { // machineProxy.setStatusCode(EnumUtils.getEnumByMessage(machineProxyDTO.getStatus(), MachineProxyStatus.class).getCode());
machineProxy.setStatusCode(EnumUtils.getEnumByMessage(machineProxyDTO.getStatus(), MachineProxyStatus.class).getCode()); // }
} // this.updateById(machineProxy);
this.updateById(machineProxy); // }
} //
//
// @Override
@Override // @Transactional(rollbackFor = Exception.class)
@Transactional(rollbackFor = Exception.class) // public void delete(String ids) {
public void delete(String ids) { // List<Long> machineProxyIds = Arrays.stream(ids.split(","))
List<Long> machineProxyIds = Arrays.stream(ids.split(",")) // .map(String::trim)
.map(String::trim) // .filter(s -> !s.isEmpty())
.filter(s -> !s.isEmpty()) // .map(Long::parseLong)
.map(Long::parseLong) // .toList();
.toList(); // // 参数校验
// 参数校验 // if (CollectionUtils.isEmpty(machineProxyIds)) {
if (CollectionUtils.isEmpty(machineProxyIds)) { // throw new ServiceException(ServiceException.PARAMETER_ERROR, "参数错误");
throw new ServiceException(ServiceException.PARAMETER_ERROR, "参数错误"); // }
} // // 批量逻辑删除
// 批量逻辑删除 // remove(new LambdaQueryWrapper<MachineProxy>()
remove(new LambdaQueryWrapper<MachineProxy>() // .in(MachineProxy::getId, machineProxyIds)
.in(MachineProxy::getId, machineProxyIds) // .ne(MachineProxy::getStatus, MachineProxyStatus.ONLINE.getCode()));
.ne(MachineProxy::getStatus, MachineProxyStatus.ONLINE.getCode())); // }
} //
// @Override
@Override // public PageResult<MachineProxyDTO> list(MachineProxyDTO machineProxyDTO) {
public PageResult<MachineProxyDTO> list(MachineProxyDTO machineProxyDTO) { // QueryWrapper<MachineProxy> queryWrapper = getMachineProxyQueryWrapper(machineProxyDTO);
QueryWrapper<MachineProxy> queryWrapper = getMachineProxyQueryWrapper(machineProxyDTO); // Page<MachineProxy> page = machineProxyMapper.selectPage(new Page<>(machineProxyDTO.getPageIndex(), machineProxyDTO.getPageSize()), queryWrapper);
Page<MachineProxy> page = machineProxyMapper.selectPage(new Page<>(machineProxyDTO.getPageIndex(), machineProxyDTO.getPageSize()), queryWrapper); // List<MachineProxyDTO> machineProxyDtos = page.getRecords().stream().map(machineProxy -> {
List<MachineProxyDTO> machineProxyDtos = page.getRecords().stream().map(machineProxy -> { // MachineProxyDTO dto = new MachineProxyDTO();
MachineProxyDTO dto = new MachineProxyDTO(); // BeanUtils.copyProperties(machineProxy, dto);
BeanUtils.copyProperties(machineProxy, dto); // dto.setProxyType(EnumUtils.getEnumByCode(machineProxy.getProxyTypeCode(), MachineProxyType.class).getMessage());
dto.setProxyType(EnumUtils.getEnumByCode(machineProxy.getProxyTypeCode(), MachineProxyType.class).getMessage()); // dto.setStatus(EnumUtils.getEnumByCode(machineProxy.getStatusCode(), MachineProxyStatus.class).getMessage());
dto.setStatus(EnumUtils.getEnumByCode(machineProxy.getStatusCode(), MachineProxyStatus.class).getMessage()); // return dto;
return dto; // }).toList();
}).toList(); // return new PageResult<>(
return new PageResult<>( // page.getCurrent(),
page.getCurrent(), // page.getSize(),
page.getSize(), // page.getTotal(),
page.getTotal(), // page.getPages(),
page.getPages(), // machineProxyDtos
machineProxyDtos // );
); // }
} //
// private QueryWrapper<MachineProxy> getMachineProxyQueryWrapper(MachineProxyDTO machineProxyDTO) {
private QueryWrapper<MachineProxy> getMachineProxyQueryWrapper(MachineProxyDTO machineProxyDTO) { // QueryWrapper<MachineProxy> queryWrapper = new QueryWrapper<>();
QueryWrapper<MachineProxy> queryWrapper = new QueryWrapper<>(); // if (machineProxyDTO.getHostIp() != null && !machineProxyDTO.getHostIp().isEmpty()) {
if (machineProxyDTO.getHostIp() != null && !machineProxyDTO.getHostIp().isEmpty()) { // queryWrapper.like("host_ip", machineProxyDTO.getHostIp());
queryWrapper.like("host_ip", machineProxyDTO.getHostIp()); // }
} // if (machineProxyDTO.getSshPort() != null && !machineProxyDTO.getSshPort().isEmpty()) {
if (machineProxyDTO.getSshPort() != null && !machineProxyDTO.getSshPort().isEmpty()) { // queryWrapper.like("ssh_port", machineProxyDTO.getSshPort());
queryWrapper.like("ssh_port", machineProxyDTO.getSshPort()); // }
} // if (machineProxyDTO.getUsername() != null && !machineProxyDTO.getUsername().isEmpty()) {
if (machineProxyDTO.getUsername() != null && !machineProxyDTO.getUsername().isEmpty()) { // queryWrapper.like("username", machineProxyDTO.getUsername());
queryWrapper.like("username", machineProxyDTO.getUsername()); // }
} // if (machineProxyDTO.getDescription() != null && !machineProxyDTO.getDescription().isEmpty()) {
if (machineProxyDTO.getDescription() != null && !machineProxyDTO.getDescription().isEmpty()) { // queryWrapper.like("description", machineProxyDTO.getDescription());
queryWrapper.like("description", machineProxyDTO.getDescription()); // }
} // if (machineProxyDTO.getStatus() != null && !machineProxyDTO.getStatus().isEmpty()) {
if (machineProxyDTO.getStatus() != null && !machineProxyDTO.getStatus().isEmpty()) { // queryWrapper.like("status_code", EnumUtils.getEnumByMessage(machineProxyDTO.getStatus(), MachineProxyStatus.class).getCode());
queryWrapper.like("status_code", EnumUtils.getEnumByMessage(machineProxyDTO.getStatus(), MachineProxyStatus.class).getCode()); // }
} // if (machineProxyDTO.getProxyType() != null && !machineProxyDTO.getProxyType().isEmpty()) {
if (machineProxyDTO.getProxyType() != null && !machineProxyDTO.getProxyType().isEmpty()) { // queryWrapper.like("proxy_type_code", EnumUtils.getEnumByMessage(machineProxyDTO.getProxyType(), MachineProxyType.class).getCode());
queryWrapper.like("proxy_type_code", EnumUtils.getEnumByMessage(machineProxyDTO.getProxyType(), MachineProxyType.class).getCode()); // }
} // return queryWrapper.orderByDesc("create_date");
return queryWrapper.orderByDesc("create_date"); // }
} //
//}
}

717
modules/module-ci-machine/src/main/java/cd/casic/module/machine/service/impl/MachineinfoServiceImpl.java
View File

@ -1,363 +1,354 @@
package cd.casic.module.machine.service.impl; //package cd.casic.module.machine.service.impl;
//import cd.casic.module.machine.enums.MachineInfoType;
import cd.casic.module.machine.enums.MachineInfoType; //import cd.casic.module.machine.handler.ConnectionSession;
import cd.casic.module.machine.handler.ConnectionSession; //import cd.casic.module.machine.dal.mysql.MachineInfoMapper;
import cd.casic.module.machine.mapper.MachineInfoMapper; //import cd.casic.module.machine.controller.vo.MachineInfoDto;
import cd.casic.module.machine.dto.MachineInfoDto; //import cd.casic.module.machine.dal.dataobject.MachineInfo;
import cd.casic.module.machine.entity.MachineInfo; //import cd.casic.module.machine.enums.AuthenticationType;
import cd.casic.module.machine.enums.AuthenticationType; //import cd.casic.module.machine.enums.ConnectionStatus;
import cd.casic.module.machine.enums.ConnectionStatus; //import cd.casic.module.machine.enums.MachineInfoStatus;
import cd.casic.module.machine.enums.MachineInfoStatus; //import cd.casic.module.machine.service.MachineInfoService;
import cd.casic.module.machine.exception.ServiceException; //import cd.casic.module.machine.utils.EnumUtils;
import cd.casic.module.machine.service.MachineInfoService; //import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import cd.casic.module.machine.utils.EnumUtils; //import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import cd.casic.module.machine.utils.PageResult; //import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; //import jakarta.annotation.Resource;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper; //import lombok.extern.slf4j.Slf4j;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; //import org.springframework.beans.BeanUtils;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; //import org.springframework.stereotype.Service;
//import java.util.Arrays;
import com.fasterxml.jackson.core.JsonProcessingException; //import java.util.HashMap;
import com.fasterxml.jackson.core.type.TypeReference; //import java.util.List;
import com.fasterxml.jackson.databind.ObjectMapper; //import java.util.Map;
import jakarta.annotation.Resource; //import java.util.concurrent.ConcurrentHashMap;
import lombok.extern.slf4j.Slf4j; //import java.util.concurrent.atomic.AtomicInteger;
import org.springframework.beans.BeanUtils; //import java.util.stream.Collectors;
import org.springframework.stereotype.Service; //
//@Slf4j
import java.util.Arrays; //@Service("machineInfoService")
import java.util.HashMap; //public class MachineinfoServiceImpl implements MachineInfoService {
import java.util.List; //
import java.util.Map; // int ENABLE = 1;
import java.util.concurrent.ConcurrentHashMap; // int UN_ENABLE = 0;
import java.util.concurrent.atomic.AtomicInteger; //
import java.util.stream.Collectors; // @Resource
// private MachineInfoMapper machineInfoMapper;
@Slf4j // @Resource
@Service // private ConnectionSession connectionSession;
public class MachineinfoServiceImpl extends ServiceImpl<MachineInfoMapper, MachineInfo> implements MachineInfoService { // /**
// * 会话ID生成器
int ENABLE = 1; // */
int UN_ENABLE = 0; // private final AtomicInteger sessionIdGenerator = new AtomicInteger(1000);
//
@Resource // /**
private MachineInfoMapper machineInfoMapper; // * 会话管理：会话ID -> 连接会话
@Resource // */
private ConnectionSession connectionSession; // private final Map<String, ConnectionSession> sessions = new ConcurrentHashMap<>();
/** //
* 会话ID生成器 // /**
*/ // * 机器名称 -> 会话ID
private final AtomicInteger sessionIdGenerator = new AtomicInteger(1000); // */
// private final Map<String, String> machineSessionMapping = new ConcurrentHashMap<>();
/** //
* 会话管理：会话ID -> 连接会话 // @Override
*/ // public boolean addMachineInfo(MachineInfoDto machineInfoDto) {
private final Map<String, ConnectionSession> sessions = new ConcurrentHashMap<>(); // if (machineInfoDto == null) {
// throw new ServiceException(ServiceException.MACHINE_INFO_NULL, "机器信息为空");
/** // }
* 机器名称 -> 会话ID // MachineInfo machineInfo = new MachineInfo();
*/ // BeanUtils.copyProperties(machineInfoDto, machineInfo);
private final Map<String, String> machineSessionMapping = new ConcurrentHashMap<>(); // machineInfo.setStatusCode(1);
// machineInfo.setAuthenticationTypeCode(
@Override // "密码认证".equals(machineInfoDto.getAuthenticationType())
public boolean addMachineInfo(MachineInfoDto machineInfoDto) { // ? AuthenticationType.PASSWORD.getCode()
if (machineInfoDto == null) { // : AuthenticationType.SECRET_KEY.getCode()
throw new ServiceException(ServiceException.MACHINE_INFO_NULL, "机器信息为空"); // );
} // machineInfo.setMachineInfoTypeCode(
MachineInfo machineInfo = new MachineInfo(); // "Windows".equals(machineInfoDto.getMachineInfoType())
BeanUtils.copyProperties(machineInfoDto, machineInfo); // ? MachineInfoType.WINDOWS.getCode()
machineInfo.setStatusCode(1); // : MachineInfoType.Linux.getCode()
machineInfo.setAuthenticationTypeCode( // );
"密码认证".equals(machineInfoDto.getAuthenticationType()) //
? AuthenticationType.PASSWORD.getCode() // return this.save(machineInfo);
: AuthenticationType.SECRET_KEY.getCode() // }
); //
machineInfo.setMachineInfoTypeCode( // @Override
"Windows".equals(machineInfoDto.getMachineInfoType()) // public PageResult<MachineInfoDto> listMachineInfo(MachineInfoDto machineInfoDto) {
? MachineInfoType.WINDOWS.getCode() // QueryWrapper<MachineInfo> queryWrapper = getMachineInfoQueryWrapper(machineInfoDto);
: MachineInfoType.Linux.getCode() // Page<MachineInfo> page = machineInfoMapper.selectPage(
); // new Page<>(machineInfoDto.getPageIndex(), machineInfoDto.getPageSize()),
// queryWrapper
return this.save(machineInfo); // );
} //
// List<MachineInfoDto> machineInfoDtos = page.getRecords().stream()
@Override // .map(machineInfo -> {
public PageResult<MachineInfoDto> listMachineInfo(MachineInfoDto machineInfoDto) { // MachineInfoDto dto = new MachineInfoDto();
QueryWrapper<MachineInfo> queryWrapper = getMachineInfoQueryWrapper(machineInfoDto); // BeanUtils.copyProperties(machineInfo, dto);
Page<MachineInfo> page = machineInfoMapper.selectPage( // // 直接调用原有枚举转换方法
new Page<>(machineInfoDto.getPageIndex(), machineInfoDto.getPageSize()), // dto.setMachineInfoType(EnumUtils.getEnumByCode(machineInfo.getMachineInfoTypeCode(), MachineInfoType.class).getMessage());
queryWrapper // dto.setStatus(EnumUtils.getEnumByCode(machineInfo.getStatusCode(), MachineInfoStatus.class).getMessage());
); // dto.setAuthenticationType(EnumUtils.getEnumByCode(machineInfo.getAuthenticationTypeCode(), AuthenticationType.class).getMessage());
// return dto;
List<MachineInfoDto> machineInfoDtos = page.getRecords().stream() // })
.map(machineInfo -> { // .toList();
MachineInfoDto dto = new MachineInfoDto(); //
BeanUtils.copyProperties(machineInfo, dto); // return new PageResult<>(
// 直接调用原有枚举转换方法 // page.getCurrent(),
dto.setMachineInfoType(EnumUtils.getEnumByCode(machineInfo.getMachineInfoTypeCode(), MachineInfoType.class).getMessage()); // page.getSize(),
dto.setStatus(EnumUtils.getEnumByCode(machineInfo.getStatusCode(), MachineInfoStatus.class).getMessage()); // page.getTotal(),
dto.setAuthenticationType(EnumUtils.getEnumByCode(machineInfo.getAuthenticationTypeCode(), AuthenticationType.class).getMessage()); // page.getPages(),
return dto; // machineInfoDtos
}) // );
.toList(); // }
//
return new PageResult<>( // @Override
page.getCurrent(), // public boolean updateMachineInfo(MachineInfoDto machineInfoDto) {
page.getSize(), // MachineInfo machineInfo = new MachineInfo();
page.getTotal(), // BeanUtils.copyProperties(machineInfoDto, machineInfo);
page.getPages(), // machineInfo.setAuthenticationTypeCode(
machineInfoDtos // "密码认证".equals(machineInfoDto.getAuthenticationType())
); // ? AuthenticationType.PASSWORD.getCode()
} // : AuthenticationType.SECRET_KEY.getCode()
// );
@Override // machineInfo.setMachineInfoTypeCode(
public boolean updateMachineInfo(MachineInfoDto machineInfoDto) { // "Windows".equals(machineInfoDto.getMachineInfoType())
MachineInfo machineInfo = new MachineInfo(); // ? MachineInfoType.WINDOWS.getCode()
BeanUtils.copyProperties(machineInfoDto, machineInfo); // : MachineInfoType.Linux.getCode()
machineInfo.setAuthenticationTypeCode( // );
"密码认证".equals(machineInfoDto.getAuthenticationType()) // return this.updateById(machineInfo);
? AuthenticationType.PASSWORD.getCode() // }
: AuthenticationType.SECRET_KEY.getCode() //
); // @Override
machineInfo.setMachineInfoTypeCode( // public boolean updateStatus(MachineInfoDto machineInfoDto) {
"Windows".equals(machineInfoDto.getMachineInfoType()) // UpdateWrapper<MachineInfo> updateWrapper = new UpdateWrapper<>();
? MachineInfoType.WINDOWS.getCode() // updateWrapper.eq("id", machineInfoDto.getId()).set("status_code", EnumUtils.getEnumByMessage(machineInfoDto.getStatus(), MachineInfoStatus.class).getCode());
: MachineInfoType.Linux.getCode() // return this.update(updateWrapper);
); // }
return this.updateById(machineInfo); //
} // @Override
// public boolean bindingSecretKey(MachineInfoDto machineInfoDto) {
@Override // UpdateWrapper<MachineInfo> updateWrapper = new UpdateWrapper<>();
public boolean updateStatus(MachineInfoDto machineInfoDto) { // updateWrapper.eq("id", machineInfoDto.getId()).set("secret_key_id", machineInfoDto.getSecretKeyId()).set("authentication_type_code", 2);
UpdateWrapper<MachineInfo> updateWrapper = new UpdateWrapper<>(); // return this.update(updateWrapper);
updateWrapper.eq("id", machineInfoDto.getId()).set("status_code", EnumUtils.getEnumByMessage(machineInfoDto.getStatus(), MachineInfoStatus.class).getCode()); // }
return this.update(updateWrapper); //
} // @Override
// public void deleteList(String machineInfoIds) {
@Override // List<Long> machineInfoIdList = Arrays.stream(machineInfoIds.split(","))
public boolean bindingSecretKey(MachineInfoDto machineInfoDto) { // .map(String::trim)
UpdateWrapper<MachineInfo> updateWrapper = new UpdateWrapper<>(); // .filter(s -> !s.isEmpty())
updateWrapper.eq("id", machineInfoDto.getId()).set("secret_key_id", machineInfoDto.getSecretKeyId()).set("authentication_type_code", 2); // .map(Long::parseLong)
return this.update(updateWrapper); // .collect(Collectors.toList());
} // machineInfoMapper.selectBatchIds(machineInfoIdList).forEach(machineInfo -> {
// if (machineInfo.getStatusCode() == 1) {
@Override // this.removeById(machineInfo.getId());
public void deleteList(String machineInfoIds) { // }
List<Long> machineInfoIdList = Arrays.stream(machineInfoIds.split(",")) // });
.map(String::trim) // }
.filter(s -> !s.isEmpty()) //
.map(Long::parseLong) // @Override
.collect(Collectors.toList()); // public void deleteMachineInfo(Long machineInfoId) {
machineInfoMapper.selectBatchIds(machineInfoIdList).forEach(machineInfo -> { // MachineInfo machineInfo = this.getById(machineInfoId);
if (machineInfo.getStatusCode() == 1) { // if (machineInfo.getStatusCode() == 1) {
this.removeById(machineInfo.getId()); // this.removeById(machineInfoId);
} // }
}); // }
} //
// private QueryWrapper<MachineInfo> getMachineInfoQueryWrapper(MachineInfoDto machineInfoDto) {
@Override // QueryWrapper<MachineInfo> queryWrapper = new QueryWrapper<>();
public void deleteMachineInfo(Long machineInfoId) { // if (machineInfoDto.getStatus() != null && !machineInfoDto.getStatus().isEmpty()) {
MachineInfo machineInfo = this.getById(machineInfoId); // queryWrapper.eq("status_code", EnumUtils.getEnumByMessage(machineInfoDto.getStatus(), MachineInfoStatus.class).getCode());
if (machineInfo.getStatusCode() == 1) { // }
this.removeById(machineInfoId); // if (machineInfoDto.getName() != null && !machineInfoDto.getName().isEmpty()) {
} // queryWrapper.like("name", machineInfoDto.getName());
} // }
// if (machineInfoDto.getTag() != null && !machineInfoDto.getTag().isEmpty()) {
private QueryWrapper<MachineInfo> getMachineInfoQueryWrapper(MachineInfoDto machineInfoDto) { // queryWrapper.like("tag", machineInfoDto.getTag());
QueryWrapper<MachineInfo> queryWrapper = new QueryWrapper<>(); // }
if (machineInfoDto.getStatus() != null && !machineInfoDto.getStatus().isEmpty()) { // if (machineInfoDto.getHostIp() != null && !machineInfoDto.getHostIp().isEmpty()) {
queryWrapper.eq("status_code", EnumUtils.getEnumByMessage(machineInfoDto.getStatus(), MachineInfoStatus.class).getCode()); // queryWrapper.like("host_ip", machineInfoDto.getHostIp());
} // }
if (machineInfoDto.getName() != null && !machineInfoDto.getName().isEmpty()) { // if (machineInfoDto.getDescription() != null && !machineInfoDto.getDescription().isEmpty()) {
queryWrapper.like("name", machineInfoDto.getName()); // queryWrapper.like("description", machineInfoDto.getDescription());
} // }
if (machineInfoDto.getTag() != null && !machineInfoDto.getTag().isEmpty()) { // return queryWrapper.orderByDesc("create_date");
queryWrapper.like("tag", machineInfoDto.getTag()); // }
} //
if (machineInfoDto.getHostIp() != null && !machineInfoDto.getHostIp().isEmpty()) { //
queryWrapper.like("host_ip", machineInfoDto.getHostIp()); // @Override
} // public boolean testConnection(Long id) {
if (machineInfoDto.getDescription() != null && !machineInfoDto.getDescription().isEmpty()) { // //先查询机器是否存在，在判断机器可用性
queryWrapper.like("description", machineInfoDto.getDescription()); // MachineInfo machineInfo = machineInfoMapper.getById(id);
} // if (machineInfo==null){
return queryWrapper.orderByDesc("create_date"); // throw new RuntimeException("机器不存在");
} // }
// if (machineInfo.getStatusCode() == 0) {
// throw new RuntimeException("机器不可用");
@Override // }
public boolean testConnection(Long id) { // log.info("测试机器连接: {}", machineInfo.getHostIp());
//先查询机器是否存在，在判断机器可用性 // connectionSession.setMachineInfo(machineInfo);
MachineInfo machineInfo = this.getById(id); // try{
if (machineInfo==null){ // connectionSession.connect();
throw new RuntimeException("机器不存在"); // return true;
} // } catch (Exception e) {
if (machineInfo.getStatusCode() == 0) { // log.error("机器连接测试失败: {}", e.getMessage(), e);
throw new RuntimeException("机器不可用"); // return false;
} // }
log.info("测试机器连接: {}", machineInfo.getHostIp()); // }
connectionSession.setMachineInfo(machineInfo); //
try{ // @Override
connectionSession.connect(); // public ConnectionStatus getConnectionStatus(String machineName) {
return true; // String sessionId = machineSessionMapping.get(machineName);
} catch (Exception e) { // if (sessionId == null) {
log.error("机器连接测试失败: {}", e.getMessage(), e); // return ConnectionStatus.DISCONNECTED;
return false; // }
} //
} // ConnectionSession session = sessions.get(sessionId);
// return session != null ? session.getStatus() : ConnectionStatus.DISCONNECTED;
@Override // }
public ConnectionStatus getConnectionStatus(String machineName) { //
String sessionId = machineSessionMapping.get(machineName); // @Override
if (sessionId == null) { // public Map<String, ConnectionStatus> getAllConnectionStatus() {
return ConnectionStatus.DISCONNECTED; // Map<String, ConnectionStatus> result = new HashMap<>();
} //
// machineSessionMapping.forEach((machineName, sessionId) -> {
ConnectionSession session = sessions.get(sessionId); // ConnectionSession session = sessions.get(sessionId);
return session != null ? session.getStatus() : ConnectionStatus.DISCONNECTED; // result.put(machineName, session != null ? session.getStatus() : ConnectionStatus.DISCONNECTED);
} // });
//
@Override // return result;
public Map<String, ConnectionStatus> getAllConnectionStatus() { // }
Map<String, ConnectionStatus> result = new HashMap<>(); //
// @Override
machineSessionMapping.forEach((machineName, sessionId) -> { // public String connect(MachineInfo machineInfo) {
ConnectionSession session = sessions.get(sessionId); // if (machineInfo.getStatus().getCode() == UN_ENABLE) {
result.put(machineName, session != null ? session.getStatus() : ConnectionStatus.DISCONNECTED); // throw new RuntimeException("机器不可用");
}); // }
// log.info("建立机器连接: {}", machineInfo.getHostIp());
return result; //
} // // 检查是否已连接
// String existingSessionId = machineSessionMapping.get(machineInfo.getName());
@Override // if (existingSessionId != null) {
public String connect(MachineInfo machineInfo) { // ConnectionSession existingSession = sessions.get(existingSessionId);
if (machineInfo.getStatus().getCode() == UN_ENABLE) { // if (existingSession != null && existingSession.getStatus() == ConnectionStatus.CONNECTED) {
throw new RuntimeException("机器不可用"); // log.info("机器已连接，返回现有会话: {}", machineInfo.getHostIp());
} // return existingSessionId;
log.info("建立机器连接: {}", machineInfo.getHostIp()); // }
// }
// 检查是否已连接 //
String existingSessionId = machineSessionMapping.get(machineInfo.getName()); // try {
if (existingSessionId != null) { // connectionSession.setMachineInfo(machineInfo);
ConnectionSession existingSession = sessions.get(existingSessionId); //
if (existingSession != null && existingSession.getStatus() == ConnectionStatus.CONNECTED) { // connectionSession.connect();
log.info("机器已连接，返回现有会话: {}", machineInfo.getHostIp()); //
return existingSessionId; // // 生成会话ID
} // String sessionId = generateSessionId();
} //
// // 保存会话
try { // sessions.put(sessionId, connectionSession);
connectionSession.setMachineInfo(machineInfo); // machineSessionMapping.put(machineInfo.getName(), sessionId);
//
connectionSession.connect(); // log.info("机器连接成功: {}, 会话ID: {}", machineInfo.getHostIp(), sessionId);
// return sessionId;
// 生成会话ID // } catch (Exception e) {
String sessionId = generateSessionId(); // log.error("机器连接失败: {}", e.getMessage(), e);
// throw new RuntimeException("机器连接失败: " + e.getMessage(), e);
// 保存会话 // }
sessions.put(sessionId, connectionSession); // }
machineSessionMapping.put(machineInfo.getName(), sessionId); //
// @Override
log.info("机器连接成功: {}, 会话ID: {}", machineInfo.getHostIp(), sessionId); // public boolean disconnect(String sessionId) {
return sessionId; // log.info("断开机器连接: {}", sessionId);
} catch (Exception e) { //
log.error("机器连接失败: {}", e.getMessage(), e); // ConnectionSession session = sessions.get(sessionId);
throw new RuntimeException("机器连接失败: " + e.getMessage(), e); // if (session == null) {
} // log.warn("会话不存在: {}", sessionId);
} // return false;
// }
@Override //
public boolean disconnect(String sessionId) { // try {
log.info("断开机器连接: {}", sessionId); // session.disconnect();
//
ConnectionSession session = sessions.get(sessionId); // // 清理会话
if (session == null) { // sessions.remove(sessionId);
log.warn("会话不存在: {}", sessionId); // machineSessionMapping.entrySet().removeIf(entry -> entry.getValue().equals(sessionId));
return false; //
} // log.info("机器连接已断开: {}", sessionId);
// return true;
try { // } catch (Exception e) {
session.disconnect(); // log.error("断开连接失败: {}", e.getMessage(), e);
// return false;
// 清理会话 // }
sessions.remove(sessionId); // }
machineSessionMapping.entrySet().removeIf(entry -> entry.getValue().equals(sessionId)); //
// @Override
log.info("机器连接已断开: {}", sessionId); // public String executeCommand(String sessionId, String command) {
return true; // log.info("执行命令: {}, 会话ID: {}", command, sessionId);
} catch (Exception e) { //
log.error("断开连接失败: {}", e.getMessage(), e); // ConnectionSession session = sessions.get(sessionId);
return false; // if (session == null) {
} // throw new RuntimeException("会话不存在: " + sessionId);
} // }
//
@Override // if (session.getStatus() != ConnectionStatus.CONNECTED) {
public String executeCommand(String sessionId, String command) { // throw new RuntimeException("会话未连接: " + sessionId);
log.info("执行命令: {}, 会话ID: {}", command, sessionId); // }
//
ConnectionSession session = sessions.get(sessionId); // try {
if (session == null) { // return session.executeCommand(command);
throw new RuntimeException("会话不存在: " + sessionId); // } catch (Exception e) {
} // log.error("命令执行失败: {}", e.getMessage(), e);
// throw new RuntimeException("命令执行失败: " + e.getMessage(), e);
if (session.getStatus() != ConnectionStatus.CONNECTED) { // }
throw new RuntimeException("会话未连接: " + sessionId); // }
} //
// @Override
try { // public boolean uploadFile(String sessionId, String localFilePath, String remoteFilePath) {
return session.executeCommand(command); // log.info("上传文件: {} -> {}, 会话ID: {}", localFilePath, remoteFilePath, sessionId);
} catch (Exception e) { //
log.error("命令执行失败: {}", e.getMessage(), e); // ConnectionSession session = sessions.get(sessionId);
throw new RuntimeException("命令执行失败: " + e.getMessage(), e); // if (session == null) {
} // throw new RuntimeException("会话不存在: " + sessionId);
} // }
//
@Override // if (session.getStatus() != ConnectionStatus.CONNECTED) {
public boolean uploadFile(String sessionId, String localFilePath, String remoteFilePath) { // throw new RuntimeException("会话未连接: " + sessionId);
log.info("上传文件: {} -> {}, 会话ID: {}", localFilePath, remoteFilePath, sessionId); // }
//
ConnectionSession session = sessions.get(sessionId); // try {
if (session == null) { // return session.uploadFile(localFilePath, remoteFilePath);
throw new RuntimeException("会话不存在: " + sessionId); // } catch (Exception e) {
} // log.error("文件上传失败: {}", e.getMessage(), e);
// throw new RuntimeException("文件上传失败: " + e.getMessage(), e);
if (session.getStatus() != ConnectionStatus.CONNECTED) { // }
throw new RuntimeException("会话未连接: " + sessionId); // }
} //
// @Override
try { // public boolean downloadFile(String sessionId, String remoteFilePath, String localFilePath) {
return session.uploadFile(localFilePath, remoteFilePath); // log.info("下载文件: {} -> {}, 会话ID: {}", remoteFilePath, localFilePath, sessionId);
} catch (Exception e) { //
log.error("文件上传失败: {}", e.getMessage(), e); // ConnectionSession session = sessions.get(sessionId);
throw new RuntimeException("文件上传失败: " + e.getMessage(), e); // if (session == null) {
} // throw new RuntimeException("会话不存在: " + sessionId);
} // }
//
@Override // if (session.getStatus() != ConnectionStatus.CONNECTED) {
public boolean downloadFile(String sessionId, String remoteFilePath, String localFilePath) { // throw new RuntimeException("会话未连接: " + sessionId);
log.info("下载文件: {} -> {}, 会话ID: {}", remoteFilePath, localFilePath, sessionId); // }
//
ConnectionSession session = sessions.get(sessionId); // try {
if (session == null) { // return session.downloadFile(remoteFilePath, localFilePath);
throw new RuntimeException("会话不存在: " + sessionId); // } catch (Exception e) {
} // log.error("文件下载失败: {}", e.getMessage(), e);
// throw new RuntimeException("文件下载失败: " + e.getMessage(), e);
if (session.getStatus() != ConnectionStatus.CONNECTED) { // }
throw new RuntimeException("会话未连接: " + sessionId); // }
} //
//
try { // /**
return session.downloadFile(remoteFilePath, localFilePath); // * 生成会话ID
} catch (Exception e) { // */
log.error("文件下载失败: {}", e.getMessage(), e); // private String generateSessionId() {
throw new RuntimeException("文件下载失败: " + e.getMessage(), e); // return "session-" + sessionIdGenerator.incrementAndGet();
} // }
} //}
/**
* 生成会话ID
*/
private String generateSessionId() {
return "session-" + sessionIdGenerator.incrementAndGet();
}
}

317
modules/module-ci-machine/src/main/java/cd/casic/module/machine/service/impl/SecretKeyServiceImpl.java
View File

@ -1,160 +1,159 @@
package cd.casic.module.machine.service.impl; //package cd.casic.module.machine.service.impl;
//
import cd.casic.module.machine.dto.SecretKeyDto; //import cd.casic.module.machine.controller.vo.SecretKeyDto;
import cd.casic.module.machine.entity.MachineInfo; //import cd.casic.module.machine.dal.dataobject.MachineInfo;
import cd.casic.module.machine.entity.SecretKey; //import cd.casic.module.machine.dal.dataobject.SecretKey;
import cd.casic.module.machine.mapper.SecretServiceMapper; //import cd.casic.module.machine.dal.mysql.SecretServiceMapper;
import cd.casic.module.machine.service.MachineInfoService;
import cd.casic.module.machine.utils.PageResult;
import cn.hutool.core.io.resource.ResourceUtil;
import cn.hutool.core.util.IdUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import cd.casic.module.machine.utils.AliYunOssClient;
import cd.casic.module.machine.exception.ServiceException;
//import cd.casic.module.machine.service.MachineInfoService; //import cd.casic.module.machine.service.MachineInfoService;
import cd.casic.module.machine.service.SecretKeyService; //import cn.hutool.core.io.resource.ResourceUtil;
import jakarta.annotation.Resource; //import cn.hutool.core.util.IdUtil;
import org.springframework.beans.BeanUtils; //import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.stereotype.Service; //import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
//import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import java.util.List; //
//import cd.casic.module.machine.utils.AliYunOssClient;
@Service //import cd.casic.module.machine.exception.ServiceException;
public class SecretKeyServiceImpl extends ServiceImpl<SecretServiceMapper, SecretKey> implements SecretKeyService { ////import cd.casic.module.machine.service.MachineInfoService;
//import cd.casic.module.machine.service.SecretKeyService;
@Resource //import jakarta.annotation.Resource;
private MachineInfoService machineInfoService; //import org.springframework.beans.BeanUtils;
//import org.springframework.stereotype.Service;
@Resource //
private AliYunOssClient aliYunOssClient; //import java.util.List;
//
@Resource //@Service
private SecretServiceMapper secretServiceMapper; //public class SecretKeyServiceImpl extends ServiceImpl<SecretServiceMapper, SecretKey> implements SecretKeyService {
//
// @Resource
// private MachineInfoService machineInfoService;
//
@Override // @Resource
public boolean addSecretKey(SecretKeyDto secretKeyDto){ // private AliYunOssClient aliYunOssClient;
if (secretKeyDto.getPath()==null) //
{ // @Resource
throw new ServiceException(ServiceException.MACHINE_PROXY_NULL,"密钥不能为空"); // private SecretServiceMapper secretServiceMapper;
} //
//
String ossPath = upLoadSecretKey(secretKeyDto.getPath()); //
if (ossPath == null){ //
throw new ServiceException(ServiceException.MACHINE_PROXY_NULL,"密钥上传失败"); // @Override
} // public boolean addSecretKey(SecretKeyDto secretKeyDto){
secretKeyDto.setPath(ossPath); // if (secretKeyDto.getPath()==null)
SecretKey secretKey = new SecretKey(); // {
BeanUtils.copyProperties(secretKeyDto,secretKey); // throw new ServiceException(ServiceException.MACHINE_PROXY_NULL,"密钥不能为空");
//todo检查密钥合法 // }
return this.save(secretKey); //
// String ossPath = upLoadSecretKey(secretKeyDto.getPath());
// if (ossPath == null){
} // throw new ServiceException(ServiceException.MACHINE_PROXY_NULL,"密钥上传失败");
@Override // }
public boolean updateSecretKey(SecretKeyDto secretKeyDto) { // secretKeyDto.setPath(ossPath);
// SecretKey secretKey = new SecretKey();
Long id = secretKeyDto.getId(); // BeanUtils.copyProperties(secretKeyDto,secretKey);
SecretKey secretKey = this.getById(id); // //todo检查密钥合法
if (secretKey == null){ // return this.save(secretKey);
throw new ServiceException(ServiceException.MACHINE_PROXY_NULL,"密钥不存在"); //
} //
if (!secretKey.getPath().equals(secretKeyDto.getPath())) { // }
//todo检查密钥合法 // @Override
String ossPath = upLoadSecretKey(secretKeyDto.getPath()); // public boolean updateSecretKey(SecretKeyDto secretKeyDto) {
BeanUtils.copyProperties(secretKeyDto,secretKey); //
secretKey.setPath(ossPath); // Long id = secretKeyDto.getId();
} // SecretKey secretKey = this.getById(id);
else { // if (secretKey == null){
BeanUtils.copyProperties(secretKeyDto,secretKey); // throw new ServiceException(ServiceException.MACHINE_PROXY_NULL,"密钥不存在");
} // }
// if (!secretKey.getPath().equals(secretKeyDto.getPath())) {
return this.updateById(secretKey); // //todo检查密钥合法
// String ossPath = upLoadSecretKey(secretKeyDto.getPath());
// BeanUtils.copyProperties(secretKeyDto,secretKey);
} // secretKey.setPath(ossPath);
// }
@Override // else {
public void bindingMachine(Long secretKeyId, List<Long> machineIds) { // BeanUtils.copyProperties(secretKeyDto,secretKey);
SecretKey secretKey = this.getById(secretKeyId); // }
if (secretKey==null){ //
throw new ServiceException(ServiceException.SECRETKEY_NULL,"密钥不存在"); // return this.updateById(secretKey);
} //
List<MachineInfo> machineList = machineInfoService.listByIds(machineIds); //
machineList.forEach(machine -> machine.setSecretKeyId(secretKeyId)); // }
machineInfoService.updateBatchById(machineList); //
} // @Override
// public void bindingMachine(Long secretKeyId, List<Long> machineIds) {
// SecretKey secretKey = this.getById(secretKeyId);
// if (secretKey==null){
// throw new ServiceException(ServiceException.SECRETKEY_NULL,"密钥不存在");
// }
@Override // List<MachineInfo> machineList = machineInfoService.listByIds(machineIds);
public PageResult<SecretKey> listSecretKey(SecretKeyDto secretKeyDto) { // machineList.forEach(machine -> machine.setSecretKeyId(secretKeyId));
QueryWrapper<SecretKey> queryWrapper = new QueryWrapper<>(); // machineInfoService.updateBatchById(machineList);
if (secretKeyDto.getName() != null && !secretKeyDto.getName().isEmpty()){ // }
queryWrapper.like("name", secretKeyDto.getName()); //
} //
if (secretKeyDto.getDescription() != null && !secretKeyDto.getDescription().isEmpty()){ //
queryWrapper.like("description", secretKeyDto.getDescription()); //
} //
Page<SecretKey> page = secretServiceMapper.selectPage(new Page<>(secretKeyDto.getPageIndex(), secretKeyDto.getPageSize()), queryWrapper); // @Override
return new PageResult<>( // public PageResult<SecretKey> listSecretKey(SecretKeyDto secretKeyDto) {
page.getCurrent(), // QueryWrapper<SecretKey> queryWrapper = new QueryWrapper<>();
page.getSize(), // if (secretKeyDto.getName() != null && !secretKeyDto.getName().isEmpty()){
page.getTotal(), // queryWrapper.like("name", secretKeyDto.getName());
page.getPages(), // }
page.getRecords() // if (secretKeyDto.getDescription() != null && !secretKeyDto.getDescription().isEmpty()){
); // queryWrapper.like("description", secretKeyDto.getDescription());
} // }
// Page<SecretKey> page = secretServiceMapper.selectPage(new Page<>(secretKeyDto.getPageIndex(), secretKeyDto.getPageSize()), queryWrapper);
// return new PageResult<>(
// page.getCurrent(),
@Override // page.getSize(),
public boolean deleteList(List<Long> secretKeyIds) { // page.getTotal(),
List<SecretKey> secretKeys = this.listByIds(secretKeyIds); // page.getPages(),
// page.getRecords()
for (SecretKey secretKey : secretKeys) { // );
if (secretKey.getPath() != null && !secretKey.getPath().isEmpty()){ // }
try { //
//文件名 //
//删除子目录文件，需要在前面加上根目录文件路径 //
String fileName = secretKey.getPath().substring(secretKey.getPath().lastIndexOf("/") + 1); // @Override
aliYunOssClient.delete(fileName); // public boolean deleteList(List<Long> secretKeyIds) {
} catch (Exception e) { // List<SecretKey> secretKeys = this.listByIds(secretKeyIds);
throw new RuntimeException(e); //
} // for (SecretKey secretKey : secretKeys) {
} // if (secretKey.getPath() != null && !secretKey.getPath().isEmpty()){
} // try {
// //文件名
// //删除子目录文件，需要在前面加上根目录文件路径
//todo是否删除已经绑定的机器 // String fileName = secretKey.getPath().substring(secretKey.getPath().lastIndexOf("/") + 1);
return secretServiceMapper.deleteBatchIds(secretKeyIds) > 0 ; // aliYunOssClient.delete(fileName);
} // } catch (Exception e) {
// throw new RuntimeException(e);
// }
public String upLoadSecretKey(String localPath) { // }
// }
//使用S3FileClient上传文件 //
aliYunOssClient.init(); //
// //todo是否删除已经绑定的机器
//传输到指定文件，需要在path前面加上文件路径 // return secretServiceMapper.deleteBatchIds(secretKeyIds) > 0 ;
String path = IdUtil.fastSimpleUUID() + ".txt"; // }
//
//
//上传文件是从本地上传，这里传的是本地文件地址 // public String upLoadSecretKey(String localPath) {
byte[] content = ResourceUtil.readBytes(localPath); //
String ossPath; // //使用S3FileClient上传文件
try { // aliYunOssClient.init();
ossPath = aliYunOssClient.upload(content, path, "txt"); //
}catch (Exception e) { // //传输到指定文件，需要在path前面加上文件路径
throw new RuntimeException(e+"上传文件失败"); // String path = IdUtil.fastSimpleUUID() + ".txt";
} //
return ossPath; //
} // //上传文件是从本地上传，这里传的是本地文件地址
} // byte[] content = ResourceUtil.readBytes(localPath);
// String ossPath;
// try {
// ossPath = aliYunOssClient.upload(content, path, "txt");
// }catch (Exception e) {
// throw new RuntimeException(e+"上传文件失败");
// }
// return ossPath;
// }
//}

45
modules/module-ci-machine/src/main/java/cd/casic/module/machine/utils/PageResult.java
View File

@ -1,45 +0,0 @@
package cd.casic.module.machine.utils;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* 分页结果通用类
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PageResult<T> implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 当前页码
*/
private Long pageNum;
/**
* 每页数量
*/
private Long pageSize;
/**
* 总记录数
*/
private Long total;
/**
* 总页数
*/
private Long pages;
/**
* 数据列表
*/
private List<T> list;
}