manager/c-api
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

API数据表更新

Browse Source
This commit is contained in:
gaoxq
2025-08-31 19:23:19 +08:00
parent 42dfc7e806
commit 2c04361feb
20 changed files with 4151 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/main/java/com/mini/capi/biz/controller/SshServersController.java Normal file
View File

@@ -0,0 +1,18 @@
package com.mini.capi.biz.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 前端控制器
* </p>
*
* @author gaoxq
* @since 2025-08-31
*/
@RestController
@RequestMapping("/biz/sshServers")
public class SshServersController {
}

99
src/main/java/com/mini/capi/biz/domain/SshServers.java Normal file
View File

@@ -0,0 +1,99 @@
package com.mini.capi.biz.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
*
* </p>
*
* @author gaoxq
* @since 2025-08-31
*/
@Getter
@Setter
@TableName("biz_ssh_servers")
public class SshServers implements Serializable {
private static final long serialVersionUID = 1L;
@TableField("create_time")
private LocalDateTime createTime;
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 服务器名称
*/
@TableField("name")
private String name;
/**
* 服务器地址
*/
@TableField("host")
private String host;
/**
* SSH端口
*/
@TableField("port")
private Integer port;
/**
* 用户名
*/
@TableField("username")
private String username;
/**
* 密码（建议加密存储）
*/
@TableField("password")
private String password;
@TableField("update_time")
private LocalDateTime updateTime;
/**
* 租户id
*/
@TableField("f_tenant_id")
private String fTenantId;
/**
* 流程id
*/
@TableField("f_flow_id")
private String fFlowId;
/**
* 流程任务主键
*/
@TableField("f_flow_task_id")
private String fFlowTaskId;
/**
* 流程任务状态
*/
@TableField("f_flow_state")
private Integer fFlowState;
public SshServers(String name, String host, Integer port, String username, String password){
this.name = name;
this.host = host;
this.port = port;
this.username = username;
this.password = password;
}
}

16
src/main/java/com/mini/capi/biz/mapper/SshServersMapper.java Normal file
View File

@@ -0,0 +1,16 @@
package com.mini.capi.biz.mapper;
import com.mini.capi.biz.domain.SshServers;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* Mapper 接口
* </p>
*
* @author gaoxq
* @since 2025-08-31
*/
public interface SshServersMapper extends BaseMapper<SshServers> {
}

16
src/main/java/com/mini/capi/biz/service/SshServersService.java Normal file
View File

@@ -0,0 +1,16 @@
package com.mini.capi.biz.service;
import com.mini.capi.biz.domain.SshServers;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 服务类
* </p>
*
* @author gaoxq
* @since 2025-08-31
*/
public interface SshServersService extends IService<SshServers> {
}

20
src/main/java/com/mini/capi/biz/service/impl/SshServersServiceImpl.java Normal file
View File

@@ -0,0 +1,20 @@
package com.mini.capi.biz.service.impl;
import com.mini.capi.biz.domain.SshServers;
import com.mini.capi.biz.mapper.SshServersMapper;
import com.mini.capi.biz.service.SshServersService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 服务实现类
* </p>
*
* @author gaoxq
* @since 2025-08-31
*/
@Service
public class SshServersServiceImpl extends ServiceImpl<SshServersMapper, SshServers> implements SshServersService {
}

2
src/main/java/com/mini/capi/mybatis/demo.java
View File

@@ -29,7 +29,7 @@ public class demo {
.pathInfo(Collections.singletonMap(OutputFile.xml, System.getProperty("user.dir") + "/src/main/resources/mapper"));
})
.strategyConfig(builder -> {
builder.addInclude("biz_sync_tables_view")
builder.addInclude("biz_ssh_servers")
.addTablePrefix("biz_")
.entityBuilder()
.enableLombok()

19
src/main/java/com/mini/capi/sys/controller/hostController.java Normal file
View File

@@ -0,0 +1,19 @@
package com.mini.capi.sys.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
@Controller
public class hostController {
/**
* 主机登录
*
* @return
*/
@GetMapping("/Sys/app/host")
public String listPage() {
return "views/ssh/index";
}
}

22
src/main/java/com/mini/capi/webssh/config/WebSocketConfig.java Normal file
View File

@@ -0,0 +1,22 @@
package com.mini.capi.webssh.config;
import com.mini.capi.webssh.websocket.SSHWebSocketHandler;
import jakarta.annotation.Resource;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
@Resource
private SSHWebSocketHandler sshWebSocketHandler;
@Override
public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
registry.addHandler(sshWebSocketHandler, "/ssh")
.setAllowedOriginPatterns("*"); // 生产环境中应该限制域名
}
}

