Merge branch 'higress-group:main' into main

Author: kaplax

himarket-server/src/main/java/com/alibaba/himarket/service/impl/NacosServiceImpl.java

@@ -48,6 +48,7 @@
 import com.alibaba.nacos.api.PropertyKeyConst;
 import com.alibaba.nacos.api.ai.model.a2a.AgentCard;
 import com.alibaba.nacos.api.ai.model.a2a.AgentCardVersionInfo;
+import com.alibaba.nacos.api.ai.model.mcp.McpEndpointInfo;
 import com.alibaba.nacos.api.ai.model.mcp.McpServerBasicInfo;
 import com.alibaba.nacos.api.ai.model.mcp.McpServerDetailInfo;
 import com.alibaba.nacos.api.exception.NacosException;
@@ -61,6 +62,7 @@
 import com.aliyun.mse20190531.models.ListClustersResponse;
 import com.aliyun.mse20190531.models.ListClustersResponseBody;
 import com.aliyun.teautil.models.RuntimeOptions;
+import java.net.URI;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -359,11 +361,10 @@ private MCPConfigResult buildMCPConfigResult(McpServerDetailInfo detail) {
     }
 
     private Object buildRemoteConnectionConfig(McpServerDetailInfo detail) {
-        List<?> backendEndpoints = detail.getBackendEndpoints();
+        List<McpEndpointInfo> backendEndpoints = detail.getBackendEndpoints();
 
         if (backendEndpoints != null && !backendEndpoints.isEmpty()) {
-            Object firstEndpoint = backendEndpoints.get(0);
-
+            McpEndpointInfo firstEndpoint = backendEndpoints.get(0);
             Map<String, Object> connectionConfig = new HashMap<>();
             Map<String, Object> mcpServers = new HashMap<>();
             Map<String, Object> serverConfig = new HashMap<>();
@@ -386,132 +387,117 @@ private Object buildRemoteConnectionConfig(McpServerDetailInfo detail) {
         return basicConfig;
     }
 
-    private String extractEndpointUrl(Object endpoint) {
+    private String extractEndpointUrl(McpEndpointInfo endpoint) {
         if (endpoint == null) {
             return null;
         }
 
-        if (endpoint instanceof String) {
-            return (String) endpoint;
+        String address = endpoint.getAddress();
+        if (StrUtil.isBlank(address)) {
+            return null;
         }
 
-        if (endpoint instanceof Map) {
-            Map<?, ?> endpointMap = (Map<?, ?>) endpoint;
-
-            String url = getStringValue(endpointMap, "url");
-            if (url != null) return url;
-
-            String endpointUrl = getStringValue(endpointMap, "endpointUrl");
-            if (endpointUrl != null) return endpointUrl;
-
-            String host = getStringValue(endpointMap, "host");
-            String port = getStringValue(endpointMap, "port");
-            String path = getStringValue(endpointMap, "path");
-
-            if (host != null) {
-                StringBuilder urlBuilder = new StringBuilder();
-                String protocol = getStringValue(endpointMap, "protocol");
-                urlBuilder.append(protocol != null ? protocol : "http").append("://");
-                urlBuilder.append(host);
-
-                if (port != null && !port.isEmpty()) {
-                    urlBuilder.append(":").append(port);
-                }
+        String protocol = StrUtil.blankToDefault(endpoint.getProtocol(), "http");
+        int endpointPort = endpoint.getPort() > 0 ? endpoint.getPort() : -1;
+        String normalizedPath = normalizeUrlPath(endpoint.getPath());
 
-                if (path != null && !path.isEmpty()) {
-                    if (!path.startsWith("/")) {
-                        urlBuilder.append("/");
-                    }
-                    urlBuilder.append(path);
+        // If address is already a full URL, prefer it and only fill missing port/path.
+        if (address.contains("://")) {
+            try {
+                URI uri = URI.create(address);
+                String scheme = StrUtil.blankToDefault(uri.getScheme(), protocol);
+                String host = uri.getHost();
+                int port = uri.getPort() != -1 ? uri.getPort() : endpointPort;
+                String path = StrUtil.isBlank(uri.getPath()) ? normalizedPath : uri.getPath();
+                if (host != null) {
+                    return new URI(scheme, null, host, port, path, null, null).toString();
                 }
-
-                return urlBuilder.toString();
+            } catch (Exception ignored) {
+                // fall back to simple concatenation
             }
-        }
-
-        if (endpoint.getClass().getName().contains("McpEndpointInfo")) {
-            return extractUrlFromMcpEndpointInfo(endpoint);
-        }
-
-        return endpoint.toString();
-    }
-
-    private String getStringValue(Map<?, ?> map, String key) {
-        Object value = map.get(key);
-        return value != null ? value.toString() : null;
-    }
-
-    private String extractUrlFromMcpEndpointInfo(Object endpoint) {
-        String[] possibleFieldNames = {"url", "endpointUrl", "address", "host", "endpoint"};
-
-        for (String fieldName : possibleFieldNames) {
-            try {
-                java.lang.reflect.Field field = endpoint.getClass().getDeclaredField(fieldName);
-                field.setAccessible(true);
-                Object value = field.get(endpoint);
-                if (value != null && !value.toString().trim().isEmpty()) {
-                    if (value.toString().contains("://") || value.toString().contains(":")) {
-                        return value.toString();
+            return appendPath(address, normalizedPath);
+        }
+
+        // Address might be host or host:port (IPv4/hostname). Handle simple host:port.
+        String host = address;
+        int port = endpointPort;
+
+        // Handle bracketed IPv6 forms like "[::1]" or "[::1]:8848".
+        if (address.startsWith("[") && address.contains("]")) {
+            int endBracket = address.indexOf(']');
+            host = address.substring(1, endBracket);
+            if (port == -1) {
+                String rest = address.substring(endBracket + 1);
+                if (rest.startsWith(":")) {
+                    Integer parsedPort = tryParsePort(rest.substring(1));
+                    if (parsedPort != null) {
+                        port = parsedPort;
                     }
                 }
-            } catch (Exception e) {
-                continue;
             }
-        }
-
-        java.lang.reflect.Field[] fields = endpoint.getClass().getDeclaredFields();
-
-        String host = null;
-        String port = null;
-        String path = null;
-        String protocol = null;
-
-        for (java.lang.reflect.Field field : fields) {
-            try {
-                field.setAccessible(true);
-                Object value = field.get(endpoint);
-                if (value != null && !value.toString().trim().isEmpty()) {
-                    String fieldName = field.getName().toLowerCase();
-
-                    if (fieldName.contains("host")
-                            || fieldName.contains("ip")
-                            || fieldName.contains("address")) {
-                        host = value.toString();
-                    } else if (fieldName.contains("port")) {
-                        port = value.toString();
-                    } else if (fieldName.contains("path")
-                            || fieldName.contains("endpoint")
-                            || fieldName.contains("uri")) {
-                        path = value.toString();
-                    } else if (fieldName.contains("protocol") || fieldName.contains("scheme")) {
-                        protocol = value.toString();
+        } else {
+            int lastColon = address.lastIndexOf(':');
+            if (lastColon > 0 && address.indexOf(':') == lastColon) {
+                Integer parsedPort = tryParsePort(address.substring(lastColon + 1));
+                if (parsedPort != null) {
+                    host = address.substring(0, lastColon);
+                    if (port == -1) {
+                        port = parsedPort;
                     }
                 }
-            } catch (Exception e) {
-                continue;
             }
         }
 
-        if (host != null) {
+        try {
+            return new URI(protocol, null, host, port, normalizedPath, null, null).toString();
+        } catch (Exception e) {
             StringBuilder urlBuilder = new StringBuilder();
-            urlBuilder.append(protocol != null ? protocol : "http").append("://");
-            urlBuilder.append(host);
-
-            if (port != null && !port.isEmpty()) {
+            urlBuilder.append(protocol).append("://").append(address);
+            if (port > 0 && !address.contains(":")) {
                 urlBuilder.append(":").append(port);
             }
-
-            if (path != null && !path.isEmpty()) {
-                if (!path.startsWith("/")) {
-                    urlBuilder.append("/");
-                }
-                urlBuilder.append(path);
+            if (normalizedPath != null) {
+                urlBuilder.append(normalizedPath);
             }
-
             return urlBuilder.toString();
         }
+    }
+
+    private String normalizeUrlPath(String path) {
+        if (StrUtil.isBlank(path)) {
+            return null;
+        }
+        return path.startsWith("/") ? path : "/" + path;
+    }
+
+    private Integer tryParsePort(String portStr) {
+        if (StrUtil.isBlank(portStr)) {
+            return null;
+        }
+        for (int i = 0; i < portStr.length(); i++) {
+            if (!Character.isDigit(portStr.charAt(i))) {
+                return null;
+            }
+        }
+        try {
+            int port = Integer.parseInt(portStr);
+            return port > 0 && port <= 65535 ? port : null;
+        } catch (NumberFormatException e) {
+            return null;
+        }
+    }
 
-        return endpoint.toString();
+    private String appendPath(String baseUrl, String normalizedPath) {
+        if (normalizedPath == null) {
+            return baseUrl;
+        }
+        if (baseUrl.endsWith("/") && normalizedPath.startsWith("/")) {
+            return baseUrl + normalizedPath.substring(1);
+        }
+        if (!baseUrl.endsWith("/") && !normalizedPath.startsWith("/")) {
+            return baseUrl + "/" + normalizedPath;
+        }
+        return baseUrl + normalizedPath;
     }
 
     private NacosInstance findNacosInstance(String nacosId) {

himarket-server/src/test/java/com/alibaba/himarket/service/impl/NacosServiceImplEndpointTest.java

@@ -0,0 +1,129 @@
+package com.alibaba.himarket.service.impl;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import com.alibaba.nacos.api.ai.model.mcp.McpEndpointInfo;
+import com.alibaba.nacos.api.ai.model.mcp.McpServerDetailInfo;
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.Test;
+
+class NacosServiceImplEndpointTest {
+
+    private static NacosServiceImpl newService() {
+        return new NacosServiceImpl(null, null, null);
+    }
+
+    private static McpEndpointInfo endpoint(
+            String protocol, String address, int port, String path) {
+        McpEndpointInfo info = new McpEndpointInfo();
+        info.setProtocol(protocol);
+        info.setAddress(address);
+        info.setPort(port);
+        info.setPath(path);
+        return info;
+    }
+
+    private static String invokeExtractEndpointUrl(
+            NacosServiceImpl service, McpEndpointInfo endpoint) throws Exception {
+        Method method =
+                NacosServiceImpl.class.getDeclaredMethod(
+                        "extractEndpointUrl", McpEndpointInfo.class);
+        method.setAccessible(true);
+        return (String) method.invoke(service, endpoint);
+    }
+
+    private static Object invokeBuildRemoteConnectionConfig(
+            NacosServiceImpl service, McpServerDetailInfo detail) throws Exception {
+        Method method =
+                NacosServiceImpl.class.getDeclaredMethod(
+                        "buildRemoteConnectionConfig", McpServerDetailInfo.class);
+        method.setAccessible(true);
+        return method.invoke(service, detail);
+    }
+
+    @Test
+    void extractEndpointUrl_nullEndpoint_returnsNull() throws Exception {
+        assertNull(invokeExtractEndpointUrl(newService(), null));
+    }
+
+    @Test
+    void extractEndpointUrl_blankAddress_returnsNull() throws Exception {
+        McpEndpointInfo info = endpoint("http", "  ", 8080, "/mcp");
+        assertNull(invokeExtractEndpointUrl(newService(), info));
+    }
+
+    @Test
+    void extractEndpointUrl_fullUrl_fillsMissingPortAndPath() throws Exception {
+        McpEndpointInfo info = endpoint("https", "http://example.com", 8443, "/mcp");
+        assertEquals("http://example.com:8443/mcp", invokeExtractEndpointUrl(newService(), info));
+    }
+
+    @Test
+    void extractEndpointUrl_fullUrl_keepsExistingPath_andFillsMissingPort() throws Exception {
+        McpEndpointInfo info = endpoint("http", "https://example.com/api", 1234, "/ignored");
+        assertEquals("https://example.com:1234/api", invokeExtractEndpointUrl(newService(), info));
+    }
+
+    @Test
+    void extractEndpointUrl_hostPort_parsesPortWhenEndpointPortMissing() throws Exception {
+        McpEndpointInfo info = endpoint(null, "example.com:8080", -1, "x");
+        assertEquals("http://example.com:8080/x", invokeExtractEndpointUrl(newService(), info));
+    }
+
+    @Test
+    void extractEndpointUrl_hostPort_prefersEndpointPortWhenProvided() throws Exception {
+        McpEndpointInfo info = endpoint(null, "example.com:8080", 9090, "x");
+        assertEquals("http://example.com:9090/x", invokeExtractEndpointUrl(newService(), info));
+    }
+
+    @Test
+    void extractEndpointUrl_ipv6BracketWithPort_buildsCorrectUrl() throws Exception {
+        McpEndpointInfo info = endpoint("http", "[::1]:8848", -1, "nacos");
+        assertEquals("http://[::1]:8848/nacos", invokeExtractEndpointUrl(newService(), info));
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    void buildRemoteConnectionConfig_withBackendEndpoint_setsUrlInMcpServers() throws Exception {
+        NacosServiceImpl service = newService();
+
+        McpEndpointInfo backend = endpoint("http", "example.com:8080", -1, "/mcp");
+        McpServerDetailInfo detail = new McpServerDetailInfo();
+        detail.setName("demo");
+        detail.setBackendEndpoints(List.of(backend));
+
+        Object config = invokeBuildRemoteConnectionConfig(service, detail);
+        assertNotNull(config);
+        assertTrue(config instanceof Map);
+
+        Map<String, Object> connectionConfig = (Map<String, Object>) config;
+        assertTrue(connectionConfig.containsKey("mcpServers"));
+
+        Map<String, Object> mcpServers = (Map<String, Object>) connectionConfig.get("mcpServers");
+        assertTrue(mcpServers.containsKey("demo"));
+
+        Map<String, Object> serverConfig = (Map<String, Object>) mcpServers.get("demo");
+        assertEquals("http://example.com:8080/mcp", serverConfig.get("url"));
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    void buildRemoteConnectionConfig_withoutEndpoints_returnsBasicRemoteConfig() throws Exception {
+        NacosServiceImpl service = newService();
+
+        McpServerDetailInfo detail = new McpServerDetailInfo();
+        detail.setName("demo");
+        detail.setBackendEndpoints(List.of());
+
+        Object config = invokeBuildRemoteConnectionConfig(service, detail);
+        assertNotNull(config);
+        assertTrue(config instanceof Map);
+
+        Map<String, Object> basicConfig = (Map<String, Object>) config;
+        assertEquals("remote", basicConfig.get("type"));
+        assertEquals("demo", basicConfig.get("name"));
+        assertEquals("http", basicConfig.get("protocol"));
+    }
+}