feat: 统一使用 CDN

Author: qianmoQ

src-tauri/src/env_providers/clojure.rs

@@ -1,3 +1,4 @@
+use super::metadata::{Metadata, fetch_metadata_from_cdn, is_cdn_enabled, is_fallback_enabled};
 use crate::env_manager::{
     DownloadStatus, EnvironmentProvider, EnvironmentVersion, emit_download_progress,
 };
@@ -22,25 +23,6 @@ struct GithubAsset {
     size: u64,
 }
 
-// CDN Metadata 结构
-#[derive(Debug, Deserialize, Serialize, Clone)]
-struct MetadataRelease {
-    version: String,                  // 版本号，如 "1.11.1.1262"
-    display_name: String,             // 显示名称，如 "Clojure 1.11.1.1262"
-    published_at: String,             // 发布时间
-    download_url: String,             // CDN 下载地址
-    github_url: String,               // GitHub 官方下载地址（作为备用）
-    file_name: String,                // 文件名，如 "clojure-tools-1.11.1.1262.tar.gz"
-    size: u64,                        // 文件大小（字节）
-    supported_platforms: Vec<String>, // 支持的平台，如 ["macos", "linux", "windows"]
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-struct Metadata {
-    language: String, // 语言名称 "clojure"
-    releases: Vec<MetadataRelease>,
-}
-
 #[derive(Debug, Deserialize, Serialize)]
 struct CachedReleases {
     releases: Vec<GithubRelease>,
@@ -185,56 +167,6 @@ impl ClojureEnvironmentProvider {
         Ok(versions)
     }
 
-    // 从 CDN 获取 metadata.json
-    async fn fetch_metadata_from_cdn(&self) -> Result<Metadata, String> {
-        use crate::config::get_app_config_internal;
-
-        let config = get_app_config_internal().map_err(|e| format!("读取配置失败: {}", e))?;
-
-        let cdn_enabled = config
-            .environment_mirror
-            .as_ref()
-            .and_then(|m| m.enabled)
-            .unwrap_or(false);
-
-        if !cdn_enabled {
-            return Err("CDN 未启用".to_string());
-        }
-
-        let base_url = config
-            .environment_mirror
-            .as_ref()
-            .and_then(|m| m.base_url.as_ref())
-            .ok_or("CDN 地址未配置")?;
-
-        let metadata_url = format!("{}/clojure/metadata.json", base_url);
-        info!("从 CDN 获取 Clojure metadata: {}", metadata_url);
-
-        let client = reqwest::Client::builder()
-            .user_agent("CodeForge")
-            .timeout(Duration::from_secs(30))
-            .build()
-            .map_err(|e| format!("创建 HTTP 客户端失败: {}", e))?;
-
-        let response = client
-            .get(&metadata_url)
-            .send()
-            .await
-            .map_err(|e| format!("请求 CDN metadata 失败: {}", e))?;
-
-        if !response.status().is_success() {
-            return Err(format!("CDN 返回错误状态码: {}", response.status()));
-        }
-
-        let metadata: Metadata = response
-            .json()
-            .await
-            .map_err(|e| format!("解析 metadata.json 失败: {}", e))?;
-
-        info!("成功从 CDN 获取 {} 个版本", metadata.releases.len());
-        Ok(metadata)
-    }
-
     async fn fetch_github_releases(&self) -> Result<Vec<GithubRelease>, String> {
         if let Some(cached_releases) = self.read_cache() {
             return Ok(cached_releases);
@@ -636,30 +568,26 @@ impl EnvironmentProvider for ClojureEnvironmentProvider {
     }
 
     async fn fetch_available_versions(&self) -> Result<Vec<EnvironmentVersion>, String> {
-        use crate::config::get_app_config_internal;
-
-        // 优先尝试从 CDN 获取 metadata.json
-        match self.fetch_metadata_from_cdn().await {
-            Ok(metadata) => {
-                info!("使用 CDN metadata 获取版本列表");
-                return self.parse_metadata_to_versions(metadata);
-            }
-            Err(e) => {
-                warn!("CDN metadata 获取失败: {}", e);
+        // 检查 CDN 是否启用
+        if is_cdn_enabled() {
+            match fetch_metadata_from_cdn("clojure").await {
+                Ok(metadata) => {
+                    info!("使用 CDN metadata 获取版本列表");
+                    return self.parse_metadata_to_versions(metadata);
+                }
+                Err(e) => {
+                    warn!("CDN metadata 获取失败: {}", e);
 
-                // 检查是否启用 fallback
-                let fallback_enabled = get_app_config_internal()
-                    .ok()
-                    .and_then(|config| config.environment_mirror)
-                    .and_then(|mirror| mirror.fallback_enabled)
-                    .unwrap_or(false);
+                    // 检查是否启用 fallback
+                    if !is_fallback_enabled() {
+                        return Err(format!("CDN metadata 获取失败，未启用自动回退: {}", e));
+                    }
 
-                if !fallback_enabled {
-                    return Err(format!("CDN metadata 获取失败，未启用自动回退: {}", e));
+                    info!("fallback 已启用，回退到 GitHub API");
                 }
-
-                info!("fallback 已启用，回退到 GitHub API");
             }
+        } else {
+            info!("CDN 未启用，使用 GitHub API");
         }
 
         let releases = self.fetch_github_releases().await?;

src-tauri/src/env_providers/metadata.rs

@@ -0,0 +1,94 @@
+use log::info;
+use serde::{Deserialize, Serialize};
+
+// 通用的 CDN Metadata 结构
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct MetadataRelease {
+    pub version: String,
+    pub display_name: String,
+    pub published_at: String,
+    pub download_url: String,
+    pub github_url: String,
+    pub file_name: String,
+    pub size: u64,
+    #[serde(default)]
+    pub supported_platforms: Vec<String>,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct Metadata {
+    #[serde(default)]
+    pub language: String,
+    pub releases: Vec<MetadataRelease>,
+}
+
+// 通用的 CDN 配置检查函数
+pub fn is_cdn_enabled() -> bool {
+    use crate::config::get_app_config_internal;
+
+    get_app_config_internal()
+        .ok()
+        .and_then(|config| config.environment_mirror)
+        .and_then(|mirror| mirror.enabled)
+        .unwrap_or(false)
+}
+
+// 通用的 fallback 配置检查函数
+pub fn is_fallback_enabled() -> bool {
+    use crate::config::get_app_config_internal;
+
+    get_app_config_internal()
+        .ok()
+        .and_then(|config| config.environment_mirror)
+        .and_then(|mirror| mirror.fallback_enabled)
+        .unwrap_or(false)
+}
+
+// 通用的从 CDN 获取 metadata 函数
+pub async fn fetch_metadata_from_cdn(language: &str) -> Result<Metadata, String> {
+    use crate::config::get_app_config_internal;
+
+    let config = get_app_config_internal().map_err(|e| format!("读取配置失败: {}", e))?;
+
+    let cdn_enabled = config
+        .environment_mirror
+        .as_ref()
+        .and_then(|m| m.enabled)
+        .unwrap_or(false);
+
+    if !cdn_enabled {
+        return Err("CDN 未启用".to_string());
+    }
+
+    let base_url = config
+        .environment_mirror
+        .as_ref()
+        .and_then(|m| m.base_url.as_ref())
+        .ok_or("CDN 地址未配置")?;
+
+    let metadata_url = format!("{}/{}/metadata.json", base_url, language);
+    info!("从 CDN 获取 {} metadata: {}", language, metadata_url);
+
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(30))
+        .build()
+        .map_err(|e| format!("创建 HTTP 客户端失败: {}", e))?;
+
+    let response = client
+        .get(&metadata_url)
+        .send()
+        .await
+        .map_err(|e| format!("请求 CDN metadata 失败: {}", e))?;
+
+    if !response.status().is_success() {
+        return Err(format!("CDN 返回错误状态码: {}", response.status()));
+    }
+
+    let metadata: Metadata = response
+        .json()
+        .await
+        .map_err(|e| format!("解析 metadata.json 失败: {}", e))?;
+
+    info!("成功从 CDN 获取 {} 个版本", metadata.releases.len());
+    Ok(metadata)
+}

src-tauri/src/env_providers/mod.rs

@@ -1,4 +1,5 @@
 pub mod clojure;
+pub mod metadata;
 pub mod scala;
 
 pub use clojure::ClojureEnvironmentProvider;

src-tauri/src/env_providers/scala.rs

@@ -1,3 +1,4 @@
+use super::metadata::{Metadata, fetch_metadata_from_cdn, is_cdn_enabled, is_fallback_enabled};
 use crate::env_manager::{
     DownloadStatus, EnvironmentProvider, EnvironmentVersion, download_with_fallback,
     emit_download_progress,
@@ -250,6 +251,51 @@ impl ScalaEnvironmentProvider {
         false
     }
 
+    // 将 CDN metadata 转换为 EnvironmentVersion 列表
+    fn parse_metadata_to_versions(
+        &self,
+        metadata: Metadata,
+    ) -> Result<Vec<EnvironmentVersion>, String> {
+        let mut versions = Vec::new();
+
+        for release in metadata.releases {
+            let version = release.version.clone();
+            let is_installed = self.is_version_installed(&version);
+
+            // 如果已安装，查找实际的包含 bin 目录的路径
+            let install_path = if is_installed {
+                let version_dir = self.get_version_install_path(&version);
+                let mut actual_path = version_dir.clone();
+
+                if let Ok(entries) = std::fs::read_dir(&version_dir) {
+                    for entry in entries.flatten() {
+                        let path = entry.path();
+                        if path.is_dir() && path.join("bin").exists() {
+                            actual_path = path;
+                            break;
+                        }
+                    }
+                }
+
+                Some(actual_path.to_string_lossy().to_string())
+            } else {
+                None
+            };
+
+            versions.push(EnvironmentVersion {
+                version: version.clone(),
+                download_url: release.download_url.clone(),
+                fallback_url: Some(release.github_url.clone()),
+                install_path,
+                is_installed,
+                size: Some(release.size),
+                release_date: Some(release.published_at.clone()),
+            });
+        }
+
+        Ok(versions)
+    }
+
     // 下载文件并显示进度
     async fn download_file(
         &self,
@@ -464,6 +510,28 @@ impl EnvironmentProvider for ScalaEnvironmentProvider {
     }
 
     async fn fetch_available_versions(&self) -> Result<Vec<EnvironmentVersion>, String> {
+        // 检查 CDN 是否启用
+        if is_cdn_enabled() {
+            match fetch_metadata_from_cdn("scala").await {
+                Ok(metadata) => {
+                    info!("使用 CDN metadata 获取版本列表");
+                    return self.parse_metadata_to_versions(metadata);
+                }
+                Err(e) => {
+                    warn!("CDN metadata 获取失败: {}", e);
+
+                    // 检查是否启用 fallback
+                    if !is_fallback_enabled() {
+                        return Err(format!("CDN metadata 获取失败，未启用自动回退: {}", e));
+                    }
+
+                    info!("fallback 已启用，回退到 GitHub API");
+                }
+            }
+        } else {
+            info!("CDN 未启用，使用 GitHub API");
+        }
+
         let releases = self.fetch_github_releases().await?;
         let pattern = Self::get_download_pattern();