253
src/main/java/com/mini/capi/webssh/controller/FileTransferController.java Normal file
View File

@@ -0,0 +1,253 @@
package com.mini.capi.webssh.controller;
import com.mini.capi.biz.domain.SshServers;
import com.mini.capi.biz.service.SshServersService;
import com.mini.capi.webssh.service.FileTransferService;
import jakarta.annotation.Resource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.util.List;
import java.util.Map;
import java.util.Optional;
@RestController
@RequestMapping("/api/files")
public class FileTransferController {
@Resource
private FileTransferService fileTransferService;
@Resource
private SshServersService serverService;
/**
* 上传文件到服务器
*/
@PostMapping("/upload/{serverId}")
public ResponseEntity<Map<String, Object>> uploadFile(
@PathVariable Long serverId,
@RequestParam("file") MultipartFile file,
@RequestParam("remotePath") String remotePath) {
try {
Optional<SshServers> serverOpt = serverService.getOptById(serverId);
if (!serverOpt.isPresent()) {
return ResponseEntity.badRequest()
.body(Map.of("success", false, "message", "服务器不存在"));
}
if (file.isEmpty()) {
return ResponseEntity.badRequest()
.body(Map.of("success", false, "message", "文件不能为空"));
}
fileTransferService.uploadFile(serverOpt.get(), file, remotePath);
return ResponseEntity.ok(Map.of(
"success", true,
"message", "文件上传成功",
"filename", file.getOriginalFilename(),
"size", file.getSize()
));
} catch (Exception e) {
return ResponseEntity.badRequest()
.body(Map.of("success", false, "message", "上传失败: " + e.getMessage()));
}
}
/**
* 批量上传文件
*/
@PostMapping("/upload-batch/{serverId}")
public ResponseEntity<Map<String, Object>> uploadFiles(
@PathVariable Long serverId,
@RequestParam("files") MultipartFile[] files,
@RequestParam("remotePath") String remotePath) {
try {
Optional<SshServers> serverOpt = serverService.getOptById(serverId);
if (!serverOpt.isPresent()) {
return ResponseEntity.badRequest()
.body(Map.of("success", false, "message", "服务器不存在"));
}
if (files == null || files.length == 0) {
return ResponseEntity.badRequest()
.body(Map.of("success", false, "message", "请选择要上传的文件"));
}
fileTransferService.uploadFiles(serverOpt.get(), files, remotePath);
return ResponseEntity.ok(Map.of(
"success", true,
"message", "批量上传成功",
"count", files.length
));
} catch (Exception e) {
return ResponseEntity.badRequest()
.body(Map.of("success", false, "message", "批量上传失败: " + e.getMessage()));
}
}
/**
* 从服务器下载文件
*/
@GetMapping("/download/{serverId}")
public ResponseEntity<byte[]> downloadFile(
@PathVariable Long serverId,
@RequestParam("remoteFilePath") String remoteFilePath) {
try {
Optional<SshServers> serverOpt = serverService.getOptById(serverId);
if (!serverOpt.isPresent()) {
return ResponseEntity.badRequest().build();
}
byte[] fileContent = fileTransferService.downloadFile(serverOpt.get(), remoteFilePath);
// 从路径中提取文件名
String filename = remoteFilePath.substring(remoteFilePath.lastIndexOf('/') + 1);
return ResponseEntity.ok()
.header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + filename + "\"")
.contentType(MediaType.APPLICATION_OCTET_STREAM)
.body(fileContent);
} catch (Exception e) {
return ResponseEntity.badRequest().build();
}
}
/**
* 列出远程目录内容
*/
@GetMapping("/list/{serverId}")
public ResponseEntity<Map<String, Object>> listDirectory(
@PathVariable Long serverId,
@RequestParam("remotePath") String remotePath) {
try {
Optional<SshServers> serverOpt = serverService.getOptById(serverId);
if (!serverOpt.isPresent()) {
return ResponseEntity.badRequest()
.body(Map.of("success", false, "message", "服务器不存在"));
}
List<FileTransferService.FileInfo> files =
fileTransferService.listDirectory(serverOpt.get(), remotePath);
return ResponseEntity.ok(Map.of(
"success", true,
"files", files,
"path", remotePath
));
} catch (Exception e) {
return ResponseEntity.badRequest()
.body(Map.of("success", false, "message", "获取目录列表失败: " + e.getMessage()));
}
}
/**
* 创建远程目录
*/
@PostMapping("/mkdir/{serverId}")
public ResponseEntity<Map<String, Object>> createDirectory(
@PathVariable Long serverId,
@RequestBody Map<String, String> request) {
try {
Optional<SshServers> serverOpt = serverService.getOptById(serverId);
if (!serverOpt.isPresent()) {
return ResponseEntity.badRequest()
.body(Map.of("success", false, "message", "服务器不存在"));
}
String remotePath = request.get("remotePath");
if (remotePath == null || remotePath.trim().isEmpty()) {
return ResponseEntity.badRequest()
.body(Map.of("success", false, "message", "目录路径不能为空"));
}
fileTransferService.createRemoteDirectory(serverOpt.get(), remotePath);
return ResponseEntity.ok(Map.of(
"success", true,
"message", "目录创建成功",
"path", remotePath
));
} catch (Exception e) {
return ResponseEntity.badRequest()
.body(Map.of("success", false, "message", "创建目录失败: " + e.getMessage()));
}
}
/**
* 删除远程文件或目录
*/
@DeleteMapping("/delete/{serverId}")
public ResponseEntity<Map<String, Object>> deleteFile(
@PathVariable Long serverId,
@RequestParam("remotePath") String remotePath,
@RequestParam(value = "isDirectory", defaultValue = "false") boolean isDirectory) {
try {
Optional<SshServers> serverOpt = serverService.getOptById(serverId);
if (!serverOpt.isPresent()) {
return ResponseEntity.badRequest()
.body(Map.of("success", false, "message", "服务器不存在"));
}
fileTransferService.deleteRemoteFile(serverOpt.get(), remotePath, isDirectory);
return ResponseEntity.ok(Map.of(
"success", true,
"message", (isDirectory ? "目录" : "文件") + "删除成功",
"path", remotePath
));
} catch (Exception e) {
return ResponseEntity.badRequest()
.body(Map.of("success", false, "message", "删除失败: " + e.getMessage()));
}
}
/**
* 重命名远程文件
*/
@PostMapping("/rename/{serverId}")
public ResponseEntity<Map<String, Object>> renameFile(
@PathVariable Long serverId,
@RequestBody Map<String, String> request) {
try {
Optional<SshServers> serverOpt = serverService.getOptById(serverId);
if (!serverOpt.isPresent()) {
return ResponseEntity.badRequest()
.body(Map.of("success", false, "message", "服务器不存在"));
}
String oldPath = request.get("oldPath");
String newPath = request.get("newPath");
if (oldPath == null || newPath == null || oldPath.trim().isEmpty() || newPath.trim().isEmpty()) {
return ResponseEntity.badRequest()
.body(Map.of("success", false, "message", "路径不能为空"));
}
fileTransferService.renameRemoteFile(serverOpt.get(), oldPath, newPath);
return ResponseEntity.ok(Map.of(
"success", true,
"message", "重命名成功",
"oldPath", oldPath,
"newPath", newPath
));
} catch (Exception e) {
return ResponseEntity.badRequest()
.body(Map.of("success", false, "message", "重命名失败: " + e.getMessage()));
}
}
}

