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

机器管理规范化

Browse Source
This commit is contained in:
唐潇凯 2025-06-09 18:05:30 +08:00
parent 97ffb19c03
commit be07dc0e0a
24 changed files with 1673 additions and 1505 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -8,6 +8,16 @@ 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 MACHINE_INFO_HOST_IP_NULL = new ErrorCode(1_003_000_000, "机器主机IP为空");
ErrorCode MACHINE_INFO_USER_NAME_NULL = new ErrorCode(1_003_000_000, "机器用户名为空");
ErrorCode MACHINE_INFO_TYPE_NULL = new ErrorCode(1_003_000_022, "机器类型为空");
ErrorCode MACHINE_INFO_TYPE_NOT_EXISTS = new ErrorCode(1_003_000_011, "机器类型不存在");
ErrorCode MACHINE_INFO_TAG_NULL = new ErrorCode(1_003_000_044, "机器唯一标识为空");
ErrorCode MACHINE_INFO_TAG_EXISTS = new ErrorCode(1_003_000_044, "机器唯一标识已存在");
ErrorCode MACHINE_INFO_AUTHENTICATION_TYPE_NULL = new ErrorCode(1_003_000_044, "机器认证类型为空");
ErrorCode MACHINE_INFO_AUTHENTICATION_TYPE_NOT_EXISTS = new ErrorCode(1_003_000_044, "机器认证类型不存在");
ErrorCode MACHINE_ENABLE = new ErrorCode(1_003_000_044, "机器启用中");
ErrorCode MACHINE_UN_ENABLE = new ErrorCode(1_003_000_044, "机器不可用");
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, "文件名为空");
@ -15,6 +25,8 @@ public interface MachineErrorCodeConstants {
ErrorCode DELETE_FILE_FAIL = new ErrorCode(1_003_000_005, "删除文件失败");
ErrorCode PARAMETER_ERROR = new ErrorCode(1_003_000_008, "参数错误");
// ========== 机器环境变量模块 1-003-000-009 ==========
ErrorCode MACHINE_ENV_NULL = new ErrorCode(1_003_000_009, "机器环境变量为空");
ErrorCode MACHINE_ENV_NOT_EXISTS = new ErrorCode(1_003_000_009, "机器不存在");
@ -26,6 +38,15 @@ public interface MachineErrorCodeConstants {
ErrorCode MACHINE_PROXY_TYPE_NOT_EXISTS = new ErrorCode(1_003_000_007, "机器代理类型不存在");
ErrorCode MACHINE_PROXY_IS_ONLINE = new ErrorCode(1_003_000_007, "机器代理在线，不能删除");
// ========== 密钥模块 1-003-000-010 ==========
ErrorCode SECRET_KEY_NULL = new ErrorCode(1_003_000_010, "密钥为空");
ErrorCode SECRET_KEY_NOT_EXISTS = new ErrorCode(1_003_000_010, "密钥不存在");
ErrorCode SECRET_KEY_NAME_ILLEGAL = new ErrorCode(1_003_000_010, "密钥名称不合法");
ErrorCode SECRET_KEY_PATH_ILLEGAL = new ErrorCode(1_003_000_010, "密钥路径不合法");
ErrorCode SECRET_KEY_PATH_NULL = new ErrorCode(1_003_000_010, "密钥路径为空");
ErrorCode SECRET_KEY_UPLOAD_FAIL = 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, "密钥为空");
}

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

@ -1,126 +1,143 @@
//package cd.casic.module.machine.controller;
//
//import cd.casic.framework.commons.pojo.CommonResult;
//import cd.casic.framework.commons.pojo.PageResult;
//import cd.casic.module.machine.dal.dataobject.MachineInfo;
//import cd.casic.module.machine.enums.ConnectionStatus;
//import cd.casic.module.machine.service.MachineInfoService;
//import cd.casic.module.machine.controller.vo.MachineInfoDto;
//import io.swagger.v3.oas.annotations.Operation;
//import io.swagger.v3.oas.annotations.tags.Tag;
//import jakarta.annotation.Resource;
//import org.springframework.web.bind.annotation.*;
//
//import java.util.Map;
//
//import static cd.casic.framework.commons.pojo.CommonResult.success;
//
//@RestController
//@Tag(name = "机器信息管理")
//@RequestMapping("/api/machineInfo")
//public class MachineInfoController {
// @Resource
// private MachineInfoService machineInfoService;
//
// @PostMapping("/add")
// @Operation(summary = "新增机器信息")
// public CommonResult<Boolean> add(@RequestBody MachineInfoDto machineInfoDto) {
// return success(machineInfoService.addMachineInfo(machineInfoDto));
// }
//
//
// @PostMapping("/list")
// @Operation(summary = "获取机器信息列表")
// public CommonResult<PageResult<MachineInfoDto>> list(@RequestBody MachineInfoDto machineInfoDto) {
// return success(machineInfoService.listMachineInfo(machineInfoDto));
// }
//
// @PutMapping("/update")
// @Operation(summary = "编辑机器信息")
// public CommonResult<Boolean> update(@RequestBody MachineInfoDto machineInfoDto) {
// return success(machineInfoService.updateMachineInfo(machineInfoDto));
// }
//
// @PutMapping("/updateStatus")
// @Operation(summary = "机器启用/停用")
// public CommonResult<Boolean> updateStatus(@RequestBody MachineInfoDto machineInfoDto) {
// return success(machineInfoService.updateStatus(machineInfoDto));
// }
//
// @PutMapping("/bindingSecretKey")
// @Operation(summary = "绑定密钥")
// public CommonResult<Boolean> bindingSecretKey(@RequestBody MachineInfoDto machineInfoDto) {
// return success(machineInfoService.bindingSecretKey(machineInfoDto));
// }
//
// @DeleteMapping("/delete")
// @Operation(summary = "机器信息删除")
// public CommonResult<Boolean> delete(@RequestParam Long machineInfoId) {
// machineInfoService.deleteMachineInfo(machineInfoId);
// return success(true);
// }
//
// @DeleteMapping("/deleteList")
// @Operation(summary = "批量删除机器信息")
// public CommonResult<Boolean> deleteList(@RequestParam String machineInfoIds) {
// machineInfoService.deleteList(machineInfoIds);
// return success(true);
// }
//
// @PostMapping("/test")
// @Operation(summary = "测试机器连接")
// public CommonResult<Boolean> testConnection(@RequestParam Long id) {
// return success(machineInfoService.testConnection(id));
// }
//
// @GetMapping("/status/{machineName}")
// @Operation(summary = "获取机器连接状态")
// public CommonResult<ConnectionStatus> getConnectionStatus(@PathVariable String machineName) {
// return success(machineInfoService.getConnectionStatus(machineName));
// }
//
// @GetMapping("/status/all")
// @Operation(summary = "获取所有机器连接状态")
// public CommonResult<Map<String, ConnectionStatus>> getAllConnectionStatus() {
// return success(machineInfoService.getAllConnectionStatus());
// }
//
// @PostMapping("/connect")
// @Operation(summary = "建立机器连接")
// public CommonResult<String> connect(@RequestBody MachineInfo machineInfo) {
// return success(machineInfoService.connect(machineInfo));
// }
//
// @PostMapping("/disconnect/{sessionId}")
// @Operation(summary = "断开机器连接")
// public CommonResult<Boolean> disconnect(@PathVariable String sessionId) {
// return success(machineInfoService.disconnect(sessionId));
// }
//
// @PostMapping("/execute/{sessionId}")
// @Operation(summary = "执行远程命令")
// public CommonResult<String> executeCommand(
// @PathVariable String sessionId,
// @RequestBody String command) {
//
// return success(machineInfoService.executeCommand(sessionId, command));
// }
//
// @PostMapping("/upload/{sessionId}")
// @Operation(summary = "上传文件到远程机器")
// public CommonResult<Boolean> uploadFile(
// @PathVariable String sessionId,
// @RequestParam String localFilePath,
// @RequestParam String remoteFilePath) {
// return success(machineInfoService.uploadFile(sessionId, localFilePath, remoteFilePath));
// }
//
// @PostMapping("/download/{sessionId}")
// @Operation(summary = "从远程机器下载文件")
// public CommonResult<Boolean> downloadFile(
// @PathVariable String sessionId,
// @RequestParam String remoteFilePath,
// @RequestParam String localFilePath) {
// return success(machineInfoService.downloadFile(sessionId, remoteFilePath, localFilePath));
// }
//}
package cd.casic.module.machine.controller;
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.MachineInfoDO;
import cd.casic.module.machine.enums.ConnectionStatus;
import cd.casic.module.machine.service.MachineInfoService;
import cd.casic.module.machine.controller.vo.MachineInfoVO;
import cn.hutool.core.collection.CollUtil;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import jakarta.validation.Valid;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
import static cd.casic.framework.commons.pojo.CommonResult.success;
@RestController
@Tag(name = "机器信息管理")
@RequestMapping("/ci/machineInfo")
@Validated
public class MachineInfoController {
@Resource
private MachineInfoService machineInfoService;
@PostMapping("/create")
@Operation(summary = "新增机器信息")
// @PreAuthorize("@ss.hasPermission('ci:machineInfo:create')")
public CommonResult<Long> createMachine(@Valid @RequestBody MachineInfoVO machineInfoVO) {
Long id = machineInfoService.createMachine(machineInfoVO);
return success(id);
}
@PutMapping("/update")
@Operation(summary = "编辑机器信息")
// @PreAuthorize("@ss.hasPermission('ci:machineInfo:update')")
public CommonResult<Boolean> updateMachineInfo(@Valid @RequestBody MachineInfoVO machineInfoVO) {
machineInfoService.updateMachineInfo(machineInfoVO);
return success(true);
}
@PutMapping("/updateStatus")
@Operation(summary = "机器启用/停用")
// @PreAuthorize("@ss.hasPermission('ci:machineInfo:status')")
public CommonResult<Integer> updateStatus(@RequestParam("id") Long id, @RequestParam("status") Integer status) {
Integer newStatus = machineInfoService.updateStatus(id, status);
return success(newStatus);
}
@PostMapping("/list")
@Operation(summary = "获取机器信息列表")
public CommonResult<PageResult<MachineInfoVO>> list(@Valid @RequestBody MachineInfoVO machineInfoVO) {
PageResult<MachineInfoDO> pageResult = machineInfoService.listMachineInfo(machineInfoVO);
if (CollUtil.isEmpty(pageResult.getList())) {
return success(new PageResult<>(pageResult.getTotal()));
}
return success(BeanUtils.toBean(pageResult, MachineInfoVO.class));
}
@PutMapping("/bindingSecretKey")
@Operation(summary = "绑定密钥")
// @PreAuthorize("@ss.hasPermission('ci:machineInfo:binding')")
public CommonResult<Boolean> bindingSecretKey(@RequestParam("ids") List<Long> ids, @RequestParam("secretKeyId") Long secretKeyId) {
machineInfoService.bindingSecretKey(ids,secretKeyId);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "机器信息删除")
// @PreAuthorize("@ss.hasPermission('ci:machineInfo:delete')")
public CommonResult<Boolean> deleteMachineInfo(@RequestParam("id") Long id) {
machineInfoService.deleteMachineInfo(id);
return success(true);
}
@DeleteMapping("/deleteList")
@Operation(summary = "批量删除机器信息")
// @PreAuthorize("@ss.hasPermission('ci:machineInfo:delete')")
public CommonResult<Boolean> deleteMachineInfoList(@RequestParam("machineInfoIds") String ids) {
machineInfoService.deleteMachineInfoList(ids);
return success(true);
}
@PostMapping("/test")
@Operation(summary = "测试机器连接")
public CommonResult<Boolean> testConnection(@RequestParam Long id) {
return success(machineInfoService.testConnection(id));
}
@GetMapping("/status/{machineName}")
@Operation(summary = "获取机器连接状态")
public CommonResult<ConnectionStatus> getConnectionStatus(@PathVariable String machineName) {
return success(machineInfoService.getConnectionStatus(machineName));
}
@GetMapping("/status/all")
@Operation(summary = "获取所有机器连接状态")
public CommonResult<Map<String, ConnectionStatus>> getAllConnectionStatus() {
return success(machineInfoService.getAllConnectionStatus());
}
@PostMapping("/connect")
@Operation(summary = "建立机器连接")
public CommonResult<String> connect(@Valid @RequestBody MachineInfoDO machineInfoDO) {
return success(machineInfoService.connect(machineInfoDO));
}
@PostMapping("/disconnect/{sessionId}")
@Operation(summary = "断开机器连接")
public CommonResult<Boolean> disconnect(@PathVariable String sessionId) {
return success(machineInfoService.disconnect(sessionId));
}
@PostMapping("/execute/{sessionId}")
@Operation(summary = "执行远程命令")
public CommonResult<String> executeCommand(
@PathVariable String sessionId,
@RequestBody String command) {
return success(machineInfoService.executeCommand(sessionId, command));
}
@PostMapping("/upload/{sessionId}")
@Operation(summary = "上传文件到远程机器")
public CommonResult<Boolean> uploadFile(
@PathVariable String sessionId,
@RequestParam String localFilePath,
@RequestParam String remoteFilePath) {
return success(machineInfoService.uploadFile(sessionId, localFilePath, remoteFilePath));
}
@PostMapping("/download/{sessionId}")
@Operation(summary = "从远程机器下载文件")
public CommonResult<Boolean> downloadFile(
@PathVariable String sessionId,
@RequestParam String remoteFilePath,
@RequestParam String localFilePath) {
return success(machineInfoService.downloadFile(sessionId, remoteFilePath, localFilePath));
}
}

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

