package com.zy.ai.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.zy.ai.entity.AiMcpMount;
|
import com.zy.ai.enums.AiMcpTransportType;
|
import com.zy.ai.mapper.AiMcpMountMapper;
|
import com.zy.ai.service.AiMcpMountService;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.net.URI;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
|
@Slf4j
|
@Service("aiMcpMountService")
|
public class AiMcpMountServiceImpl extends ServiceImpl<AiMcpMountMapper, AiMcpMount> implements AiMcpMountService {
|
|
private static final int DEFAULT_TIMEOUT_MS = 20000;
|
private static final int DEFAULT_PRIORITY = 100;
|
private static final String DEFAULT_LOCAL_MOUNT_CODE = "wcs_local";
|
|
@Value("${spring.ai.mcp.server.sse-endpoint:/ai/mcp/sse}")
|
private String defaultSseEndpoint;
|
|
@Value("${spring.ai.mcp.server.streamable-http.mcp-endpoint:/ai/mcp}")
|
private String defaultStreamableEndpoint;
|
|
@Value("${app.ai.mcp.server.public-base-url:http://127.0.0.1:${server.port:9090}${server.servlet.context-path:}}")
|
private String defaultLocalBaseUrl;
|
|
@Override
|
public List<AiMcpMount> listOrdered() {
|
return this.list(new QueryWrapper<AiMcpMount>()
|
.orderByAsc("priority")
|
.orderByAsc("id"));
|
}
|
|
@Override
|
public List<AiMcpMount> listEnabledOrdered() {
|
return this.list(new QueryWrapper<AiMcpMount>()
|
.eq("status", 1)
|
.orderByAsc("priority")
|
.orderByAsc("id"));
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public AiMcpMount saveMount(AiMcpMount mount) {
|
AiMcpMount candidate = prepareMountDraft(mount);
|
Date now = new Date();
|
if (candidate.getId() == null) {
|
candidate.setCreateTime(now);
|
candidate.setUpdateTime(now);
|
this.save(candidate);
|
return candidate;
|
}
|
|
AiMcpMount db = this.getById(candidate.getId());
|
if (db == null) {
|
throw new IllegalArgumentException("MCP挂载不存在");
|
}
|
candidate.setCreateTime(db.getCreateTime());
|
candidate.setLastTestOk(db.getLastTestOk());
|
candidate.setLastTestTime(db.getLastTestTime());
|
candidate.setLastTestSummary(db.getLastTestSummary());
|
candidate.setUpdateTime(now);
|
this.updateById(candidate);
|
return candidate;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean deleteMount(Long id) {
|
if (id == null) {
|
return false;
|
}
|
AiMcpMount db = this.getById(id);
|
if (db == null) {
|
return false;
|
}
|
return this.removeById(id);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public int initDefaultsIfMissing() {
|
AiMcpMount existing = this.getOne(new QueryWrapper<AiMcpMount>()
|
.eq("mount_code", DEFAULT_LOCAL_MOUNT_CODE)
|
.last("limit 1"));
|
if (existing != null) {
|
boolean changed = false;
|
AiMcpTransportType transportType = AiMcpTransportType.ofCode(existing.getTransportType());
|
if (transportType == null) {
|
existing.setTransportType(AiMcpTransportType.SSE.getCode());
|
changed = true;
|
}
|
String expectedEndpoint = defaultEndpoint(AiMcpTransportType.ofCode(existing.getTransportType()));
|
String expectedUrl = defaultUrl(AiMcpTransportType.ofCode(existing.getTransportType()));
|
if (isBlank(existing.getUrl()) || isLegacyLocalUrl(existing.getUrl(), expectedEndpoint)) {
|
existing.setUrl(expectedUrl);
|
changed = true;
|
}
|
if (changed) {
|
existing.setUpdateTime(new Date());
|
this.updateById(existing);
|
return 1;
|
}
|
return 0;
|
}
|
|
AiMcpMount mount = new AiMcpMount();
|
mount.setName("WCS默认MCP");
|
mount.setMountCode(DEFAULT_LOCAL_MOUNT_CODE);
|
mount.setTransportType(AiMcpTransportType.SSE.getCode());
|
mount.setUrl(defaultUrl(AiMcpTransportType.SSE));
|
mount.setRequestTimeoutMs(DEFAULT_TIMEOUT_MS);
|
mount.setPriority(0);
|
mount.setStatus((short) 1);
|
mount.setMemo("默认挂载当前WCS自身的MCP服务，AI助手也通过挂载配置访问本系统工具");
|
Date now = new Date();
|
mount.setCreateTime(now);
|
mount.setUpdateTime(now);
|
this.save(mount);
|
return 1;
|
}
|
|
@Override
|
public void recordTestResult(Long id, boolean ok, String summary) {
|
if (id == null) {
|
return;
|
}
|
AiMcpMount db = this.getById(id);
|
if (db == null) {
|
return;
|
}
|
db.setLastTestOk(ok ? (short) 1 : (short) 0);
|
db.setLastTestTime(new Date());
|
db.setLastTestSummary(cut(trim(summary), 1000));
|
db.setUpdateTime(new Date());
|
this.updateById(db);
|
}
|
|
@Override
|
public AiMcpMount prepareMountDraft(AiMcpMount mount) {
|
if (mount == null) {
|
throw new IllegalArgumentException("参数不能为空");
|
}
|
AiMcpMount candidate = new AiMcpMount();
|
candidate.setId(mount.getId());
|
candidate.setName(trim(mount.getName()));
|
candidate.setMountCode(normalizeIdentifier(mount.getMountCode()));
|
candidate.setTransportType(normalizeTransportType(mount.getTransportType()).getCode());
|
candidate.setUrl(normalizeUrl(mount.getUrl(), AiMcpTransportType.ofCode(candidate.getTransportType())));
|
candidate.setRequestTimeoutMs(normalizeTimeout(mount.getRequestTimeoutMs()));
|
candidate.setPriority(mount.getPriority() == null ? DEFAULT_PRIORITY : Math.max(0, mount.getPriority()));
|
candidate.setStatus(normalizeShort(mount.getStatus(), (short) 1));
|
candidate.setMemo(cut(trim(mount.getMemo()), 1000));
|
|
if (isBlank(candidate.getMountCode())) {
|
throw new IllegalArgumentException("必须填写挂载编码");
|
}
|
if (isBlank(candidate.getName())) {
|
candidate.setName(candidate.getMountCode());
|
}
|
if (isBlank(candidate.getUrl())) {
|
throw new IllegalArgumentException("必须填写URL");
|
}
|
|
AiMcpMount duplicate = this.getOne(new QueryWrapper<AiMcpMount>()
|
.eq("mount_code", candidate.getMountCode())
|
.ne(candidate.getId() != null, "id", candidate.getId())
|
.last("limit 1"));
|
if (duplicate != null) {
|
throw new IllegalArgumentException("挂载编码已存在：" + candidate.getMountCode());
|
}
|
return candidate;
|
}
|
|
@Override
|
public List<java.util.Map<String, Object>> listSupportedTransportTypes() {
|
List<java.util.Map<String, Object>> result = new ArrayList<java.util.Map<String, Object>>();
|
for (AiMcpTransportType item : AiMcpTransportType.values()) {
|
LinkedHashMap<String, Object> row = new LinkedHashMap<String, Object>();
|
row.put("code", item.getCode());
|
row.put("label", item.getLabel());
|
row.put("defaultUrl", defaultUrl(item));
|
result.add(row);
|
}
|
return result;
|
}
|
|
private AiMcpTransportType normalizeTransportType(String raw) {
|
AiMcpTransportType transportType = AiMcpTransportType.ofCode(raw);
|
if (transportType == null) {
|
throw new IllegalArgumentException("不支持的MCP传输类型：" + raw);
|
}
|
return transportType;
|
}
|
|
private Short normalizeShort(Short value, Short defaultValue) {
|
return value == null ? defaultValue : value;
|
}
|
|
private int normalizeTimeout(Integer requestTimeoutMs) {
|
int timeout = requestTimeoutMs == null ? DEFAULT_TIMEOUT_MS : requestTimeoutMs;
|
if (timeout < 1000) {
|
timeout = 1000;
|
}
|
if (timeout > 300000) {
|
timeout = 300000;
|
}
|
return timeout;
|
}
|
|
private String normalizeUrl(String url, AiMcpTransportType transportType) {
|
String value = trim(url);
|
if (isBlank(value)) {
|
return defaultUrl(transportType);
|
}
|
while (value.endsWith("/") && value.length() > "http://x".length()) {
|
value = value.substring(0, value.length() - 1);
|
}
|
if (!value.startsWith("http://") && !value.startsWith("https://")) {
|
throw new IllegalArgumentException("URL必须以 http:// 或 https:// 开头");
|
}
|
try {
|
URI uri = URI.create(value);
|
if (isBlank(uri.getScheme()) || isBlank(uri.getHost())) {
|
throw new IllegalArgumentException("URL格式不正确");
|
}
|
if (isBlank(uri.getPath()) || "/".equals(uri.getPath())) {
|
throw new IllegalArgumentException("URL必须包含完整的MCP路径");
|
}
|
return value;
|
} catch (IllegalArgumentException e) {
|
throw e;
|
} catch (Exception e) {
|
throw new IllegalArgumentException("URL格式不正确");
|
}
|
}
|
|
private String defaultEndpoint(AiMcpTransportType transportType) {
|
if (transportType == AiMcpTransportType.STREAMABLE_HTTP) {
|
String endpoint = trim(defaultStreamableEndpoint);
|
if (isBlank(endpoint)) {
|
endpoint = AiMcpTransportType.STREAMABLE_HTTP.getDefaultEndpoint();
|
}
|
if (!endpoint.startsWith("/")) {
|
endpoint = "/" + endpoint;
|
}
|
return endpoint;
|
}
|
String endpoint = trim(defaultSseEndpoint);
|
if (isBlank(endpoint)) {
|
endpoint = AiMcpTransportType.SSE.getDefaultEndpoint();
|
}
|
if (!endpoint.startsWith("/")) {
|
endpoint = "/" + endpoint;
|
}
|
return endpoint;
|
}
|
|
private String resolveDefaultLocalBaseUrl() {
|
String value = trim(defaultLocalBaseUrl);
|
if (isBlank(value)) {
|
return null;
|
}
|
while (value.endsWith("/")) {
|
value = value.substring(0, value.length() - 1);
|
}
|
return value;
|
}
|
|
private String defaultUrl(AiMcpTransportType transportType) {
|
String baseUrl = resolveDefaultLocalBaseUrl();
|
String endpoint = defaultEndpoint(transportType);
|
if (isBlank(baseUrl)) {
|
return endpoint;
|
}
|
return baseUrl + endpoint;
|
}
|
|
private boolean isLegacyLocalUrl(String url, String expectedEndpoint) {
|
String current = trim(url);
|
String targetBase = resolveDefaultLocalBaseUrl();
|
if (isBlank(current) || isBlank(targetBase) || isBlank(expectedEndpoint)) {
|
return false;
|
}
|
try {
|
URI currentUri = URI.create(current);
|
URI targetBaseUri = URI.create(targetBase);
|
String currentPath = trim(currentUri.getPath());
|
if (isBlank(currentPath) || "/".equals(currentPath)) {
|
return true;
|
}
|
String expectedPath = expectedEndpoint.startsWith("/") ? expectedEndpoint : ("/" + expectedEndpoint);
|
if (currentPath.equals(expectedPath)) {
|
return sameOrigin(currentUri, targetBaseUri);
|
}
|
String targetPath = trim(targetBaseUri.getPath());
|
if (isBlank(targetPath)) {
|
return false;
|
}
|
String expectedFullPath = targetPath + expectedPath;
|
return sameOrigin(currentUri, targetBaseUri) && currentPath.equals(expectedFullPath);
|
} catch (Exception e) {
|
log.warn("Failed to inspect MCP mount url for legacy migration, url={}", current, e);
|
return false;
|
}
|
}
|
|
private boolean sameOrigin(URI left, URI right) {
|
return equalsIgnoreCase(left.getScheme(), right.getScheme())
|
&& equalsIgnoreCase(left.getHost(), right.getHost())
|
&& effectivePort(left) == effectivePort(right);
|
}
|
|
private boolean equalsIgnoreCase(String left, String right) {
|
if (left == null) {
|
return right == null;
|
}
|
return left.equalsIgnoreCase(right);
|
}
|
|
private int effectivePort(URI uri) {
|
if (uri == null) {
|
return -1;
|
}
|
if (uri.getPort() > 0) {
|
return uri.getPort();
|
}
|
String scheme = uri.getScheme();
|
if ("https".equalsIgnoreCase(scheme)) {
|
return 443;
|
}
|
if ("http".equalsIgnoreCase(scheme)) {
|
return 80;
|
}
|
return -1;
|
}
|
|
private String normalizeIdentifier(String text) {
|
String value = trim(text);
|
if (isBlank(value)) {
|
return null;
|
}
|
value = value.replaceAll("[^0-9A-Za-z_]+", "_");
|
value = value.replaceAll("_+", "_");
|
value = value.replaceAll("^_+", "").replaceAll("_+$", "");
|
return value.toLowerCase();
|
}
|
|
private String trim(String text) {
|
return text == null ? null : text.trim();
|
}
|
|
private String cut(String text, int maxLen) {
|
if (text == null) {
|
return null;
|
}
|
return text.length() > maxLen ? text.substring(0, maxLen) : text;
|
}
|
|
private boolean isBlank(String text) {
|
return text == null || text.trim().isEmpty();
|
}
|
|
}
|