127
src/main/java/com/mini/capi/webssh/controller/ServerController.java Normal file
View File

@@ -0,0 +1,127 @@
package com.mini.capi.webssh.controller;
import com.mini.capi.biz.domain.SshServers;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.Session;
import com.mini.capi.biz.service.SshServersService;
import jakarta.annotation.Resource;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
import java.util.Optional;
@RestController
@RequestMapping("/api/servers")
public class ServerController {
@Resource
private SshServersService serverService;
/**
* 获取服务器列表
*/
@GetMapping
public ResponseEntity<List<SshServers>> getServers() {
List<SshServers> servers = serverService.list();
return ResponseEntity.ok(servers);
}
/**
* 获取单个服务器配置
*/
@GetMapping("/{id}")
public ResponseEntity<SshServers> getServer(@PathVariable Long id) {
try {
Optional<SshServers> server = serverService.getOptById(id);
if (server.isPresent()) {
return ResponseEntity.ok(server.get());
} else {
return ResponseEntity.notFound().build();
}
} catch (Exception e) {
return ResponseEntity.badRequest().build();
}
}
/**
* 添加服务器
*/
@PostMapping
public ResponseEntity<Map<String, Object>> addServer(@RequestBody SshServers server) {
try {
// 验证必要参数
if (server.getHost() == null || server.getHost().trim().isEmpty()) {
return ResponseEntity.badRequest().body(Map.of("success", false, "message", "服务器地址不能为空"));
}
if (server.getUsername() == null || server.getUsername().trim().isEmpty()) {
return ResponseEntity.badRequest().body(Map.of("success", false, "message", "用户名不能为空"));
}
if (server.getPassword() == null || server.getPassword().trim().isEmpty()) {
return ResponseEntity.badRequest().body(Map.of("success", false, "message", "密码不能为空"));
}
// 设置默认值
if (server.getPort() == null) {
server.setPort(22);
}
if (server.getName() == null || server.getName().trim().isEmpty()) {
server.setName(server.getUsername() + "@" + server.getHost());
}
serverService.save(server);
return ResponseEntity.ok(Map.of("success", true));
} catch (Exception e) {
return ResponseEntity.badRequest()
.body(Map.of("success", false, "message", e.getMessage()));
}
}
/**
* 删除服务器
*/
@DeleteMapping("/{id}")
public ResponseEntity<Map<String, Object>> deleteServer(@PathVariable Long id) {
try {
serverService.removeById(id);
return ResponseEntity.ok(Map.of("success", true));
} catch (Exception e) {
return ResponseEntity.badRequest()
.body(Map.of("success", false, "message", e.getMessage()));
}
}
/**
* 测试服务器连接
*/
@PostMapping("/test")
public ResponseEntity<Map<String, Object>> testConnection(@RequestBody SshServers server) {
try {
// 验证必要参数
if (server.getHost() == null || server.getHost().trim().isEmpty()) {
return ResponseEntity.badRequest().body(Map.of("success", false, "message", "服务器地址不能为空"));
}
if (server.getUsername() == null || server.getUsername().trim().isEmpty()) {
return ResponseEntity.badRequest().body(Map.of("success", false, "message", "用户名不能为空"));
}
if (server.getPassword() == null || server.getPassword().trim().isEmpty()) {
return ResponseEntity.badRequest().body(Map.of("success", false, "message", "密码不能为空"));
}
// 设置默认端口
int port = server.getPort() != null ? server.getPort() : 22;
// 简单的连接测试
JSch jsch = new JSch();
Session session = jsch.getSession(server.getUsername(), server.getHost(), port);
session.setPassword(server.getPassword());
session.setConfig("StrictHostKeyChecking", "no");
session.connect(5000); // 5秒超时
session.disconnect();
return ResponseEntity.ok(Map.of("success", true, "message", "连接测试成功"));
} catch (Exception e) {
return ResponseEntity.ok(Map.of("success", false, "message", "连接测试失败: " + e.getMessage()));
}
}
}

