feat: check the archive.json version before using CEF_PATH cached

archive

Author: wravery

download-cef/Cargo.toml

@@ -9,8 +9,10 @@ authors.workspace = true
 repository.workspace = true
 
 [dependencies]
+regex.workspace = true
 semver.workspace = true
 serde.workspace = true
+serde_json.workspace = true
 thiserror.workspace = true
 
 bzip2 = "0.6"

download-cef/src/lib.rs

@@ -1,14 +1,15 @@
 #![doc = include_str!("../README.md")]
 
 use bzip2::bufread::BzDecoder;
+use regex::Regex;
 use semver::Version;
 use serde::{Deserialize, Serialize};
 use sha1_smol::Sha1;
 use std::{
     collections::HashMap,
     fmt::{self, Display},
     fs::{self, File},
-    io::{self, BufReader, IsTerminal},
+    io::{self, BufReader, IsTerminal, Write},
     path::{Path, PathBuf},
     sync::{Mutex, OnceLock},
 };
@@ -40,6 +41,18 @@ pub enum Error {
     CorruptedFile(String),
     #[error("Invalid archive file path: {0}")]
     InvalidArchiveFile(String),
+    #[error("JSON serialization error: {0}")]
+    Json(#[from] serde_json::Error),
+    #[error(
+        "Undexpected archive version: location: {location} archive {archive} expected {expected}"
+    )]
+    VersionMismatch {
+        location: String,
+        archive: String,
+        expected: String,
+    },
+    #[error("Invalid regex pattern: {0}")]
+    InvalidRegexPattern(#[from] regex::Error),
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -59,20 +72,55 @@ pub const WINDOWS_TARGETS: &[&str] = &[
 ];
 
 pub fn default_version(version: &str) -> String {
-    static VERSIONS: OnceLock<Mutex<HashMap<String, String>>> = OnceLock::new();
+    unwrap_cef_version(version).unwrap_or_else(|_| version.to_string())
+}
+
+fn unwrap_cef_version(version: &str) -> Result<String> {
+    static VERSIONS: OnceLock<Mutex<HashMap<Version, String>>> = OnceLock::new();
     let mut versions = VERSIONS
         .get_or_init(Default::default)
         .lock()
         .expect("Lock error");
-    versions
-        .entry(version.to_string())
-        .or_insert_with(|| {
-            Version::parse(version)
-                .ok()
-                .and_then(|version| (!version.build.is_empty()).then(|| version.build.to_string()))
-                .unwrap_or_else(|| version.to_string())
+    Ok(versions
+        .entry(Version::parse(version)?)
+        .or_insert_with_key(|v| {
+            if v.build.is_empty() {
+                version.to_string()
+            } else {
+                v.build.to_string()
+            }
         })
-        .clone()
+        .clone())
+}
+
+pub fn check_archive_json(version: &str, location: &str) -> Result<()> {
+    let expected = Version::parse(&unwrap_cef_version(version)?)?;
+
+    static PATTERN: OnceLock<core::result::Result<Regex, regex::Error>> = OnceLock::new();
+    let pattern = PATTERN
+        .get_or_init(|| Regex::new(r"^cef_binary_([^+]+)(:?\+.+)?$"))
+        .as_ref()
+        .map_err(Clone::clone)?;
+    let archive_json: CefFile = serde_json::from_reader(File::open(archive_json_path(location))?)?;
+    let archive_version = pattern.replace(&archive_json.name, "$1");
+    let archive = Version::parse(&archive_version)?;
+
+    if archive == expected {
+        Ok(())
+    } else {
+        Err(Error::VersionMismatch {
+            location: location.to_string(),
+            expected: expected.to_string(),
+            archive: archive.to_string(),
+        })
+    }
+}
+
+fn archive_json_path<P>(location: P) -> PathBuf
+where
+    P: AsRef<Path>,
+{
+    location.as_ref().join("archive.json")
 }
 
 const URL: &str = "https://cef-builds.spotifycdn.com";
@@ -230,9 +278,19 @@ impl CefVersion {
             .find(|f| f.file_type == "minimal")
             .ok_or_else(|| Error::VersionNotFound(self.cef_version.clone()))
     }
+
+    pub fn write_archive_json<P>(&self, location: P) -> Result<()>
+    where
+        P: AsRef<Path>,
+    {
+        let archive_version = serde_json::to_string_pretty(self.minimal()?)?;
+        let mut archive_json = File::create(archive_json_path(location))?;
+        archive_json.write_all(archive_version.as_bytes())?;
+        Ok(())
+    }
 }
 
-#[derive(Deserialize, Serialize)]
+#[derive(Eq, PartialEq, Deserialize, Serialize)]
 pub struct CefFile {
     #[serde(rename = "type")]
     pub file_type: String,

export-cef-dir/src/main.rs

@@ -2,12 +2,7 @@
 
 use clap::Parser;
 use download_cef::{CefIndex, OsAndArch, DEFAULT_TARGET};
-use std::{
-    fs::{self, File},
-    io::Write,
-    path::PathBuf,
-    sync::OnceLock,
-};
+use std::{fs, path::PathBuf, sync::OnceLock};
 
 fn default_version() -> &'static str {
     static DEFAULT_VERSION: OnceLock<String> = OnceLock::new();
@@ -91,11 +86,7 @@ fn main() -> anyhow::Result<()> {
         fs::remove_file(archive)?;
     }
 
-    {
-        let archive_version = serde_json::to_string_pretty(version.minimal()?)?;
-        let mut archive_json = File::create(extracted_dir.join("archive.json"))?;
-        archive_json.write_all(archive_version.as_bytes())?;
-    }
+    version.write_archive_json(extracted_dir)?;
 
     if output != cef_dir {
         println!("Renaming: {}", output.display());

sys/Cargo.toml

@@ -16,7 +16,7 @@ doctest = false
 dox = []
 
 [package.metadata.docs.rs]
-features = [ "dox" ]
+features = ["dox"]
 
 [build-dependencies]
 anyhow.workspace = true

sys/build.rs

@@ -1,12 +1,7 @@
 #[cfg(not(feature = "dox"))]
 fn main() -> anyhow::Result<()> {
     use download_cef::{CefIndex, OsAndArch};
-    use std::{
-        env,
-        fs::{self, File},
-        io::Write,
-        path::PathBuf,
-    };
+    use std::{env, fs, path::PathBuf};
 
     println!("cargo::rerun-if-changed=build.rs");
 
@@ -23,6 +18,7 @@ fn main() -> anyhow::Result<()> {
         Ok(cef_path) => {
             // Allow overriding the CEF path with environment variables.
             println!("Using CEF path from environment: {cef_path}");
+            download_cef::check_archive_json(&env::var("CARGO_PKG_VERSION")?, &cef_path)?;
             PathBuf::from(cef_path)
         }
         Err(_) => {
@@ -45,9 +41,7 @@ fn main() -> anyhow::Result<()> {
                     ));
                 }
 
-                let archive_version = serde_json::to_string_pretty(version.minimal()?)?;
-                let mut archive_json = File::create(extracted_dir.join("archive.json"))?;
-                archive_json.write_all(archive_version.as_bytes())?;
+                version.write_archive_json(extracted_dir)?;
             }
 
             cef_dir