refactor: 重构 chromium 的下载逻辑。

hamflx · hamflx · commit 9ab16e8a33cc · 2023-02-12T23:22:30.000+08:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -4,7 +4,6 @@ version = "0.1.1"
 edition = "2021"
 authors = ["hamflx <a@hamflx.cn>"]
 license = "MIT"
-license-file = "LICENSE"
 
 [[bin]]
 name = "fb"
diff --git a/src/chromium/builds.rs b/src/chromium/builds.rs
@@ -96,6 +96,18 @@ impl Iterator for ChromiumBuildsPage {
     }
 }
 
+pub(crate) fn fetch_build_detail(prefix: &str) -> Result<Vec<GoogleApiStorageObject>> {
+    let url = format!("https://www.googleapis.com/storage/v1/b/chromium-browser-snapshots/o?delimiter=/&prefix={prefix}&fields=items(kind,mediaLink,metadata,name,size,updated),kind,prefixes,nextPageToken");
+    println!("==> fetching history {url} ...");
+    let response = reqwest::blocking::get(url)?;
+    let build_detail: ChromiumBuildPage = serde_json::from_reader(response)?;
+    println!("==> files:");
+    for file in &build_detail.items {
+        println!("    {}", file.name);
+    }
+    Ok(build_detail.items)
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct ChromiumBuildPage {
diff --git a/src/chromium/download.rs b/src/chromium/download.rs
@@ -0,0 +1,74 @@
+use std::{fs::OpenOptions, io::copy, path::Path};
+
+use anyhow::anyhow;
+use zip::read::read_zipfile_from_stream;
+
+use super::builds::GoogleApiStorageObject;
+
+pub(crate) fn download_chromium_zip_file(
+    zip_file: &GoogleApiStorageObject,
+    base_path: &Path,
+) -> std::result::Result<(), anyhow::Error> {
+    // 开始下载压缩文件。
+    println!("==> downloading {}", zip_file.media_link);
+    let mut win_zip_response = reqwest::blocking::get(&zip_file.media_link)?;
+
+    loop {
+        let mut zip = match read_zipfile_from_stream(&mut win_zip_response) {
+            Ok(Some(zip)) => zip,
+            Ok(None) => break,
+            Err(err) => return Err(anyhow!("读取压缩文件出错：{:?}", err)),
+        };
+
+        let zip_name = zip.name();
+        println!("==> unzip: {zip_name}");
+
+        if zip_name.starts_with("chrome-win/")
+            || zip_name.starts_with("chrome-win32/")
+            || zip_name.starts_with("chrome-mac/")
+            || zip_name.starts_with("chrome-linux/")
+        {
+            let prefix_len = zip_name.find('/').unwrap() + 1;
+            let file_path = base_path.join(&zip_name[prefix_len..]);
+            if zip.is_dir() {
+                std::fs::create_dir_all(&file_path).map_err(|err| {
+                    anyhow!(
+                        "创建目录 {} 时出错：{:?}",
+                        file_path.to_str().unwrap_or_default(),
+                        err
+                    )
+                })?;
+            } else {
+                if let Some(parent_dir) = file_path.parent() {
+                    let _ = std::fs::create_dir_all(parent_dir);
+                }
+                copy(
+                    &mut zip,
+                    &mut OpenOptions::new()
+                        .write(true)
+                        .truncate(true)
+                        .create(true)
+                        .open(&file_path)
+                        .map_err(|err| {
+                            anyhow!(
+                                "解压文件 {} 时出错：{:?}",
+                                file_path.to_str().unwrap_or_default(),
+                                err
+                            )
+                        })?,
+                )
+                .map_err(|err| {
+                    anyhow!(
+                        "解压文件 {} 时出错：{:?}",
+                        file_path.to_str().unwrap_or_default(),
+                        err
+                    )
+                })?;
+            }
+        } else {
+            return Err(anyhow!("压缩包文件结构不正确。"));
+        }
+    }
+
+    Ok(())
+}
diff --git a/src/chromium/history.rs b/src/chromium/history.rs
diff --git a/src/chromium/mod.rs b/src/chromium/mod.rs
@@ -0,0 +1,132 @@
+use std::vec::IntoIter;
+
+use anyhow::{anyhow, Result};
+
+use crate::{
+    common::{BrowserReleaseItem, BrowserReleases},
+    platform::Platform,
+};
+
+use self::{
+    builds::{fetch_build_detail, ChromiumBuilds},
+    download::download_chromium_zip_file,
+    history::{ChromiumHistory, ChromiumHistoryInfo},
+};
+
+mod builds;
+mod download;
+mod history;
+mod version;
+
+pub(crate) struct ChromiumReleases {
+    platform: Platform,
+    history: ChromiumHistory,
+    builds: ChromiumBuilds,
+}
+
+impl BrowserReleases for ChromiumReleases {
+    type ReleaseItem = ChromiumReleaseItem;
+    type Matches<'r> = ChromiumReleaseMatches<'r>;
+
+    fn init(platform: Platform) -> anyhow::Result<Self>
+    where
+        Self: Sized,
+    {
+        // history.json 包含了 base_position 和版本号。
+        let history = ChromiumHistory::init(platform)?;
+        // builds 包含了所有可下载的 position 信息。
+        let builds = ChromiumBuilds::init(platform)?;
+        Ok(Self {
+            platform,
+            history,
+            builds,
+        })
+    }
+
+    fn match_version<'r>(&'r self, version: &str) -> Self::Matches<'r> {
+        ChromiumReleaseMatches::new(self, self.history.find(version))
+    }
+}
+
+pub(crate) struct ChromiumReleaseMatches<'r> {
+    iter: IntoIter<&'r ChromiumHistoryInfo>,
+    releases: &'r ChromiumReleases,
+    prefix: &'static str,
+}
+
+impl<'r> ChromiumReleaseMatches<'r> {
+    fn new(releases: &'r ChromiumReleases, items: Vec<&'r ChromiumHistoryInfo>) -> Self {
+        let prefix = releases.platform.prefix();
+        Self {
+            releases,
+            iter: items.into_iter(),
+            prefix,
+        }
+    }
+}
+
+impl<'r> Iterator for ChromiumReleaseMatches<'r> {
+    type Item = Result<ChromiumReleaseItem>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        for history in self.iter.by_ref() {
+            let deps = match history.deps() {
+                Ok(deps) => deps,
+                Err(err) => return Some(Err(err)),
+            };
+            match deps.chromium_base_position {
+                Some(pos) => match pos.parse::<usize>() {
+                    Ok(pos) => match self.releases.builds.find(pos, self.prefix) {
+                        Some(rev_prefix) => {
+                            return Some(Ok(ChromiumReleaseItem {
+                                rev_prefix: rev_prefix.clone(),
+                                version: deps.chromium_version,
+                            }))
+                        }
+                        None => println!("==> no build found for rev: {pos}"),
+                    },
+                    Err(err) => println!(
+                        "==> chromium {}: parse base_position error: {:?}",
+                        deps.chromium_version, err
+                    ),
+                },
+                None => println!(
+                    "==> chromium {}: no chromium_base_position.",
+                    deps.chromium_version
+                ),
+            }
+        }
+        None
+    }
+}
+
+pub(crate) struct ChromiumReleaseItem {
+    rev_prefix: String,
+    version: String,
+}
+
+impl BrowserReleaseItem for ChromiumReleaseItem {
+    fn download(&self) -> Result<()> {
+        // 根据 prefix 找到该版本文件列表，以及 chrome-win.zip 文件信息。
+        let build_files = fetch_build_detail(&self.rev_prefix)?;
+        let zip_file = [
+            "chrome-win.zip",
+            "chrome-win32.zip",
+            "chrome-mac.zip",
+            "chrome-linux.zip",
+        ]
+        .into_iter()
+        .find_map(|f| build_files.iter().find(|file| file.name.ends_with(f)))
+        .ok_or_else(|| {
+            anyhow!(
+                "在版本 {} 中，未找到 chrome-win.zip/chrome-win32-zip/chrome-mac.zip。",
+                self.rev_prefix
+            )
+        })?;
+
+        // 先保存到临时目录里面，待解压的时候，找到里面的版本信息，再重命名一下文件夹。
+        let base_path = std::env::current_dir()?.join(format!("chromium-{}", self.version));
+        std::fs::create_dir_all(&base_path)?;
+        download_chromium_zip_file(zip_file, &base_path)
+    }
+}
diff --git a/src/chromium/version.rs b/src/chromium/version.rs
diff --git a/src/common.rs b/src/common.rs
@@ -0,0 +1,20 @@
+use anyhow::Result;
+
+use crate::platform::Platform;
+
+pub(crate) trait BrowserReleases {
+    type ReleaseItem: BrowserReleaseItem;
+    type Matches<'r>: Iterator<Item = Result<Self::ReleaseItem>>
+    where
+        Self: 'r;
+
+    fn init(platform: Platform) -> Result<Self>
+    where
+        Self: Sized;
+
+    fn match_version<'r>(&'r self, version: &str) -> Self::Matches<'r>;
+}
+
+pub(crate) trait BrowserReleaseItem {
+    fn download(&self) -> Result<()>;
+}
diff --git a/src/firefox/mod.rs b/src/firefox/mod.rs
@@ -10,7 +10,7 @@ use select::{
 
 use crate::utils::{find_sequence, get_cached_file_path};
 
-pub(crate) fn download_ff(version: &str) -> Result<()> {
+pub(crate) fn download_firefox(version: &str) -> Result<()> {
     let cur_dir = current_dir()?;
 
     let spider = FirefoxVersionSpider::init()?;
@@ -19,9 +19,9 @@ pub(crate) fn download_ff(version: &str) -> Result<()> {
         .first()
         .ok_or_else(|| anyhow!("No matched version found"))?;
 
-    let zip_content = download_ff_zip(matched_version, "win64").or_else(|err| {
+    let zip_content = download_firefox_zip(matched_version, "win64").or_else(|err| {
         println!("==> download firefox win64 failed: {err}, trying win32 ...");
-        download_ff_zip(matched_version, "win32")
+        download_firefox_zip(matched_version, "win32")
     })?;
 
     let base_path = cur_dir.join(format!(".tmp-firefox-{matched_version}"));
@@ -46,7 +46,7 @@ pub(crate) fn download_ff(version: &str) -> Result<()> {
     Ok(())
 }
 
-pub(crate) fn download_ff_zip(version: &str, arch: &str) -> Result<Bytes> {
+fn download_firefox_zip(version: &str, arch: &str) -> Result<Bytes> {
     let cur_dir = current_dir()?;
     let url = format!(
         "https://ftp.mozilla.org/pub/firefox/releases/{version}/{arch}/zh-CN/Firefox%20Setup%20{version}.exe"
@@ -72,10 +72,10 @@ pub(crate) fn download_ff_zip(version: &str, arch: &str) -> Result<Bytes> {
 }
 
 #[derive(Debug)]
-pub(crate) struct FirefoxVersionSpider(Vec<String>);
+struct FirefoxVersionSpider(Vec<String>);
 
 impl FirefoxVersionSpider {
-    pub(crate) fn init() -> Result<Self> {
+    fn init() -> Result<Self> {
         let cached_releases_path = get_cached_file_path("firefox-releases.json")?;
         if cached_releases_path.exists() {
             println!("==> using cached firefox releases");
@@ -93,7 +93,7 @@ impl FirefoxVersionSpider {
                         .descendant(predicate::Name("a")),
                 )
                 .map(|node| node.text().trim_end_matches('/').to_owned())
-                .filter(|name| is_valid_version(name.as_str()))
+                .filter(|name| is_valid_ff_version(name.as_str()))
                 .collect::<Vec<_>>();
 
             std::fs::write(&cached_releases_path, serde_json::to_string(&releases)?)?;
@@ -102,7 +102,7 @@ impl FirefoxVersionSpider {
         }
     }
 
-    pub(crate) fn find(&self, version: &str) -> Vec<&String> {
+    fn find(&self, version: &str) -> Vec<&String> {
         let mut matched_list = self
             .0
             .iter()
@@ -127,7 +127,7 @@ impl FirefoxVersionSpider {
     }
 }
 
-pub(crate) fn is_valid_version(version: &str) -> bool {
+fn is_valid_ff_version(version: &str) -> bool {
     let mut split = version.split('.');
     match (split.next(), split.next()) {
         (Some(first), Some(second)) => {
diff --git a/src/main.rs b/src/main.rs