301
src/main/java/com/mini/capi/webssh/service/FileTransferService.java Normal file
View File

@@ -0,0 +1,301 @@
package com.mini.capi.webssh.service;
import com.jcraft.jsch.*;
import com.mini.capi.biz.domain.SshServers;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.Vector;
@Service
@Slf4j
public class FileTransferService {
/**
* 上传文件到远程服务器
*/
public void uploadFile(SshServers server, MultipartFile file, String remotePath) throws Exception {
Session session = null;
ChannelSftp sftpChannel = null;
try {
session = createSession(server);
sftpChannel = (ChannelSftp) session.openChannel("sftp");
sftpChannel.connect();
// 确保远程目录存在
createRemoteDirectory(sftpChannel, remotePath);
// 上传文件
String remoteFilePath = remotePath + "/" + file.getOriginalFilename();
try (InputStream inputStream = file.getInputStream()) {
sftpChannel.put(inputStream, remoteFilePath);
}
log.info("文件上传成功: {} -> {}", file.getOriginalFilename(), remoteFilePath);
} finally {
closeConnections(sftpChannel, session);
}
}
/**
* 从远程服务器下载文件
*/
public byte[] downloadFile(SshServers server, String remoteFilePath) throws Exception {
Session session = null;
ChannelSftp sftpChannel = null;
try {
session = createSession(server);
sftpChannel = (ChannelSftp) session.openChannel("sftp");
sftpChannel.connect();
try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
InputStream inputStream = sftpChannel.get(remoteFilePath)) {
byte[] buffer = new byte[8192];
int bytesRead;
while ((bytesRead = inputStream.read(buffer)) != -1) {
outputStream.write(buffer, 0, bytesRead);
}
log.info("文件下载成功: {}", remoteFilePath);
return outputStream.toByteArray();
}
} finally {
closeConnections(sftpChannel, session);
}
}
/**
* 列出远程目录内容
*/
@SuppressWarnings("unchecked")
public List<FileInfo> listDirectory(SshServers server, String remotePath) throws Exception {
Session session = null;
ChannelSftp sftpChannel = null;
List<FileInfo> files = new ArrayList<>();
try {
session = createSession(server);
sftpChannel = (ChannelSftp) session.openChannel("sftp");
sftpChannel.connect();
Vector<ChannelSftp.LsEntry> entries = sftpChannel.ls(remotePath);
for (ChannelSftp.LsEntry entry : entries) {
String filename = entry.getFilename();
if (!filename.equals(".") && !filename.equals("..")) {
SftpATTRS attrs = entry.getAttrs();
files.add(new FileInfo(
filename,
attrs.isDir(),
attrs.getSize(),
attrs.getMTime() * 1000L, // Convert to milliseconds
getPermissionString(attrs.getPermissions())
));
}
}
log.info("目录列表获取成功: {}, 文件数: {}", remotePath, files.size());
return files;
} finally {
closeConnections(sftpChannel, session);
}
}
/**
* 创建远程目录
*/
public void createRemoteDirectory(SshServers server, String remotePath) throws Exception {
Session session = null;
ChannelSftp sftpChannel = null;
try {
session = createSession(server);
sftpChannel = (ChannelSftp) session.openChannel("sftp");
sftpChannel.connect();
createRemoteDirectory(sftpChannel, remotePath);
log.info("远程目录创建成功: {}", remotePath);
} finally {
closeConnections(sftpChannel, session);
}
}
/**
* 删除远程文件或目录
*/
public void deleteRemoteFile(SshServers server, String remotePath, boolean isDirectory) throws Exception {
Session session = null;
ChannelSftp sftpChannel = null;
try {
session = createSession(server);
sftpChannel = (ChannelSftp) session.openChannel("sftp");
sftpChannel.connect();
if (isDirectory) {
sftpChannel.rmdir(remotePath);
} else {
sftpChannel.rm(remotePath);
}
log.info("远程文件删除成功: {}", remotePath);
} finally {
closeConnections(sftpChannel, session);
}
}
/**
* 重命名远程文件
*/
public void renameRemoteFile(SshServers server, String oldPath, String newPath) throws Exception {
Session session = null;
ChannelSftp sftpChannel = null;
try {
session = createSession(server);
sftpChannel = (ChannelSftp) session.openChannel("sftp");
sftpChannel.connect();
sftpChannel.rename(oldPath, newPath);
log.info("文件重命名成功: {} -> {}", oldPath, newPath);
} finally {
closeConnections(sftpChannel, session);
}
}
/**
* 批量上传文件
*/
public void uploadFiles(SshServers server, MultipartFile[] files, String remotePath) throws Exception {
Session session = null;
ChannelSftp sftpChannel = null;
try {
session = createSession(server);
sftpChannel = (ChannelSftp) session.openChannel("sftp");
sftpChannel.connect();
// 确保远程目录存在
createRemoteDirectory(sftpChannel, remotePath);
for (MultipartFile file : files) {
if (!file.isEmpty()) {
String remoteFilePath = remotePath + "/" + file.getOriginalFilename();
try (InputStream inputStream = file.getInputStream()) {
sftpChannel.put(inputStream, remoteFilePath);
log.info("文件上传成功: {}", file.getOriginalFilename());
}
}
}
log.info("批量上传完成，共上传 {} 个文件", files.length);
} finally {
closeConnections(sftpChannel, session);
}
}
// 私有辅助方法
private Session createSession(SshServers server) throws JSchException {
JSch jsch = new JSch();
Session session = jsch.getSession(server.getUsername(), server.getHost(), server.getPort());
session.setPassword(server.getPassword());
Properties config = new Properties();
config.put("StrictHostKeyChecking", "no");
config.put("PreferredAuthentications", "password");
session.setConfig(config);
session.connect(10000); // 10秒超时
return session;
}
private void createRemoteDirectory(ChannelSftp sftpChannel, String remotePath) {
try {
String[] pathParts = remotePath.split("/");
String currentPath = "";
for (String part : pathParts) {
if (!part.isEmpty()) {
currentPath += "/" + part;
try {
sftpChannel.mkdir(currentPath);
} catch (SftpException e) {
log.error(e.getMessage(),e);
}
}
}
} catch (Exception e) {
log.warn("创建远程目录失败: {}", e.getMessage());
}
}
private void closeConnections(ChannelSftp sftpChannel, Session session) {
if (sftpChannel != null && sftpChannel.isConnected()) {
sftpChannel.disconnect();
}
if (session != null && session.isConnected()) {
session.disconnect();
}
}
private String getPermissionString(int permissions) {
StringBuilder sb = new StringBuilder();
// Owner permissions
sb.append((permissions & 0400) != 0 ? 'r' : '-');
sb.append((permissions & 0200) != 0 ? 'w' : '-');
sb.append((permissions & 0100) != 0 ? 'x' : '-');
// Group permissions
sb.append((permissions & 0040) != 0 ? 'r' : '-');
sb.append((permissions & 0020) != 0 ? 'w' : '-');
sb.append((permissions & 0010) != 0 ? 'x' : '-');
// Others permissions
sb.append((permissions & 0004) != 0 ? 'r' : '-');
sb.append((permissions & 0002) != 0 ? 'w' : '-');
sb.append((permissions & 0001) != 0 ? 'x' : '-');
return sb.toString();
}
// 文件信息内部类
public static class FileInfo {
private String name;
private boolean isDirectory;
private long size;
private long lastModified;
private String permissions;
public FileInfo(String name, boolean isDirectory, long size, long lastModified, String permissions) {
this.name = name;
this.isDirectory = isDirectory;
this.size = size;
this.lastModified = lastModified;
this.permissions = permissions;
}
// Getters
public String getName() { return name; }
public boolean isDirectory() { return isDirectory; }
public long getSize() { return size; }
public long getLastModified() { return lastModified; }
public String getPermissions() { return permissions; }
}
}

