update

utils/get.go

@@ -1,12 +1,14 @@
 package utils
 
 import (
+	"errors"
 	"net/http"
+	"sub2clash/config"
 	"time"
 )
 
-func GetWithRetry(url string) (resp *http.Response, err error) {
-	retryTimes := 3
+func Get(url string) (resp *http.Response, err error) {
+	retryTimes := config.Default.RequestRetryTimes
 	haveTried := 0
 	retryDelay := time.Second // 延迟1秒再重试
 	for haveTried < retryTimes {
@@ -16,8 +18,13 @@ func GetWithRetry(url string) (resp *http.Response, err error) {
 			time.Sleep(retryDelay)
 			continue
 		} else {
+			// 如果文件大小大于设定，直接返回错误
+			if get != nil && get.ContentLength > config.Default.RequestMaxFileSize {
+				return nil, errors.New("文件过大")
+			}
 			return get, nil
 		}
+
 	}
 	return nil, err
 }

utils/proxy.go

@@ -1,23 +1,29 @@
 package utils
 
 import (
-	"sort"
 	"strings"
-	"sub/model"
-	"sub/parser"
+	"sub2clash/model"
+	"sub2clash/parser"
 )
 
-func GetContryCode(proxy model.Proxy) string {
-	keys := make([]string, 0, len(model.CountryKeywords))
-	for k := range model.CountryKeywords {
-		keys = append(keys, k)
+func GetContryName(proxy model.Proxy) string {
+	// 创建一个切片包含所有的国家映射
+	countryMaps := []map[string]string{
+		model.CountryFlag,
+		model.CountryChineseName,
+		model.CountryISO,
+		model.CountryEnglishName,
 	}
-	sort.Strings(keys)
-	for _, k := range keys {
-		if strings.Contains(strings.ToLower(proxy.Name), strings.ToLower(k)) {
-			return model.CountryKeywords[k]
+
+	// 对每一个映射进行检查
+	for _, countryMap := range countryMaps {
+		for k, v := range countryMap {
+			if strings.Contains(proxy.Name, k) {
+				return v
+			}
 		}
 	}
+
 	return "其他地区"
 }
 
@@ -29,17 +35,18 @@ var skipGroups = map[string]bool{
 }
 
 func AddProxy(sub *model.Subscription, proxies ...model.Proxy) {
-	newContryNames := make([]string, 0, len(proxies))
-	for p := range proxies {
-		proxy := proxies[p]
+	newCountryGroupNames := make([]string, 0)
+
+	for _, proxy := range proxies {
 		sub.Proxies = append(sub.Proxies, proxy)
+
 		haveProxyGroup := false
+		countryName := GetContryName(proxy)
+
 		for i := range sub.ProxyGroups {
 			group := &sub.ProxyGroups[i]
-			groupName := []rune(group.Name)
-			proxyName := []rune(proxy.Name)
 
-			if string(groupName[:2]) == string(proxyName[:2]) || GetContryCode(proxy) == group.Name {
+			if group.Name == countryName {
 				group.Proxies = append(group.Proxies, proxy.Name)
 				haveProxyGroup = true
 			}
@@ -48,28 +55,25 @@ func AddProxy(sub *model.Subscription, proxies ...model.Proxy) {
 				group.Proxies = append(group.Proxies, proxy.Name)
 			}
 		}
+
 		if !haveProxyGroup {
-			contryCode := GetContryCode(proxy)
 			newGroup := model.ProxyGroup{
-				Name:    contryCode,
-				Type:    "select",
-				Proxies: []string{proxy.Name},
+				Name:          countryName,
+				Type:          "select",
+				Proxies:       []string{proxy.Name},
+				IsCountryGrop: true,
 			}
-			newContryNames = append(newContryNames, contryCode)
 			sub.ProxyGroups = append(sub.ProxyGroups, newGroup)
+			newCountryGroupNames = append(newCountryGroupNames, countryName)
 		}
 	}
-	newContryNamesMap := make(map[string]bool)
-	for _, n := range newContryNames {
-		newContryNamesMap[n] = true
-	}
+
 	for i := range sub.ProxyGroups {
-		if !skipGroups[sub.ProxyGroups[i].Name] && !newContryNamesMap[sub.ProxyGroups[i].Name] {
-			newProxies := make(
-				[]string, len(newContryNames), len(newContryNames)+len(sub.ProxyGroups[i].Proxies),
-			)
-			copy(newProxies, newContryNames)
-			sub.ProxyGroups[i].Proxies = append(newProxies, sub.ProxyGroups[i].Proxies...)
+		if sub.ProxyGroups[i].IsCountryGrop {
+			continue
+		}
+		if !skipGroups[sub.ProxyGroups[i].Name] {
+			sub.ProxyGroups[i].Proxies = append(newCountryGroupNames, sub.ProxyGroups[i].Proxies...)
 		}
 	}
 }

utils/rule.go

@@ -4,11 +4,11 @@ import (
 	"fmt"
 	"gopkg.in/yaml.v3"
 	"io"
-	"sub/model"
+	"sub2clash/model"
 )
 
 func AddRulesByUrl(sub *model.Subscription, url string, proxy string) {
-	get, err := GetWithRetry(url)
+	get, err := Get(url)
 	if err != nil {
 		fmt.Println(err)
 		return

utils/sub.go

@@ -7,18 +7,20 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"sync"
 	"time"
 )
 
 var subsDir = "subs"
+var fileLock sync.RWMutex
 
 func LoadSubscription(url string, refresh bool) ([]byte, error) {
 	if refresh {
 		return FetchSubscriptionFromAPI(url)
 	}
 	hash := md5.Sum([]byte(url))
-	fileName := filepath.Join(subsDir, hex.EncodeToString(hash[:])+".yaml")
-	const refreshInterval = 5 * 60 // 5分钟
+	fileName := filepath.Join(subsDir, hex.EncodeToString(hash[:]))
+	const refreshInterval = 500 * 60 // 5分钟
 	stat, err := os.Stat(fileName)
 	if err != nil {
 		if !os.IsNotExist(err) {
@@ -38,6 +40,8 @@ func LoadSubscription(url string, refresh bool) ([]byte, error) {
 				fmt.Println(err)
 			}
 		}(file)
+		fileLock.RLock()
+		defer fileLock.RUnlock()
 		subContent, err := io.ReadAll(file)
 		if err != nil {
 			return nil, err
@@ -49,17 +53,12 @@ func LoadSubscription(url string, refresh bool) ([]byte, error) {
 
 func FetchSubscriptionFromAPI(url string) ([]byte, error) {
 	hash := md5.Sum([]byte(url))
-	fileName := filepath.Join(subsDir, hex.EncodeToString(hash[:])+".yaml")
-	resp, err := GetWithRetry(url)
+	fileName := filepath.Join(subsDir, hex.EncodeToString(hash[:]))
+	resp, err := Get(url)
 	if err != nil {
 		return nil, err
 	}
-	defer func(Body io.ReadCloser) {
-		err := Body.Close()
-		if err != nil {
-			fmt.Println(err)
-		}
-	}(resp.Body)
+	defer resp.Body.Close()
 	data, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read response body: %w", err)
@@ -74,6 +73,8 @@ func FetchSubscriptionFromAPI(url string) ([]byte, error) {
 			fmt.Println(err)
 		}
 	}(file)
+	fileLock.Lock()
+	defer fileLock.Unlock()
 	_, err = file.Write(data)
 	if err != nil {
 		return nil, fmt.Errorf("failed to write to sub.yaml: %w", err)