@ -1,56 +1,78 @@
//package cd.casic.module.machine.controller;
//
//import cd.casic.framework.commons.pojo.CommonResult;
//import cd.casic.framework.commons.pojo.PageResult;
//import cd.casic.module.machine.dal.dataobject.SecretKey;
//import cd.casic.module.machine.service.SecretKeyService;
//import cd.casic.module.machine.controller.vo.SecretKeyDto;
//import io.swagger.v3.oas.annotations.Operation;
//import io.swagger.v3.oas.annotations.tags.Tag;
//import jakarta.annotation.Resource;
//import org.springframework.web.bind.annotation.*;
//
//import java.util.List;
//
//import static cd.casic.framework.commons.pojo.CommonResult.success;
//
//@RestController
//@RequestMapping("/api/secretKey")
//@Tag(name = "密钥管理")
//public class SecretKeyController {
// @Resource
// private SecretKeyService secretKeyService;
//
// @PostMapping(value = "/add")
// @Operation(summary = "新增密钥")
// public CommonResult<Boolean> add(@RequestBody SecretKeyDto secretKeyDto) throws Exception {
// return success(secretKeyService.addSecretKey(secretKeyDto));
// }
//
// @PutMapping("/bindingMachine")
// @Operation(summary = "绑定机器")
// public CommonResult<Boolean> bindingMachine(@RequestParam("secretKeyId") Long secretKeyId, @RequestParam("machineIds") List<Long> machineIds) {
// secretKeyService.bindingMachine(secretKeyId, machineIds);
// return success(true);
// }
//
// @PutMapping("/update")
// @Operation(summary = "编辑密钥信息")
// public CommonResult<Boolean> update(@RequestBody SecretKeyDto secretKeyDto) {
// return success(secretKeyService.updateSecretKey(secretKeyDto));
// }
//
// @DeleteMapping("/deleteList")
// @Operation(summary = "批量删除密钥")
// public CommonResult<Boolean> deleteList(@RequestParam("secretKeyId") List<Long> secretKeyIds) {
// return success(secretKeyService.deleteList(secretKeyIds));
// }
//
// @PostMapping("/list")
// @Operation(summary = "获取密钥信息列表")
// public CommonResult<PageResult<SecretKey>> list(@RequestBody SecretKeyDto secretKeyDto) {
// return success(secretKeyService.listSecretKey(secretKeyDto));
// }
//
//
//}
package cd.casic.module.machine.controller;
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.SecretKeyDO;
import cd.casic.module.machine.service.SecretKeyService;
import cd.casic.module.machine.controller.vo.SecretKeyVO;
import cn.hutool.core.collection.CollUtil;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
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.*;
import java.util.List;
import static cd.casic.framework.commons.pojo.CommonResult.success;
@RestController
@RequestMapping("/ci/secretKey")
@Tag(name = "密钥管理")
@Validated
public class SecretKeyController {
@Resource
private SecretKeyService secretKeyService;
@PostMapping(value = "/create")
@Operation(summary = "新增密钥")
// @PreAuthorize("@ss.hasPermission('ci:secretKey:create')")
public CommonResult<Long> createSecretKey(@Valid @RequestBody SecretKeyVO secretKeyVO) throws Exception {
Long secretKeyId = secretKeyService.createSecretKey(secretKeyVO);
return success(secretKeyId);
}
@PutMapping("/update")
@Operation(summary = "编辑密钥信息")
// @PreAuthorize("@ss.hasPermission('ci:secretKey:update')")
public CommonResult<Boolean> updateSecretKey(@Valid @RequestBody SecretKeyVO secretKeyVO) {
secretKeyService.updateSecretKey(secretKeyVO);
return success(true);
}
@PutMapping("/bindingMachine")
@Operation(summary = "绑定机器") //todo解绑机器
// @PreAuthorize("@ss.hasPermission('ci:secretKey:binding')")
public CommonResult<Boolean> bindingMachine(@RequestParam("id") Long id, @RequestParam("machineInfoIds") List<Long> machineInfoId) {
secretKeyService.bindingMachine(id, machineInfoId);
return success(true);
}
@GetMapping("/getSecretKey")
@Operation(summary = "获取机器的环境变量")
public CommonResult<SecretKeyVO> getSecretKey(@RequestParam("id") Long id) {
SecretKeyVO secretKeyVO = secretKeyService.getSecretKey(id);
return success(secretKeyVO);
}
@DeleteMapping("/deleteList")
@Operation(summary = "批量删除密钥")
// @PreAuthorize("@ss.hasPermission('ci:secretKey:delete')")
public CommonResult<Boolean> deleteSecretKeyList(@RequestParam("ids") List<Long> ids) {
secretKeyService.deleteSecretKeyList(ids);
return success(true);
}
@PostMapping("/list")
@Operation(summary = "获取密钥信息列表")
public CommonResult<PageResult<SecretKeyVO>> getSecretKeypage(@Valid @RequestBody SecretKeyVO secretKeyVO) {
PageResult<SecretKeyDO> pageResult = secretKeyService.getSecretKeypage(secretKeyVO);
if (CollUtil.isEmpty(pageResult.getList())) {
return success(new PageResult<>(pageResult.getTotal()));
}
return success(BeanUtils.toBean(pageResult,SecretKeyVO.class));
}
}

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