96
src/main/java/com/mini/capi/webssh/service/SSHConnectionManager.java Normal file
View File

@@ -0,0 +1,96 @@
package com.mini.capi.webssh.service;
import com.jcraft.jsch.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.Map;
import java.util.Properties;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
@Component
@Slf4j
public class SSHConnectionManager {
private final Map<String, Session> connections = new ConcurrentHashMap<>();
private final Map<String, ChannelShell> channels = new ConcurrentHashMap<>();
/**
* 建立SSH连接
*/
public String createConnection(String host, int port, String username, String password) {
try {
JSch jsch = new JSch();
Session session = jsch.getSession(username, host, port);
// 配置连接参数
Properties config = new Properties();
config.put("StrictHostKeyChecking", "no");
config.put("PreferredAuthentications", "password");
session.setConfig(config);
session.setPassword(password);
// 建立连接
session.connect(30000); // 30秒超时
// 创建Shell通道
ChannelShell channel = (ChannelShell) session.openChannel("shell");
channel.setPty(true);
channel.setPtyType("xterm", 80, 24, 640, 480);
// 生成连接ID
String connectionId = UUID.randomUUID().toString();
// 保存连接和通道
connections.put(connectionId, session);
channels.put(connectionId, channel);
log.info("SSH连接建立成功: {}@{}:{}", username, host, port);
return connectionId;
} catch (JSchException e) {
log.error("SSH连接失败: {}", e.getMessage());
throw new RuntimeException("SSH连接失败: " + e.getMessage());
}
}
/**
* 获取SSH通道
*/
public ChannelShell getChannel(String connectionId) {
return channels.get(connectionId);
}
/**
* 获取SSH会话
*/
public Session getSession(String connectionId) {
return connections.get(connectionId);
}
/**
* 关闭SSH连接
*/
public void closeConnection(String connectionId) {
ChannelShell channel = channels.remove(connectionId);
if (channel != null && channel.isConnected()) {
channel.disconnect();
}
Session session = connections.remove(connectionId);
if (session != null && session.isConnected()) {
session.disconnect();
}
log.info("SSH连接已关闭: {}", connectionId);
}
/**
* 检查连接状态
*/
public boolean isConnected(String connectionId) {
Session session = connections.get(connectionId);
return session != null && session.isConnected();
}
}

