chore: refine display logic for node ranking

Author: vernesong

adapter/outboundgroup/smart.go

@@ -371,7 +371,12 @@ func (s *Smart) InitializeCache() {
 
     s.startTimedTask(5*time.Minute, checkInterval, "Clean up nodes", s.cleanupOrphanedNodeCache, true)
     s.startTimedTask(10*time.Second, checkInterval, "Preload frequent data", func() {
-        s.store.PreloadFrequentData(s.Name(), s.configName)
+        proxies := s.GetProxies(false)
+        proxyNames := make([]string, 0, len(proxies))
+        for _, p := range proxies {
+            proxyNames = append(proxyNames, p.Name())
+        }
+        s.store.PreloadFrequentData(s.Name(), s.configName, proxyNames)
     }, true)
     s.startTimedTask(5*time.Minute, prefetchInterval, "prefetch", s.runPrefetch, false)
     s.startTimedTask(5*time.Minute, rankingInterval, "ranking", s.updateNodeRanking, false)
@@ -462,7 +467,12 @@ func (s *Smart) updateNodeRanking() {
 
 	log.Debugln("[Smart] Starting node ranking update for policy group [%s]", s.Name())
 
-	ranking, err := s.store.GetNodeWeightRanking(s.Name(), s.configName, false)
+    proxies := s.GetProxies(false)
+    proxyNames := make([]string, 0, len(proxies))
+    for _, p := range proxies {
+        proxyNames = append(proxyNames, p.Name())
+    }
+    ranking, err := s.store.GetNodeWeightRanking(s.Name(), s.configName, false, proxyNames)
 	if err != nil {
 		log.Warnln("[Smart] Failed to update node ranking: %v", err)
 		return

component/smart/common.go

@@ -318,20 +318,20 @@ func getSystemMemoryLimit() float64 {
                     }
                 }
             }
-        } else if runtime.GOOS == "linux" || runtime.GOOS == "darwin" {
-            output, err = cmd.ExecCmd("grep MemTotal /proc/meminfo")
-            if err == nil {
-                parts := strings.Fields(output)
-                if len(parts) >= 2 {
-                    memStr := strings.TrimSuffix(parts[1], "kB")
-                    memStr = strings.TrimSpace(memStr)
-                    memKB, parseErr := strconv.ParseFloat(memStr, 64)
-                    if parseErr == nil {
-                        memTotal = memKB / 1024.0
+            } else if runtime.GOOS == "linux" || runtime.GOOS == "android" || runtime.GOOS == "darwin" || runtime.GOOS == "freebsd" {
+                output, err = cmd.ExecCmd("grep MemTotal /proc/meminfo")
+                if err == nil {
+                    parts := strings.Fields(output)
+                    if len(parts) >= 2 {
+                        memStr := strings.TrimSuffix(parts[1], "kB")
+                        memStr = strings.TrimSpace(memStr)
+                        memKB, parseErr := strconv.ParseFloat(memStr, 64)
+                        if parseErr == nil {
+                            memTotal = memKB / 1024.0
+                        }
                     }
                 }
             }
-        }
 
         memTotal = memTotal / 4.0
 

component/smart/memory.go

@@ -507,7 +507,7 @@ func (s *Store) AdjustCacheParameters() {
 }
 
 // 预加载频繁使用的数据
-func (s *Store) PreloadFrequentData(group, config string) {
+func (s *Store) PreloadFrequentData(group, config string, proxies []string) {
     log.Infoln("[SmartStore] Starting data preloading for group [%s], config [%s]", group, config)
 
     memUsage := GetSystemMemoryUsage()
@@ -535,7 +535,7 @@ func (s *Store) PreloadFrequentData(group, config string) {
         nodeStatesCount = len(stateData)
     }
 
-    ranking, _ := s.GetNodeWeightRanking(group, config, true)
+    ranking, _ := s.GetNodeWeightRanking(group, config, true, proxies)
 
     domains, err := s.GetActiveDomains(group, config, domainLimit)
     if err == nil && len(domains) > 0 {

component/smart/stats.go

@@ -276,7 +276,7 @@ func (r *AtomicStatsRecord) SetWeight(weightType string, value float64) {
 }
 
 // 获取节点权重排名
-func (s *Store) GetNodeWeightRanking(group, config string, onlyCache bool) (map[string]string, error) {
+func (s *Store) GetNodeWeightRanking(group, config string, onlyCache bool, proxies []string) (map[string]string, error) {
     cacheKey := FormatCacheKey(KeyTypeRanking, config, group, "")
 
     cachedData, ok := GetCacheValue(cacheKey)
@@ -305,7 +305,12 @@ func (s *Store) GetNodeWeightRanking(group, config string, onlyCache bool) (map[
         return make(map[string]string), nil
     }
 
-    allNodes, _ := s.GetAllNodesForGroup(group, config)
+    var allNodes []string
+    if len(proxies) > 0 {
+        allNodes = proxies
+    } else {
+        allNodes, _ = s.GetAllNodesForGroup(group, config)
+    }
 
     nodeDataMap := make(map[string]*struct{
         tcpWeights    float64
@@ -553,9 +558,11 @@ func (s *Store) GetNodeWeightRanking(group, config string, onlyCache bool) (map[
         }
     }
 
-    for _, nodeName := range allNodes {
-        if _, exists := nodeWeights[nodeName]; !exists {
-            result[nodeName] = RankRarelyUsed
+    if len(nodeWeights) > 0 {
+        for _, nodeName := range allNodes {
+            if _, exists := nodeWeights[nodeName]; !exists {
+                result[nodeName] = RankRarelyUsed
+            }
         }
     }
 

hub/route/groups.go

@@ -131,8 +131,23 @@ func getGroupWeights(w http.ResponseWriter, r *http.Request) {
 		})
 		return
 	}
+
+	proxies := smartGroup.GetProxies(false)
+	proxyNames := make([]string, 0, len(proxies))
+	for _, p := range proxies {
+		proxyNames = append(proxyNames, p.Name())
+	}
+
+	if len(proxyNames) == 0 {
+		render.Status(r, http.StatusInternalServerError)
+		render.JSON(w, r, render.M{
+			"weights": map[string]string{},
+			"message": "No available proxies in this group",
+		})
+		return
+	}
 
-	weights, err := smartStore.GetStore().GetNodeWeightRanking(groupName, configName, false)
+	weights, err := smartStore.GetStore().GetNodeWeightRanking(groupName, configName, false, proxyNames)
 
 	if err != nil {
 		log.Warnln("[Smart] Failed to get weight ranking: %s", err.Error())