@ -1,46 +0,0 @@
package cd.casic.module.machine.controller.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import java.util.Date;
@EqualsAndHashCode(callSuper = true)
@Data
@AllArgsConstructor
@NoArgsConstructor
public class MachineInfoDto extends PageDto {
private Long id;
private Date createDate;
private Date updateDate;
private String name;
private String tag;
private String hostIp;
private String description;
private String username;
private String status;
private Integer sshPort;
private String password;
private Long secretKeyId;
private Long machineProxyId;
private String authenticationType;
private String machineInfoType;
private int isProxy;
}

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

@ -0,0 +1,64 @@
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.util.Date;
@EqualsAndHashCode(callSuper = true)
@Schema(description = "管理后台 - 机器信息 Response VO")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class MachineInfoVO extends PageParam {
@Schema(description = "机器ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
private Long id;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED, example = "2023-06-15T10:30:00")
private Date createTime;
@Schema(description = "更新时间", example = "2023-06-15T10:30:00")
private Date updateTime;
@Schema(description = "机器名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "server-01")
private String name;
@Schema(description = "机器标签,唯一标识", example = "production,web-server")
private String tag;
@Schema(description = "主机IP", requiredMode = Schema.RequiredMode.REQUIRED, example = "192.168.1.100")
private String hostIp;
@Schema(description = "机器描述", example = "生产环境Web服务器")
private String description;
@Schema(description = "登录用户名", requiredMode = Schema.RequiredMode.REQUIRED, example = "admin")
private String username;
@Schema(description = "机器状态", example = "online,offline,maintenance")
private Integer status;
@Schema(description = "SSH端口", example = "22")
private Integer sshPort;
@Schema(description = "登录密码", example = "******")
private String password;
@Schema(description = "密钥ID", example = "5")
private Long secretKeyId;
@Schema(description = "代理ID", example = "101")
private Long machineProxyId;
@Schema(description = "认证类型", example = "password,key")
private Integer authenticationType;
@Schema(description = "机器信息类型", example = "Linux,Windows")
private Integer machineInfoType;
}

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

@ -1,35 +0,0 @@
package cd.casic.module.machine.controller.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import java.util.Date;
import java.util.List;
@EqualsAndHashCode(callSuper = true)
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SecretKeyDto extends PageDto {
private Long id;
private String name;
private String description;
//存储路径,本地上传文件路径
private String path;
private String fileName;
//密钥密码
private String password;
private Date createDate;
private Date updateDate;
private List<Long> machineInfoIds;
}

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

@ -0,0 +1,43 @@
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;
import java.util.List;
@EqualsAndHashCode(callSuper = true)
@Schema(description = "管理后台 - 密钥信息 Response VO")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true) // 添加链式调用支持
public class SecretKeyVO extends PageParam {
@Schema(description = "密钥ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
private Long id;
@Schema(description = "密钥名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "生产环境密钥")
private String name;
@Schema(description = "密钥描述", example = "用于加密敏感数据的密钥")
private String description;
@Schema(description = "存储路径（本地上传文件路径）", example = "/data/secret_keys/")
private String path;
@Schema(description = "文件名", example = "key.pem")
private String fileName;
@Schema(description = "密钥密码", example = "******")
private String password;
@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;
@Schema(description = "关联的机器ID列表", requiredMode = Schema.RequiredMode.REQUIRED, example = "[1024, 2048]")
private List<Long> machineInfoIds;
}

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

@ -1,24 +1,35 @@
package cd.casic.module.machine.dal.dataobject;
import cd.casic.framework.mybatis.core.dataobject.BaseDO;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import cd.casic.module.machine.enums.AuthenticationType;
import cd.casic.module.machine.enums.MachineInfoStatus;
import cd.casic.module.machine.enums.MachineInfoType;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
@EqualsAndHashCode(callSuper = true)
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "machine_info")
public class MachineInfo extends BaseEntity {
public class MachineInfoDO extends BaseDO {
/**
* 机器id
*/
@TableId
private Long id;
@TableField(value = "name")
private String name;
/**
* 机器唯一标识
*/
@TableField(value = "tag")
private String tag;
@ -28,18 +39,11 @@ public class MachineInfo extends BaseEntity {
@TableField(value = "description")
private String description;
@TableField(exist = false)
private MachineInfoType machineInfoType;
@TableField(value = "machine_info_type")
private Integer machineInfoType;
@TableField(value = "machine_info_type_code")
private int machineInfoTypeCode;
@TableField(exist = false)
private MachineInfoStatus status;
@TableField(value = "status_code")
private int statusCode;
@TableField(value = "status")
private Integer status;
//用户名
@TableField(value = "username")
@ -58,12 +62,7 @@ public class MachineInfo extends BaseEntity {
@TableField(value = "machine_proxy_id")
private Long machineProxyId;
@TableField(value = "authentication_type_code")
private int authenticationTypeCode;
@TableField(value = "authentication_type")
private Integer authenticationType;
@TableField(exist = false)
private AuthenticationType authenticationType;
@TableField(value = "is_proxy")
private int isProxy;
}

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

@ -1,6 +1,8 @@
package cd.casic.module.machine.dal.dataobject;
import cd.casic.framework.mybatis.core.dataobject.BaseDO;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
@ -12,7 +14,14 @@ import lombok.NoArgsConstructor;
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "machine_secret_key")
public class SecretKey extends BaseEntity{
public class SecretKeyDO extends BaseDO {
/**
* 密钥id
*/
@TableId
private Long id;
@TableField(value = "name")
private String name;

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

@ -1,11 +1,50 @@
package cd.casic.module.machine.dal.mysql;
import cd.casic.framework.commons.pojo.PageResult;
import cd.casic.framework.mybatis.core.mapper.BaseMapperX;
import cd.casic.framework.mybatis.core.query.LambdaQueryWrapperX;
import cd.casic.module.machine.controller.vo.MachineEnvVO;
import cd.casic.module.machine.controller.vo.MachineInfoVO;
import cd.casic.module.machine.dal.dataobject.MachineEnvDO;
import cd.casic.module.machine.dal.dataobject.MachineInfo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import cd.casic.module.machine.dal.dataobject.MachineInfoDO;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
@Mapper
public interface MachineInfoMapper extends BaseMapperX<MachineInfo> {
public interface MachineInfoMapper extends BaseMapperX<MachineInfoDO> {
default Boolean existsByTag(String tag){
return selectOne(new QueryWrapper<MachineInfoDO>().eq("tag", tag))!=null;
}
default void updateStatus(Long machineInfoId, Integer status){
UpdateWrapper<MachineInfoDO> set = new UpdateWrapper<>();
set.eq("id", machineInfoId).set("status", status);
this.update(null,set);
}
default void bindingSecretKey(List<Long> machineInfoIds, Long secretKeyId){
LambdaUpdateWrapper<MachineInfoDO> wrapper = new LambdaUpdateWrapper<MachineInfoDO>()
.set(MachineInfoDO::getSecretKeyId, secretKeyId)
.in(MachineInfoDO::getId, machineInfoIds);
this.update(null, wrapper);
}
default void unBindingSecretKey(List<Long> secretKeyId){
LambdaUpdateWrapper<MachineInfoDO> wrapper = new LambdaUpdateWrapper<MachineInfoDO>()
.set(MachineInfoDO::getSecretKeyId, null)
.in(MachineInfoDO::getSecretKeyId, secretKeyId);
this.update(null, wrapper);
}
default PageResult<MachineInfoDO> selectPage(MachineInfoVO machineInfoVO){
return selectPage(machineInfoVO,new LambdaQueryWrapperX<MachineInfoDO>()
.likeIfPresent(MachineInfoDO::getName, machineInfoVO.getName())
.likeIfPresent(MachineInfoDO::getTag, machineInfoVO.getTag())
.likeIfPresent(MachineInfoDO::getDescription, machineInfoVO.getDescription())
.likeIfPresent(MachineInfoDO::getUsername, machineInfoVO.getUsername())
.eqIfPresent(MachineInfoDO::getHostIp, machineInfoVO.getHostIp()));
}
}

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

@ -0,0 +1,29 @@
package cd.casic.module.machine.dal.mysql;
import cd.casic.framework.commons.pojo.PageResult;
import cd.casic.framework.mybatis.core.mapper.BaseMapperX;
import cd.casic.framework.mybatis.core.query.LambdaQueryWrapperX;
import cd.casic.module.machine.controller.vo.SecretKeyVO;
import cd.casic.module.machine.dal.dataobject.MachineInfoDO;
import cd.casic.module.machine.dal.dataobject.SecretKeyDO;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
@Mapper
public interface SecretKeyMapper extends BaseMapperX<SecretKeyDO> {
//查询列表
default PageResult<SecretKeyDO> selectPage(SecretKeyVO secretKeyVO){
return selectPage(secretKeyVO,new LambdaQueryWrapperX<SecretKeyDO>()
.likeIfPresent(SecretKeyDO::getName,secretKeyVO.getName())
.likeIfPresent(SecretKeyDO::getDescription,secretKeyVO.getDescription()));
}
default void bindingMachine(Long machineInfoId, List<Long> secretKeyId){
UpdateWrapper<SecretKeyDO> set = new UpdateWrapper<>();
set.eq("id", secretKeyId).set("machineInfoId", machineInfoId);
this.update(null,set);
}
}

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

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

11
modules/module-ci-machine/src/main/java/cd/casic/module/machine/enums/AuthenticationType.java
View File

@ -1,16 +1,25 @@
package cd.casic.module.machine.enums;
import cd.casic.framework.commons.core.IntArrayValuable;
import lombok.AllArgsConstructor;
import lombok.Getter;
import java.util.Arrays;
@Getter
@AllArgsConstructor
public enum AuthenticationType implements CodeEnum {
public enum AuthenticationType implements IntArrayValuable {
PASSWORD(1,"密码认证"),
SECRET_KEY(2,"密钥认证");
public static final int[] ARRAYS = Arrays.stream(values()).mapToInt(AuthenticationType::getCode).toArray();
private final int code;
private final String message;
@Override
public int[] array() {
return ARRAYS;
}
}

8
modules/module-ci-machine/src/main/java/cd/casic/module/machine/enums/MachineInfoStatus.java
View File

@ -1,16 +1,22 @@
package cd.casic.module.machine.enums;
import cd.casic.framework.commons.core.IntArrayValuable;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public enum MachineInfoStatus implements CodeEnum {
public enum MachineInfoStatus implements IntArrayValuable {
ENABLE(1,"启用"),
UN_ENABLE(0,"停用");
private final int code;
private final String message;
@Override
public int[] array() {
return new int[0];
}
}

12
modules/module-ci-machine/src/main/java/cd/casic/module/machine/enums/MachineInfoType.java
View File

@ -1,16 +1,24 @@
package cd.casic.module.machine.enums;
import cd.casic.framework.commons.core.IntArrayValuable;
import lombok.AllArgsConstructor;
import lombok.Getter;
import java.util.Arrays;
@Getter
@AllArgsConstructor
public enum MachineInfoType implements CodeEnum {
public enum MachineInfoType implements IntArrayValuable {
Linux(1,"Linux"),
WINDOWS(2,"Windows");
public static final int[] ARRAYS = Arrays.stream(values()).mapToInt(MachineInfoType::getCode).toArray();
private final int code;
private final String message;
@Override
public int[] array() {
return ARRAYS;
}
}

1
modules/module-ci-machine/src/main/java/cd/casic/module/machine/enums/MachineProxyStatus.java
View File

@ -6,6 +6,7 @@ import lombok.AllArgsConstructor;
import lombok.Getter;
import java.util.Arrays;
import java.util.List;
@Getter
@AllArgsConstructor

19
modules/module-ci-machine/src/main/java/cd/casic/module/machine/enums/PermissionExceptionEnum.java
View File

@ -1,19 +0,0 @@
package cd.casic.module.machine.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public enum PermissionExceptionEnum implements CodeEnum {
URL_NOT_EXIST(1, "资源路径不存在，请检查请求地址"),
NO_PERMISSION(2, "没有权限访问资源，请联系管理员"),
NO_PERMISSION_OPERATE(3, "没有权限操作该数据，请联系管理员");
private final int code;
private final String message;
}

1277
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

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

@ -1,25 +1,26 @@
package cd.casic.module.machine.service;
import cd.casic.framework.commons.pojo.PageResult;
import cd.casic.module.machine.controller.vo.MachineInfoDto;
import cd.casic.module.machine.dal.dataobject.MachineInfo;
import cd.casic.module.machine.controller.vo.MachineInfoVO;
import cd.casic.module.machine.dal.dataobject.MachineInfoDO;
import cd.casic.module.machine.enums.ConnectionStatus;
import com.baomidou.mybatisplus.extension.service.IService;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
import java.util.Map;
public interface MachineInfoService {
boolean addMachineInfo(MachineInfoDto MachineInfoDto);
Long createMachine(MachineInfoVO MachineInfoVO);
PageResult<MachineInfoDto> listMachineInfo(MachineInfoDto MachineInfoDto);
PageResult<MachineInfoDO> listMachineInfo(MachineInfoVO MachineInfoVO);
boolean updateMachineInfo(MachineInfoDto machineInfoDto);
void updateMachineInfo(MachineInfoVO machineInfoVO);
boolean updateStatus(MachineInfoDto machineInfoDto);
Integer updateStatus(Long machineInfoId, Integer status);
boolean bindingSecretKey(MachineInfoDto machineInfoDto);
void bindingSecretKey(List<Long> machineInfoIds, Long secretKeyId);
void deleteList(String machineInfoIds);
void deleteMachineInfoList(String machineInfoIds);
void deleteMachineInfo(Long machineInfoId);
@ -50,10 +51,10 @@ public interface MachineInfoService {
/**
* 建立机器连接
*
* @param machineInfo 机器信息
* @param machineInfoDO 机器信息
* @return 连接会话ID
*/
String connect(MachineInfo machineInfo);
String connect(MachineInfoDO machineInfoDO);
/**
* 断开机器连接
@ -91,4 +92,6 @@ public interface MachineInfoService {
* @return 操作结果
*/
boolean downloadFile(String sessionId, String remoteFilePath, String localFilePath);
void unBindingSecretKey(List<Long> SecretKeyIds);
}

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

@ -1,24 +1,25 @@
package cd.casic.module.machine.service;
import cd.casic.framework.commons.pojo.PageResult;
import cd.casic.module.machine.dal.dataobject.SecretKey;
import cd.casic.module.machine.controller.vo.SecretKeyDto;
import com.baomidou.mybatisplus.extension.service.IService;
import cd.casic.module.machine.dal.dataobject.SecretKeyDO;
import cd.casic.module.machine.controller.vo.SecretKeyVO;
import jakarta.validation.Valid;
import java.util.List;
public interface SecretKeyService extends IService<SecretKey> {
boolean addSecretKey(SecretKeyDto secretKeyDto) throws Exception;
public interface SecretKeyService{
Long createSecretKey(@Valid SecretKeyVO secretKeyVO) throws Exception;
void bindingMachine(Long secretKeyId, List<Long> machineInfoIds);
void bindingMachine(Long id, List<Long> machineInfoId);
boolean updateSecretKey(SecretKeyDto secretKeyDto);
void updateSecretKey(@Valid SecretKeyVO secretKeyVO);
PageResult<SecretKey> listSecretKey(SecretKeyDto secretKeyDto);
PageResult<SecretKeyDO> getSecretKeypage(@Valid SecretKeyVO secretKeyVO);
boolean deleteList(List<Long> secretKeyIds);
void deleteSecretKeyList(List<Long> ids);
SecretKeyVO getSecretKey(Long id);
}

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

@ -1,5 +1,4 @@
package cd.casic.module.machine.service.impl;
import cd.casic.module.machine.convert.MachineEnvConvert;
import cd.casic.module.machine.controller.vo.MachineEnvVO;
import cd.casic.module.machine.dal.dataobject.MachineEnvDO;
import cd.casic.module.machine.dal.mysql.MachineEnvMapper;
@ -45,11 +44,8 @@ public class MachineEnvServiceImpl implements MachineEnvService {
@Override
public MachineEnvVO getEnv(Long machineId) {
if (machineId == null) {
return null;
}
MachineEnvDO machineEnvDO = machineEnvMapper.selectById(machineId);
return machineEnvDO != null ? MachineEnvConvert.INSTANCE.convertToVO(machineEnvDO) : null;
MachineEnvDO machineEnvDO = validateMachineEnvExists(machineId);
return BeanUtils.toBean(machineEnvDO, MachineEnvVO.class);
}

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

@ -6,10 +6,7 @@ import cd.casic.module.machine.enums.MachineProxyStatus;
import cd.casic.module.machine.enums.MachineProxyType;
import cd.casic.module.machine.dal.mysql.MachineProxyMapper;
import cd.casic.module.machine.service.MachineProxyService;
import cd.casic.module.machine.utils.EnumUtils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.google.common.annotations.VisibleForTesting;
import jakarta.annotation.Resource;
import cd.casic.framework.commons.util.object.BeanUtils;
@ -19,16 +16,14 @@ import org.springframework.util.CollectionUtils;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import static cd.casic.framework.commons.exception.util.ServiceExceptionUtil.exception;
import static cd.casic.module.machine.contants.MachineErrorCodeConstants.*;
import static com.baomidou.mybatisplus.extension.toolkit.Db.save;
import static org.apache.catalina.security.SecurityUtil.remove;
/**
* 机器代理服务实现类
*/
@Service
@Service("machineProxyService")
public class MachineProxyServiceImpl implements MachineProxyService {
@Resource
private MachineProxyMapper machineProxyMapper;

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

@ -1,354 +1,370 @@
//package cd.casic.module.machine.service.impl;
//import cd.casic.module.machine.enums.MachineInfoType;
//import cd.casic.module.machine.handler.ConnectionSession;
//import cd.casic.module.machine.dal.mysql.MachineInfoMapper;
//import cd.casic.module.machine.controller.vo.MachineInfoDto;
//import cd.casic.module.machine.dal.dataobject.MachineInfo;
//import cd.casic.module.machine.enums.AuthenticationType;
//import cd.casic.module.machine.enums.ConnectionStatus;
//import cd.casic.module.machine.enums.MachineInfoStatus;
//import cd.casic.module.machine.service.MachineInfoService;
//import cd.casic.module.machine.utils.EnumUtils;
//import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
//import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
//import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
//import jakarta.annotation.Resource;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.beans.BeanUtils;
//import org.springframework.stereotype.Service;
//import java.util.Arrays;
//import java.util.HashMap;
//import java.util.List;
//import java.util.Map;
//import java.util.concurrent.ConcurrentHashMap;
//import java.util.concurrent.atomic.AtomicInteger;
//import java.util.stream.Collectors;
//
//@Slf4j
//@Service("machineInfoService")
//public class MachineinfoServiceImpl implements MachineInfoService {
//
// int ENABLE = 1;
// int UN_ENABLE = 0;
//
// @Resource
// private MachineInfoMapper machineInfoMapper;
// @Resource
// private ConnectionSession connectionSession;
// /**
// * 会话ID生成器
// */
// private final AtomicInteger sessionIdGenerator = new AtomicInteger(1000);
//
// /**
// * 会话管理：会话ID -> 连接会话
// */
// private final Map<String, ConnectionSession> sessions = new ConcurrentHashMap<>();
//
// /**
// * 机器名称 -> 会话ID
// */
// private final Map<String, String> machineSessionMapping = new ConcurrentHashMap<>();
//
// @Override
// public boolean addMachineInfo(MachineInfoDto machineInfoDto) {
// if (machineInfoDto == null) {
// throw new ServiceException(ServiceException.MACHINE_INFO_NULL, "机器信息为空");
// }
// MachineInfo machineInfo = new MachineInfo();
// BeanUtils.copyProperties(machineInfoDto, machineInfo);
// machineInfo.setStatusCode(1);
// machineInfo.setAuthenticationTypeCode(
// "密码认证".equals(machineInfoDto.getAuthenticationType())
// ? AuthenticationType.PASSWORD.getCode()
// : AuthenticationType.SECRET_KEY.getCode()
// );
// machineInfo.setMachineInfoTypeCode(
// "Windows".equals(machineInfoDto.getMachineInfoType())
// ? MachineInfoType.WINDOWS.getCode()
// : MachineInfoType.Linux.getCode()
// );
//
// return this.save(machineInfo);
// }
//
// @Override
// public PageResult<MachineInfoDto> listMachineInfo(MachineInfoDto machineInfoDto) {
// QueryWrapper<MachineInfo> queryWrapper = getMachineInfoQueryWrapper(machineInfoDto);
// Page<MachineInfo> page = machineInfoMapper.selectPage(
// new Page<>(machineInfoDto.getPageIndex(), machineInfoDto.getPageSize()),
// queryWrapper
// );
//
// List<MachineInfoDto> machineInfoDtos = page.getRecords().stream()
// .map(machineInfo -> {
// MachineInfoDto dto = new MachineInfoDto();
// BeanUtils.copyProperties(machineInfo, dto);
// // 直接调用原有枚举转换方法
// dto.setMachineInfoType(EnumUtils.getEnumByCode(machineInfo.getMachineInfoTypeCode(), MachineInfoType.class).getMessage());
// dto.setStatus(EnumUtils.getEnumByCode(machineInfo.getStatusCode(), MachineInfoStatus.class).getMessage());
// dto.setAuthenticationType(EnumUtils.getEnumByCode(machineInfo.getAuthenticationTypeCode(), AuthenticationType.class).getMessage());
// return dto;
// })
// .toList();
//
// return new PageResult<>(
// page.getCurrent(),
// page.getSize(),
// page.getTotal(),
// page.getPages(),
// machineInfoDtos
// );
// }
//
// @Override
// public boolean updateMachineInfo(MachineInfoDto machineInfoDto) {
// MachineInfo machineInfo = new MachineInfo();
// BeanUtils.copyProperties(machineInfoDto, machineInfo);
// machineInfo.setAuthenticationTypeCode(
// "密码认证".equals(machineInfoDto.getAuthenticationType())
// ? AuthenticationType.PASSWORD.getCode()
// : AuthenticationType.SECRET_KEY.getCode()
// );
// machineInfo.setMachineInfoTypeCode(
// "Windows".equals(machineInfoDto.getMachineInfoType())
// ? MachineInfoType.WINDOWS.getCode()
// : MachineInfoType.Linux.getCode()
// );
// return this.updateById(machineInfo);
// }
//
// @Override
// public boolean updateStatus(MachineInfoDto machineInfoDto) {
// UpdateWrapper<MachineInfo> updateWrapper = new UpdateWrapper<>();
// updateWrapper.eq("id", machineInfoDto.getId()).set("status_code", EnumUtils.getEnumByMessage(machineInfoDto.getStatus(), MachineInfoStatus.class).getCode());
// return this.update(updateWrapper);
// }
//
// @Override
// public boolean bindingSecretKey(MachineInfoDto machineInfoDto) {
// UpdateWrapper<MachineInfo> updateWrapper = new UpdateWrapper<>();
// updateWrapper.eq("id", machineInfoDto.getId()).set("secret_key_id", machineInfoDto.getSecretKeyId()).set("authentication_type_code", 2);
// return this.update(updateWrapper);
// }
//
// @Override
// public void deleteList(String machineInfoIds) {
// List<Long> machineInfoIdList = Arrays.stream(machineInfoIds.split(","))
// .map(String::trim)
// .filter(s -> !s.isEmpty())
// .map(Long::parseLong)
// .collect(Collectors.toList());
// machineInfoMapper.selectBatchIds(machineInfoIdList).forEach(machineInfo -> {
// if (machineInfo.getStatusCode() == 1) {
// this.removeById(machineInfo.getId());
// }
// });
// }
//
// @Override
// public void deleteMachineInfo(Long machineInfoId) {
// MachineInfo machineInfo = this.getById(machineInfoId);
// if (machineInfo.getStatusCode() == 1) {
// this.removeById(machineInfoId);
// }
// }
//
// private QueryWrapper<MachineInfo> getMachineInfoQueryWrapper(MachineInfoDto machineInfoDto) {
// QueryWrapper<MachineInfo> queryWrapper = new QueryWrapper<>();
// if (machineInfoDto.getStatus() != null && !machineInfoDto.getStatus().isEmpty()) {
// queryWrapper.eq("status_code", EnumUtils.getEnumByMessage(machineInfoDto.getStatus(), MachineInfoStatus.class).getCode());
// }
// if (machineInfoDto.getName() != null && !machineInfoDto.getName().isEmpty()) {
// queryWrapper.like("name", machineInfoDto.getName());
// }
// if (machineInfoDto.getTag() != null && !machineInfoDto.getTag().isEmpty()) {
// queryWrapper.like("tag", machineInfoDto.getTag());
// }
// if (machineInfoDto.getHostIp() != null && !machineInfoDto.getHostIp().isEmpty()) {
// queryWrapper.like("host_ip", machineInfoDto.getHostIp());
// }
// if (machineInfoDto.getDescription() != null && !machineInfoDto.getDescription().isEmpty()) {
// queryWrapper.like("description", machineInfoDto.getDescription());
// }
// return queryWrapper.orderByDesc("create_date");
// }
//
//
// @Override
// public boolean testConnection(Long id) {
// //先查询机器是否存在，在判断机器可用性
// MachineInfo machineInfo = machineInfoMapper.getById(id);
// if (machineInfo==null){
// throw new RuntimeException("机器不存在");
// }
// if (machineInfo.getStatusCode() == 0) {
// throw new RuntimeException("机器不可用");
// }
// log.info("测试机器连接: {}", machineInfo.getHostIp());
// connectionSession.setMachineInfo(machineInfo);
// try{
// connectionSession.connect();
// return true;
// } catch (Exception e) {
// log.error("机器连接测试失败: {}", e.getMessage(), e);
// return false;
// }
// }
//
// @Override
// public ConnectionStatus getConnectionStatus(String machineName) {
// String sessionId = machineSessionMapping.get(machineName);
// if (sessionId == null) {
// return ConnectionStatus.DISCONNECTED;
// }
//
// ConnectionSession session = sessions.get(sessionId);
// return session != null ? session.getStatus() : ConnectionStatus.DISCONNECTED;
// }
//
// @Override
// public Map<String, ConnectionStatus> getAllConnectionStatus() {
// Map<String, ConnectionStatus> result = new HashMap<>();
//
// machineSessionMapping.forEach((machineName, sessionId) -> {
// ConnectionSession session = sessions.get(sessionId);
// result.put(machineName, session != null ? session.getStatus() : ConnectionStatus.DISCONNECTED);
// });
//
// return result;
// }
//
// @Override
// public String connect(MachineInfo machineInfo) {
// if (machineInfo.getStatus().getCode() == UN_ENABLE) {
// throw new RuntimeException("机器不可用");
// }
// log.info("建立机器连接: {}", machineInfo.getHostIp());
//
// // 检查是否已连接
// String existingSessionId = machineSessionMapping.get(machineInfo.getName());
// if (existingSessionId != null) {
// ConnectionSession existingSession = sessions.get(existingSessionId);
// if (existingSession != null && existingSession.getStatus() == ConnectionStatus.CONNECTED) {
// log.info("机器已连接，返回现有会话: {}", machineInfo.getHostIp());
// return existingSessionId;
// }
// }
//
// try {
// connectionSession.setMachineInfo(machineInfo);
//
// connectionSession.connect();
//
// // 生成会话ID
// String sessionId = generateSessionId();
//
// // 保存会话
// sessions.put(sessionId, connectionSession);
// machineSessionMapping.put(machineInfo.getName(), sessionId);
//
// log.info("机器连接成功: {}, 会话ID: {}", machineInfo.getHostIp(), sessionId);
// return sessionId;
// } catch (Exception e) {
// log.error("机器连接失败: {}", e.getMessage(), e);
// throw new RuntimeException("机器连接失败: " + e.getMessage(), e);
// }
// }
//
// @Override
// public boolean disconnect(String sessionId) {
// log.info("断开机器连接: {}", sessionId);
//
// ConnectionSession session = sessions.get(sessionId);
// if (session == null) {
// log.warn("会话不存在: {}", sessionId);
// return false;
// }
//
// try {
// session.disconnect();
//
// // 清理会话
// sessions.remove(sessionId);
// machineSessionMapping.entrySet().removeIf(entry -> entry.getValue().equals(sessionId));
//
// log.info("机器连接已断开: {}", sessionId);
// return true;
// } catch (Exception e) {
// log.error("断开连接失败: {}", e.getMessage(), e);
// return false;
// }
// }
//
// @Override
// public String executeCommand(String sessionId, String command) {
// log.info("执行命令: {}, 会话ID: {}", command, sessionId);
//
// ConnectionSession session = sessions.get(sessionId);
// if (session == null) {
// throw new RuntimeException("会话不存在: " + sessionId);
// }
//
// if (session.getStatus() != ConnectionStatus.CONNECTED) {
// throw new RuntimeException("会话未连接: " + sessionId);
// }
//
// try {
// return session.executeCommand(command);
// } catch (Exception e) {
// log.error("命令执行失败: {}", e.getMessage(), e);
// throw new RuntimeException("命令执行失败: " + e.getMessage(), e);
// }
// }
//
// @Override
// public boolean uploadFile(String sessionId, String localFilePath, String remoteFilePath) {
// log.info("上传文件: {} -> {}, 会话ID: {}", localFilePath, remoteFilePath, sessionId);
//
// ConnectionSession session = sessions.get(sessionId);
// if (session == null) {
// throw new RuntimeException("会话不存在: " + sessionId);
// }
//
// if (session.getStatus() != ConnectionStatus.CONNECTED) {
// throw new RuntimeException("会话未连接: " + sessionId);
// }
//
// try {
// return session.uploadFile(localFilePath, remoteFilePath);
// } catch (Exception e) {
// log.error("文件上传失败: {}", e.getMessage(), e);
// throw new RuntimeException("文件上传失败: " + e.getMessage(), e);
// }
// }
//
// @Override
// public boolean downloadFile(String sessionId, String remoteFilePath, String localFilePath) {
// log.info("下载文件: {} -> {}, 会话ID: {}", remoteFilePath, localFilePath, sessionId);
//
// ConnectionSession session = sessions.get(sessionId);
// if (session == null) {
// throw new RuntimeException("会话不存在: " + sessionId);
// }
//
// if (session.getStatus() != ConnectionStatus.CONNECTED) {
// throw new RuntimeException("会话未连接: " + sessionId);
// }
//
// try {
// return session.downloadFile(remoteFilePath, localFilePath);
// } catch (Exception e) {
// log.error("文件下载失败: {}", e.getMessage(), e);
// throw new RuntimeException("文件下载失败: " + e.getMessage(), e);
// }
// }
//
//
// /**
// * 生成会话ID
// */
// private String generateSessionId() {
// return "session-" + sessionIdGenerator.incrementAndGet();
// }
//}
package cd.casic.module.machine.service.impl;
import cd.casic.framework.commons.pojo.PageResult;
import cd.casic.module.machine.controller.vo.SecretKeyVO;
import cd.casic.module.machine.enums.AuthenticationType;
import cd.casic.module.machine.enums.MachineInfoType;
import cd.casic.module.machine.handler.ConnectionSession;
import cd.casic.module.machine.dal.mysql.MachineInfoMapper;
import cd.casic.module.machine.controller.vo.MachineInfoVO;
import cd.casic.module.machine.dal.dataobject.MachineInfoDO;
import cd.casic.module.machine.enums.ConnectionStatus;
import cd.casic.module.machine.enums.MachineInfoStatus;
import cd.casic.module.machine.service.MachineInfoService;
import cd.casic.module.machine.service.SecretKeyService;
import com.google.common.annotations.VisibleForTesting;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import cd.casic.framework.commons.util.object.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import static cd.casic.framework.commons.exception.util.ServiceExceptionUtil.exception;
import static cd.casic.module.machine.contants.MachineErrorCodeConstants.*;
/**
* 机器信息服务实现类
*/
@Slf4j
@Service("machineInfoService")
public class MachineinfoServiceImpl implements MachineInfoService {
@Resource
private SecretKeyService secretKeyService;
@Resource
private MachineInfoMapper machineInfoMapper;
@Resource
private ConnectionSession connectionSession;
/**
* 会话ID生成器
*/
private final AtomicInteger sessionIdGenerator = new AtomicInteger(1000);
/**
* 会话管理：会话ID -> 连接会话
*/
private final Map<String, ConnectionSession> sessions = new ConcurrentHashMap<>();
/**
* 机器名称 -> 会话ID
*/
private final Map<String, String> machineSessionMapping = new ConcurrentHashMap<>();
@Override
public Long createMachine(MachineInfoVO machineInfoVO) {
validateMachineEnvAdd(machineInfoVO);
validateMachineTagUnique(machineInfoVO.getTag());
MachineInfoDO machineInfoDO = BeanUtils.toBean(machineInfoVO, MachineInfoDO.class);
Long secretKeyId = machineInfoDO.getSecretKeyId();
SecretKeyVO secretKey = secretKeyService.getSecretKey(secretKeyId);
if (secretKey==null){
throw exception(SECRET_KEY_NOT_EXISTS);
}
machineInfoMapper.insert(machineInfoDO);
Long id = machineInfoDO.getId();
return id;
}
@Override
public void updateMachineInfo(MachineInfoVO machineInfoVO) {
validateMachineEnvAdd(machineInfoVO);
String newTag = machineInfoVO.getTag();
MachineInfoDO machineInfoDO = validateMachineInfoExists(machineInfoVO.getId());
String oldTag = machineInfoDO.getTag();
if (!newTag.equals(oldTag)){
validateMachineTagUnique(newTag);
}
BeanUtils.copyProperties(machineInfoVO, machineInfoDO);
machineInfoMapper.updateById(machineInfoDO);
}
@Override
public Integer updateStatus(Long machineInfoId, Integer status) {
machineInfoMapper.updateStatus(machineInfoId, status);
return machineInfoMapper.selectById(machineInfoId).getStatus();
}
@Override
public PageResult<MachineInfoDO> listMachineInfo(MachineInfoVO machineInfoVO) {
return machineInfoMapper.selectPage(machineInfoVO);
}
@Override
public void bindingSecretKey(List<Long> machineInfoId,Long secretKeyId) {
machineInfoMapper.bindingSecretKey(machineInfoId,secretKeyId);
}
@Override
@Transactional//其中一个在线，那么就回滚
public void deleteMachineInfoList(String machineInfoIds) {
List<Long> machineInfoIdList = Arrays.stream(machineInfoIds.split(","))
.map(String::trim)
.filter(s -> !s.isEmpty())
.map(Long::parseLong)
.toList();
machineInfoIdList.forEach(this::deleteMachineInfo);
}
@Override
public void deleteMachineInfo(Long machineInfoId) {
MachineInfoDO machineInfoDO = validateMachineInfoExists(machineInfoId);
validateMachineEnable(machineInfoDO);
machineInfoMapper.deleteById(machineInfoId);
}
@Override
public boolean testConnection(Long id) {
//先查询机器是否存在，在判断机器可用性
MachineInfoDO machineInfoDO = validateMachineInfoExists(id);
validateMachineUnEnable(machineInfoDO);
log.info("测试机器连接: {}", machineInfoDO.getHostIp());
connectionSession.setMachineInfo(machineInfoDO);
try{
connectionSession.connect();
return true;
} catch (Exception e) {
log.error("机器连接测试失败: {}", e.getMessage(), e);
return false;
}
}
@Override
public ConnectionStatus getConnectionStatus(String machineName) {
String sessionId = machineSessionMapping.get(machineName);
if (sessionId == null) {
return ConnectionStatus.DISCONNECTED;
}
ConnectionSession session = sessions.get(sessionId);
return session != null ? session.getStatus() : ConnectionStatus.DISCONNECTED;
}
@Override
public Map<String, ConnectionStatus> getAllConnectionStatus() {
Map<String, ConnectionStatus> result = new HashMap<>();
machineSessionMapping.forEach((machineName, sessionId) -> {
ConnectionSession session = sessions.get(sessionId);
result.put(machineName, session != null ? session.getStatus() : ConnectionStatus.DISCONNECTED);
});
return result;
}
@Override
public String connect(MachineInfoDO machineInfoDO) {
//先查询机器是否存在，在判断机器可用性
validateMachineUnEnable(machineInfoDO);
log.info("建立机器连接: {}", machineInfoDO.getHostIp());
// 检查是否已连接
String existingSessionId = machineSessionMapping.get(machineInfoDO.getName());
if (existingSessionId != null) {
ConnectionSession existingSession = sessions.get(existingSessionId);
if (existingSession != null && existingSession.getStatus() == ConnectionStatus.CONNECTED) {
log.info("机器已连接，返回现有会话: {}", machineInfoDO.getHostIp());
return existingSessionId;
}
}
try {
connectionSession.setMachineInfo(machineInfoDO);
connectionSession.connect();
// 生成会话ID
String sessionId = generateSessionId();
// 保存会话
sessions.put(sessionId, connectionSession);
machineSessionMapping.put(machineInfoDO.getName(), sessionId);
log.info("机器连接成功: {}, 会话ID: {}", machineInfoDO.getHostIp(), sessionId);
return sessionId;
} catch (Exception e) {
log.error("机器连接失败: {}", e.getMessage(), e);
throw new RuntimeException("机器连接失败: " + e.getMessage(), e);
}
}
@Override
public boolean disconnect(String sessionId) {
log.info("断开机器连接: {}", sessionId);
ConnectionSession session = sessions.get(sessionId);
if (session == null) {
log.warn("会话不存在: {}", sessionId);
return false;
}
try {
session.disconnect();
// 清理会话
sessions.remove(sessionId);
machineSessionMapping.entrySet().removeIf(entry -> entry.getValue().equals(sessionId));
log.info("机器连接已断开: {}", sessionId);
return true;
} catch (Exception e) {
log.error("断开连接失败: {}", e.getMessage(), e);
return false;
}
}
@Override
public String executeCommand(String sessionId, String command) {
log.info("执行命令: {}, 会话ID: {}", command, sessionId);
ConnectionSession session = sessions.get(sessionId);
if (session == null) {
throw new RuntimeException("会话不存在: " + sessionId);
}
if (session.getStatus() != ConnectionStatus.CONNECTED) {
throw new RuntimeException("会话未连接: " + sessionId);
}
try {
return session.executeCommand(command);
} catch (Exception e) {
log.error("命令执行失败: {}", e.getMessage(), e);
throw new RuntimeException("命令执行失败: " + e.getMessage(), e);
}
}
@Override
public boolean uploadFile(String sessionId, String localFilePath, String remoteFilePath) {
log.info("上传文件: {} -> {}, 会话ID: {}", localFilePath, remoteFilePath, sessionId);
ConnectionSession session = sessions.get(sessionId);
if (session == null) {
throw new RuntimeException("会话不存在: " + sessionId);
}
if (session.getStatus() != ConnectionStatus.CONNECTED) {
throw new RuntimeException("会话未连接: " + sessionId);
}
try {
return session.uploadFile(localFilePath, remoteFilePath);
} catch (Exception e) {
log.error("文件上传失败: {}", e.getMessage(), e);
throw new RuntimeException("文件上传失败: " + e.getMessage(), e);
}
}
@Override
public boolean downloadFile(String sessionId, String remoteFilePath, String localFilePath) {
log.info("下载文件: {} -> {}, 会话ID: {}", remoteFilePath, localFilePath, sessionId);
ConnectionSession session = sessions.get(sessionId);
if (session == null) {
throw new RuntimeException("会话不存在: " + sessionId);
}
if (session.getStatus() != ConnectionStatus.CONNECTED) {
throw new RuntimeException("会话未连接: " + sessionId);
}
try {
return session.downloadFile(remoteFilePath, localFilePath);
} catch (Exception e) {
log.error("文件下载失败: {}", e.getMessage(), e);
throw new RuntimeException("文件下载失败: " + e.getMessage(), e);
}
}
@Override
public void unBindingSecretKey(List<Long> SecretKeyIds) {
machineInfoMapper.unBindingSecretKey(SecretKeyIds);
}
@VisibleForTesting
void validateMachineEnvAdd(MachineInfoVO machineInfoVO) {
if (machineInfoVO.getHostIp().isEmpty()) {
throw exception(MACHINE_INFO_HOST_IP_NULL);
}
if (machineInfoVO.getUsername().isEmpty()){
throw exception(MACHINE_INFO_USER_NAME_NULL);
}
if(machineInfoVO.getTag().isEmpty()){
throw exception(MACHINE_INFO_TAG_NULL);
}
if (machineInfoVO.getAuthenticationType()!=null){
boolean flag=true;
for (int type : AuthenticationType.ARRAYS) {
if (type == machineInfoVO.getAuthenticationType()) {
flag=false;
break;
}
if (flag){
throw exception(MACHINE_INFO_AUTHENTICATION_TYPE_NOT_EXISTS);
}
}
}else {
throw exception(MACHINE_INFO_AUTHENTICATION_TYPE_NULL);
}
if (machineInfoVO.getMachineInfoType()!= null){
boolean flag = true;
for (int type : MachineInfoType.ARRAYS) {
if (type == machineInfoVO.getMachineInfoType()) {
flag=false;
break;
}
}
if (flag) {
throw exception(MACHINE_INFO_TYPE_NOT_EXISTS);
}
}else {
throw exception(MACHINE_INFO_TYPE_NULL);
}
}
@VisibleForTesting
void validateMachineTagUnique(String tag){
if (machineInfoMapper.existsByTag(tag)) {
throw exception(MACHINE_INFO_TAG_EXISTS);
}
}
@VisibleForTesting
MachineInfoDO validateMachineInfoExists(Long id) {
if (id == null) {
return null;
}
MachineInfoDO machineInfoDO = machineInfoMapper.selectById(id);
if (machineInfoDO == null) {
throw exception(MACHINE_INFO_NULL);
}
return machineInfoDO;
}
@VisibleForTesting
void validateMachineEnable(MachineInfoDO machineInfoDO) {
if (machineInfoDO.getStatus()==MachineInfoStatus.ENABLE.getCode()){
throw exception(MACHINE_ENABLE);
}
}
@VisibleForTesting
void validateMachineUnEnable(MachineInfoDO machineInfoDO) {
if (machineInfoDO.getStatus()==MachineInfoStatus.UN_ENABLE.getCode()){
throw exception(MACHINE_UN_ENABLE);
}
}
/**
* 生成会话ID
*/
private String generateSessionId() {
return "session-" + sessionIdGenerator.incrementAndGet();
}
}

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

@ -1,159 +1,157 @@
//package cd.casic.module.machine.service.impl;
//
//import cd.casic.module.machine.controller.vo.SecretKeyDto;
//import cd.casic.module.machine.dal.dataobject.MachineInfo;
//import cd.casic.module.machine.dal.dataobject.SecretKey;
//import cd.casic.module.machine.dal.mysql.SecretServiceMapper;
//import cd.casic.module.machine.service.MachineInfoService;
//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.SecretKeyService;
//import jakarta.annotation.Resource;
//import org.springframework.beans.BeanUtils;
//import org.springframework.stereotype.Service;
//
//import java.util.List;
//
//@Service
//public class SecretKeyServiceImpl extends ServiceImpl<SecretServiceMapper, SecretKey> implements SecretKeyService {
//
// @Resource
// private MachineInfoService machineInfoService;
//
// @Resource
// private AliYunOssClient aliYunOssClient;
//
// @Resource
// private SecretServiceMapper secretServiceMapper;
//
//
//
//
// @Override
// public boolean addSecretKey(SecretKeyDto secretKeyDto){
// if (secretKeyDto.getPath()==null)
// {
// throw new ServiceException(ServiceException.MACHINE_PROXY_NULL,"密钥不能为空");
// }
//
// String ossPath = upLoadSecretKey(secretKeyDto.getPath());
// if (ossPath == null){
// throw new ServiceException(ServiceException.MACHINE_PROXY_NULL,"密钥上传失败");
// }
// secretKeyDto.setPath(ossPath);
// SecretKey secretKey = new SecretKey();
// BeanUtils.copyProperties(secretKeyDto,secretKey);
// //todo检查密钥合法
// return this.save(secretKey);
//
//
// }
// @Override
// public boolean updateSecretKey(SecretKeyDto secretKeyDto) {
//
// Long id = secretKeyDto.getId();
// SecretKey secretKey = this.getById(id);
// if (secretKey == null){
// throw new ServiceException(ServiceException.MACHINE_PROXY_NULL,"密钥不存在");
// }
// if (!secretKey.getPath().equals(secretKeyDto.getPath())) {
// //todo检查密钥合法
// String ossPath = upLoadSecretKey(secretKeyDto.getPath());
// BeanUtils.copyProperties(secretKeyDto,secretKey);
// secretKey.setPath(ossPath);
// }
// else {
// BeanUtils.copyProperties(secretKeyDto,secretKey);
// }
//
// return this.updateById(secretKey);
//
//
// }
//
// @Override
// public void bindingMachine(Long secretKeyId, List<Long> machineIds) {
// SecretKey secretKey = this.getById(secretKeyId);
// if (secretKey==null){
// throw new ServiceException(ServiceException.SECRETKEY_NULL,"密钥不存在");
// }
// List<MachineInfo> machineList = machineInfoService.listByIds(machineIds);
// machineList.forEach(machine -> machine.setSecretKeyId(secretKeyId));
// machineInfoService.updateBatchById(machineList);
// }
//
//
//
//
//
// @Override
// public PageResult<SecretKey> listSecretKey(SecretKeyDto secretKeyDto) {
// QueryWrapper<SecretKey> queryWrapper = new QueryWrapper<>();
// 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);
// return new PageResult<>(
// page.getCurrent(),
// page.getSize(),
// page.getTotal(),
// page.getPages(),
// page.getRecords()
// );
// }
//
//
//
// @Override
// public boolean deleteList(List<Long> secretKeyIds) {
// List<SecretKey> secretKeys = this.listByIds(secretKeyIds);
//
// for (SecretKey secretKey : secretKeys) {
// if (secretKey.getPath() != null && !secretKey.getPath().isEmpty()){
// try {
// //文件名
// //删除子目录文件，需要在前面加上根目录文件路径
// String fileName = secretKey.getPath().substring(secretKey.getPath().lastIndexOf("/") + 1);
// aliYunOssClient.delete(fileName);
// } catch (Exception e) {
// throw new RuntimeException(e);
// }
// }
// }
//
//
// //todo是否删除已经绑定的机器
// return secretServiceMapper.deleteBatchIds(secretKeyIds) > 0 ;
// }
//
//
// public String upLoadSecretKey(String localPath) {
//
// //使用S3FileClient上传文件
// aliYunOssClient.init();
//
// //传输到指定文件，需要在path前面加上文件路径
// String path = IdUtil.fastSimpleUUID() + ".txt";
//
//
// //上传文件是从本地上传，这里传的是本地文件地址
// byte[] content = ResourceUtil.readBytes(localPath);
// String ossPath;
// try {
// ossPath = aliYunOssClient.upload(content, path, "txt");
// }catch (Exception e) {
// throw new RuntimeException(e+"上传文件失败");
// }
// return ossPath;
// }
//}
package cd.casic.module.machine.service.impl;
import cd.casic.framework.commons.pojo.PageResult;
import cd.casic.framework.commons.util.object.BeanUtils;
import cd.casic.module.machine.controller.vo.SecretKeyVO;
import cd.casic.module.machine.dal.dataobject.SecretKeyDO;
import cd.casic.module.machine.dal.mysql.SecretKeyMapper;
import cd.casic.module.machine.service.MachineInfoService;
import cn.hutool.core.io.resource.ResourceUtil;
import cn.hutool.core.util.IdUtil;
import cd.casic.module.machine.utils.AliYunOssClient;
import cd.casic.module.machine.service.SecretKeyService;
import com.google.common.annotations.VisibleForTesting;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import static cd.casic.framework.commons.exception.util.ServiceExceptionUtil.exception;
import static cd.casic.module.machine.contants.MachineErrorCodeConstants.*;
/**
* 密钥服务实现类
*/
@Service("secretKeyService")
public class SecretKeyServiceImpl implements SecretKeyService {
@Resource
private MachineInfoService machineInfoService;
@Resource
private AliYunOssClient aliYunOssClient;
@Resource
private SecretKeyMapper secretKeyMapper;
@Override
public SecretKeyVO getSecretKey(Long id){
SecretKeyDO secretKeyDO = validateSecretKeyExists(id);
return BeanUtils.toBean(secretKeyDO, SecretKeyVO.class);
}
@Override
public Long createSecretKey(SecretKeyVO secretKeyVO){
validateSecretKeyAdd(secretKeyVO);
String ossPath = upLoadSecretKey(secretKeyVO.getPath());
//检查得到的oss路径是否为空
validateSecretKeyPath(ossPath);
secretKeyVO.setPath(ossPath);
SecretKeyDO secretKeyDO = BeanUtils.toBean(secretKeyVO, SecretKeyDO.class);
//todo检查密钥合法
secretKeyMapper.insert(secretKeyDO);
return secretKeyDO.getId();
}
@Override
public void updateSecretKey(SecretKeyVO secretKeyVO) {
SecretKeyDO secretKeyDO = validateSecretKeyExists(secretKeyVO.getId());
//如果路径改变==改变密钥
if (!secretKeyDO.getPath().equals(secretKeyVO.getPath())) {
//todo检查密钥合法
String ossPath = upLoadSecretKey(secretKeyVO.getPath());
BeanUtils.copyProperties(secretKeyVO, secretKeyDO);
secretKeyDO.setPath(ossPath);
}
else {
BeanUtils.copyProperties(secretKeyVO,secretKeyDO);
}
secretKeyMapper.updateById(secretKeyDO);
}
@Override
public void bindingMachine(Long id,List<Long> machineInfoIds) {
validateSecretKeyExists(id);
machineInfoService.bindingSecretKey(machineInfoIds, id);
}
@Override
@Transactional
public void deleteSecretKeyList(List<Long> ids) {
ids.forEach(
secretKeyId -> {
SecretKeyDO secretKeyDO = validateSecretKeyExists(secretKeyId);
if (secretKeyDO.getPath() != null && !secretKeyDO.getPath().isEmpty()){
try {
//文件名
//删除子目录文件，需要在前面加上根目录文件路径
String fileName = secretKeyDO.getPath().substring(secretKeyDO.getPath().lastIndexOf("/") + 1);
aliYunOssClient.delete(fileName);
} catch (Exception e) {
throw exception(DELETE_FILE_FAIL);
}
}
}
);
//绑定的机器全部设置为空
machineInfoService.unBindingSecretKey(ids);
secretKeyMapper.deleteBatchIds(ids);
}
@Override
public PageResult<SecretKeyDO> getSecretKeypage(SecretKeyVO secretKeyVO) {
return secretKeyMapper.selectPage(secretKeyVO);
}
public String upLoadSecretKey(String localPath) {
//使用S3FileClient上传文件
aliYunOssClient.init();
//传输到指定文件，需要在path前面加上文件路径
String path = IdUtil.fastSimpleUUID() + ".txt";
//上传文件是从本地上传，这里传的是本地文件地址
byte[] content = ResourceUtil.readBytes(localPath);
String ossPath;
try {
ossPath = aliYunOssClient.upload(content, path, "txt");
}catch (Exception e) {
throw exception(UPLOADING_FILE_FAIL);
}
return ossPath;
}
@VisibleForTesting
void validateSecretKeyAdd(SecretKeyVO secretKeyVO) {
if (secretKeyVO==null) {
throw exception(SECRET_KEY_NULL);
}
if (secretKeyVO.getPath().isEmpty()) {
throw exception(SECRET_KEY_PATH_NULL);
}
}
@VisibleForTesting
void validateSecretKeyPath(String path) {
if (path.isEmpty()) {
throw exception(SECRET_KEY_PATH_NULL);
}
}
@VisibleForTesting
SecretKeyDO validateSecretKeyExists(Long id) {
if (id == null) {
return null;
}
SecretKeyDO secretKeyDO = secretKeyMapper.selectById(id);
if (secretKeyDO == null) {
throw exception(SECRET_KEY_NOT_EXISTS);
}
return secretKeyDO;
}
}