263
src/main/java/com/mini/capi/webssh/websocket/SSHWebSocketHandler.java Normal file
View File

@@ -0,0 +1,263 @@
package com.mini.capi.webssh.websocket;
import com.mini.capi.webssh.service.SSHConnectionManager;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jcraft.jsch.ChannelShell;
import com.jcraft.jsch.JSchException;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
@Component
@Slf4j
public class SSHWebSocketHandler extends TextWebSocketHandler {
@Resource
private SSHConnectionManager connectionManager;
private final Map<WebSocketSession, String> sessionConnections = new ConcurrentHashMap<>();
private final Map<WebSocketSession, String> sessionUsers = new ConcurrentHashMap<>();
// 为每个WebSocket会话添加同步锁
private final Map<WebSocketSession, Object> sessionLocks = new ConcurrentHashMap<>();
@Override
public void afterConnectionEstablished(WebSocketSession session) {
log.info("WebSocket连接建立: {}", session.getId());
// 为每个会话创建同步锁
sessionLocks.put(session, new Object());
}
@Override
protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
try {
String payload = message.getPayload();
ObjectMapper mapper = new ObjectMapper();
JsonNode jsonNode = mapper.readTree(payload);
String type = jsonNode.get("type").asText();
switch (type) {
case "connect":
handleConnect(session, jsonNode);
break;
case "command":
handleCommand(session, jsonNode);
break;
case "resize":
handleResize(session, jsonNode);
break;
case "disconnect":
handleDisconnect(session);
break;
default:
log.warn("未知的消息类型: {}", type);
}
} catch (Exception e) {
log.error("处理WebSocket消息失败", e);
sendError(session, "处理消息失败: " + e.getMessage());
}
}
/**
* 处理SSH连接请求
*/
private void handleConnect(WebSocketSession session, JsonNode jsonNode) {
try {
String host = jsonNode.get("host").asText();
int port = jsonNode.get("port").asInt(22);
String username = jsonNode.get("username").asText();
String password = jsonNode.get("password").asText();
boolean enableCollaboration = jsonNode.has("enableCollaboration") &&
jsonNode.get("enableCollaboration").asBoolean();
// 存储用户信息
sessionUsers.put(session, username);
// 建立SSH连接
String connectionId = connectionManager.createConnection(host, port, username, password);
sessionConnections.put(session, connectionId);
// 启动SSH通道
ChannelShell channel = connectionManager.getChannel(connectionId);
startSSHChannel(session, channel);
// 发送连接成功消息
Map<String, Object> response = new HashMap<>();
response.put("type", "connected");
response.put("message", "SSH连接建立成功");
sendMessage(session, response);
} catch (Exception e) {
log.error("建立SSH连接失败", e);
sendError(session, "连接失败: " + e.getMessage());
}
}
/**
* 处理命令执行请求
*/
private void handleCommand(WebSocketSession session, JsonNode jsonNode) {
String connectionId = sessionConnections.get(session);
if (connectionId == null) {
sendError(session, "SSH连接未建立");
return;
}
String command = jsonNode.get("command").asText();
ChannelShell channel = connectionManager.getChannel(connectionId);
String username = sessionUsers.get(session);
if (channel != null && channel.isConnected()) {
try {
// 发送命令到SSH通道
OutputStream out = channel.getOutputStream();
out.write(command.getBytes());
out.flush();
} catch (IOException e) {
log.error("发送SSH命令失败", e);
sendError(session, "命令执行失败");
}
}
}
/**
* 启动SSH通道并处理输出
*/
private void startSSHChannel(WebSocketSession session, ChannelShell channel) {
try {
// 连接通道
channel.connect();
// 处理SSH输出
InputStream in = channel.getInputStream();
// 在单独的线程中读取SSH输出
new Thread(() -> {
byte[] buffer = new byte[4096];
try {
while (channel.isConnected() && session.isOpen()) {
if (in.available() > 0) {
int len = in.read(buffer);
if (len > 0) {
String output = new String(buffer, 0, len, "UTF-8");
// 发送给当前会话
sendMessage(session, Map.of(
"type", "output",
"data", output
));
}
} else {
// 没有数据时短暂休眠，避免CPU占用过高
Thread.sleep(10);
}
}
} catch (IOException | InterruptedException e) {
log.warn("SSH输出读取中断: {}", e.getMessage());
}
}, "SSH-Output-Reader-" + session.getId()).start();
} catch (JSchException | IOException e) {
log.error("启动SSH通道失败", e);
sendError(session, "通道启动失败: " + e.getMessage());
}
}
/**
* 处理终端大小调整
*/
private void handleResize(WebSocketSession session, JsonNode jsonNode) {
String connectionId = sessionConnections.get(session);
if (connectionId != null) {
ChannelShell channel = connectionManager.getChannel(connectionId);
if (channel != null) {
try {
int cols = jsonNode.get("cols").asInt();
int rows = jsonNode.get("rows").asInt();
channel.setPtySize(cols, rows, cols * 8, rows * 16);
} catch (Exception e) {
log.warn("调整终端大小失败", e);
}
}
}
}
/**
* 处理断开连接
*/
private void handleDisconnect(WebSocketSession session) {
String connectionId = sessionConnections.remove(session);
String username = sessionUsers.remove(session);
if (connectionId != null) {
connectionManager.closeConnection(connectionId);
}
// 清理锁资源
sessionLocks.remove(session);
}
@Override
public void afterConnectionClosed(WebSocketSession session, CloseStatus status) {
handleDisconnect(session);
log.info("WebSocket连接关闭: {}", session.getId());
}
/**
* 发送消息到WebSocket客户端（线程安全）
*/
private void sendMessage(WebSocketSession session, Object message) {
Object lock = sessionLocks.get(session);
if (lock == null) return;
synchronized (lock) {
try {
if (session.isOpen()) {
ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(message);
session.sendMessage(new TextMessage(json));
}
} catch (Exception e) {
log.error("发送WebSocket消息失败", e);
}
}
}
/**
* 发送错误消息
*/
private void sendError(WebSocketSession session, String error) {
sendMessage(session, Map.of(
"type", "error",
"message", error
));
}
/**
* 从会话中获取用户信息
*/
private String getUserFromSession(WebSocketSession session) {
// 简化实现，实际应用中可以从session中获取认证用户信息
return "anonymous";
}
/**
* 从会话中获取主机信息
*/
private String getHostFromSession(WebSocketSession session) {
// 简化实现，实际应用中可以保存连接信息
return "unknown";
}
}