feat: add x_exec.container, build_deps, and checksum_bsum metadata

QaidVoid · QaidVoid · commit 2f0964f78e29 · 2026-02-18T09:44:58.000+05:45
diff --git a/sbuild-linter/src/build_config/mod.rs b/sbuild-linter/src/build_config/mod.rs
@@ -22,6 +22,7 @@ pub struct BuildConfig {
     pub app_id: Option<String>,
     pub build_util: Option<Vec<String>>,
     pub build_asset: Option<Vec<BuildAsset>>,
+    pub build_deps: Option<Vec<String>>,
     pub category: Vec<String>,
     pub description: Option<Description>,
     pub homepage: Option<Vec<String>>,
@@ -112,6 +113,14 @@ impl BuildConfig {
             }
         }
 
+        write_field_comments(writer, "build_deps")?;
+        if let Some(ref build_deps) = self.build_deps {
+            writeln!(writer, "{}build_deps:", indent_str)?;
+            for dep in build_deps {
+                writeln!(writer, "{}  - \"{}\"", indent_str, dep)?;
+            }
+        }
+
         write_field_comments(writer, "ghcr_pkg")?;
         if let Some(ref ghcr_pkg) = self.ghcr_pkg {
             writeln!(writer, "{}ghcr_pkg: \"{}\"", indent_str, ghcr_pkg)?;
diff --git a/sbuild-linter/src/validator.rs b/sbuild-linter/src/validator.rs
@@ -245,10 +245,17 @@ impl ValidationContext {
         let mut valid = true;
         let mut x_exec = XExec::default();
 
+        // container (optional)
+        if let Some(container_node) = Self::mapping_get(node, "container") {
+            if let Some(s) = self.expect_non_empty_string(container_node, "x_exec.container") {
+                x_exec.container = Some(s);
+            }
+        }
+
         // shell (required)
         if let Some(shell_node) = Self::mapping_get(node, "shell") {
             if let Some(s) = self.expect_non_empty_string(shell_node, "x_exec.shell") {
-                if which::which_global(&s).is_ok() {
+                if x_exec.container.is_some() || which::which_global(&s).is_ok() {
                     x_exec.shell = s;
                 } else {
                     self.error(
@@ -538,7 +545,7 @@ impl ValidationContext {
 
             if let Some(url_node) = Self::mapping_get(asset_node, "url") {
                 if let Some(u) = self.expect_non_empty_string(url_node, "build_asset.url") {
-                    if !is_valid_url(&u) {
+                    if !u.contains("${") && !is_valid_url(&u) {
                         self.error(
                             "build_asset.url",
                             &format!("'{}' is not a valid URL.", u),
@@ -698,6 +705,9 @@ impl ValidationContext {
                 "build_asset" => {
                     config.build_asset = self.validate_build_asset(val_node);
                 }
+                "build_deps" => {
+                    config.build_deps = self.expect_string_array(val_node, "build_deps", false);
+                }
                 "category" => {
                     if let Some(cats) = self.expect_string_array(val_node, "category", false) {
                         for c in &cats {
diff --git a/sbuild-linter/src/xexec.rs b/sbuild-linter/src/xexec.rs
@@ -12,6 +12,7 @@ pub struct XExec {
     pub depends: Option<Vec<String>>,
     pub entrypoint: Option<String>,
     pub pkgver: Option<String>,
+    pub container: Option<String>,
     pub shell: String,
     pub run: String,
 }
@@ -54,6 +55,10 @@ impl XExec {
             writeln!(writer, "{}entrypoint: \"{}\"", indent_str, entrypoint)?;
         }
 
+        if let Some(ref container) = self.container {
+            writeln!(writer, "{}container: \"{}\"", indent_str, container)?;
+        }
+
         writeln!(writer, "{}shell: \"{}\"", indent_str, self.shell)?;
 
         if let Some(ref pkgver) = self.pkgver {
diff --git a/sbuild-meta/src/metadata.rs b/sbuild-meta/src/metadata.rs
@@ -125,6 +125,9 @@ pub struct PackageMetadata {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub shasum: Option<String>,
 
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub checksum_bsum: Option<String>,
+
     // Build info
     #[serde(skip_serializing_if = "Option::is_none")]
     pub build_id: Option<String>,
@@ -317,6 +320,11 @@ impl PackageMetadata {
                 self.shasum = Some(shasum.to_string());
             }
         }
+        if self.checksum_bsum.is_none() {
+            if let Some(cb) = manifest.get_annotation("dev.pkgforge.soar.checksum_bsum") {
+                self.checksum_bsum = Some(cb.to_string());
+            }
+        }
 
         // Generate blob reference and download URLs
         let filenames = manifest.filenames();
@@ -408,6 +416,9 @@ impl PackageMetadata {
         if let Some(v) = get_str("shasum") {
             self.shasum = Some(v);
         }
+        if let Some(v) = get_str("checksum_bsum") {
+            self.checksum_bsum = Some(v);
+        }
         if let Some(v) = get_str("icon") {
             self.icon = Some(v);
         }
diff --git a/sbuild/src/builder.rs b/sbuild/src/builder.rs
@@ -28,7 +28,8 @@ use crate::{
     },
     types::{OutputStream, PackageType, SoarEnv},
     utils::{
-        calc_magic_bytes, download, is_static_elf, pack_appimage, self_extract_appimage, temp_file,
+        calc_magic_bytes, download, expand_env_vars, is_static_elf, pack_appimage,
+        self_extract_appimage, temp_file,
     },
 };
 
@@ -116,6 +117,14 @@ impl BuildContext {
         let existing_envs: Vec<(String, Option<String>)> =
             inherit_keys.iter().map(|key| get_env_var(key)).collect();
 
+        let arch = ARCH.to_string();
+        let arch_alt = match ARCH {
+            "x86_64" => "amd64",
+            "aarch64" => "arm64",
+            _ => ARCH,
+        }
+        .to_string();
+
         let paths = format!("{}:{}", soar_bin, paths);
         let mut vars: Vec<(String, String)> = [
             ("pkg", self.pkg.clone()),
@@ -128,6 +137,8 @@ impl BuildContext {
             ("pkg_ver", self.remote_pkgver.clone()),
             ("pkgver", self.pkgver.clone()),
             ("remote_pkgver", self.remote_pkgver.clone()),
+            ("arch", arch),
+            ("arch_alt", arch_alt),
         ]
         .into_iter()
         .flat_map(|(key, value)| {
@@ -188,15 +199,23 @@ impl Builder {
         }
     }
 
-    pub async fn download_build_assets(&mut self, build_assets: &[BuildAsset]) {
+    pub async fn download_build_assets(
+        &mut self,
+        build_assets: &[BuildAsset],
+        context: &BuildContext,
+    ) {
+        let env_vars = context.env_vars(&self.soar_env.bin_path);
         for asset in build_assets {
+            let url = expand_env_vars(&asset.url, &env_vars);
+            let out = expand_env_vars(&asset.out, &env_vars);
+
             self.logger
-                .info(format!("Downloading build asset from {}", asset.url));
+                .info(format!("Downloading build asset from {}", url));
 
-            let out_path = format!("SBUILD_TEMP/{}", asset.out);
-            if download(&asset.url, out_path).await.is_err() {
+            let out_path = out.to_string();
+            if download(&url, out_path).await.is_err() {
                 self.logger
-                    .error(format!("Failed to download build asset from {}", asset.url));
+                    .error(format!("Failed to download build asset from {}", url));
                 std::process::exit(1);
             };
         }
@@ -270,7 +289,9 @@ impl Builder {
 
         fs::create_dir_all(&context.tmpdir).unwrap();
 
-        if self.external {
+        let is_container = build_config.x_exec.container.is_some();
+
+        if self.external && !is_container {
             if let Some(build_utils) = build_config.build_util.clone() {
                 let mut child = Command::new("soar")
                     .env_clear()
@@ -291,17 +312,54 @@ impl Builder {
         }
 
         if let Some(ref build_assets) = build_config.build_asset {
-            self.download_build_assets(build_assets).await;
+            self.download_build_assets(build_assets, context).await;
         }
 
-        let mut child = Command::new(&exec_file)
-            .env_clear()
-            .envs(context.env_vars(&self.soar_env.bin_path))
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .stdin(Stdio::null())
-            .spawn()
-            .unwrap();
+        let mut child = if let Some(ref container) = build_config.x_exec.container {
+            let image = if container.contains(':') {
+                container.clone()
+            } else {
+                format!("{}:{}", container, ARCH)
+            };
+
+            let env_vars = context.env_vars(&self.soar_env.bin_path);
+            let mut cmd = Command::new("docker");
+            cmd.args(["run", "--rm", "--privileged", "--net=host", "--pull=always"]);
+
+            for (key, value) in &env_vars {
+                if key == "PATH" {
+                    continue;
+                }
+                let val = match key.as_str() {
+                    "sbuild_outdir" | "SBUILD_OUTDIR" => "/sbuild".to_string(),
+                    "sbuild_tmpdir" | "SBUILD_TMPDIR" => "/sbuild/SBUILD_TEMP".to_string(),
+                    _ => value.clone(),
+                };
+                cmd.arg("-e").arg(format!("{}={}", key, val));
+            }
+
+            cmd.args(["-v", &format!("{}:/sbuild:rw", context.outdir.display())]);
+            cmd.args(["-v", &format!("{}:/exec_script:ro", exec_file)]);
+            cmd.args(["-w", "/sbuild"]);
+            cmd.arg(&image);
+            cmd.arg("/exec_script");
+
+            cmd.env_clear()
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .stdin(Stdio::null())
+                .spawn()
+                .unwrap()
+        } else {
+            Command::new(&exec_file)
+                .env_clear()
+                .envs(context.env_vars(&self.soar_env.bin_path))
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .stdin(Stdio::null())
+                .spawn()
+                .unwrap()
+        };
 
         if let Err(err) = self.prepare_resources(&build_config, context).await {
             self.logger.warn(&err);
diff --git a/sbuild/src/commands/build.rs b/sbuild/src/commands/build.rs
@@ -577,6 +577,15 @@ async fn post_build_processing(
                         (None, None, None)
                     };
 
+                    let checksum_bsum = {
+                        let checksum_path = pkg_dir.join("CHECKSUM");
+                        if checksum_path.exists() {
+                            checksum::b3sum(&checksum_path).ok()
+                        } else {
+                            None
+                        }
+                    };
+
                     let ghcr_total_size: u64 = files_to_push
                         .iter()
                         .filter_map(|f| fs::metadata(f).ok().map(|m| m.len()))
@@ -591,6 +600,7 @@ async fn post_build_processing(
                             &tag,
                             bsum.as_deref(),
                             shasum.as_deref(),
+                            checksum_bsum.as_deref(),
                             binary_size,
                             Some(ghcr_total_size),
                         ) {
@@ -627,6 +637,7 @@ async fn post_build_processing(
                         build_script: recipe_url.map(|s| s.to_string()),
                         bsum,
                         shasum,
+                        checksum_bsum,
                     };
 
                     if cli.dry_run {
@@ -799,6 +810,15 @@ async fn post_build_processing(
                         (None, None, None)
                     };
 
+                    let checksum_bsum = {
+                        let checksum_path = outdir.join("CHECKSUM");
+                        if checksum_path.exists() {
+                            checksum::b3sum(&checksum_path).ok()
+                        } else {
+                            None
+                        }
+                    };
+
                     let ghcr_total_size: u64 = files_to_push
                         .iter()
                         .filter_map(|f| fs::metadata(f).ok().map(|m| m.len()))
@@ -813,6 +833,7 @@ async fn post_build_processing(
                             &tag,
                             bsum.as_deref(),
                             shasum.as_deref(),
+                            checksum_bsum.as_deref(),
                             binary_size,
                             Some(ghcr_total_size),
                         ) {
@@ -849,6 +870,7 @@ async fn post_build_processing(
                         build_script: recipe_url.map(|s| s.to_string()),
                         bsum,
                         shasum,
+                        checksum_bsum,
                     };
 
                     if cli.dry_run {
diff --git a/sbuild/src/ghcr.rs b/sbuild/src/ghcr.rs
@@ -42,6 +42,8 @@ pub struct PackageAnnotations {
     pub bsum: Option<String>,
     /// SHA256 checksum of the main binary
     pub shasum: Option<String>,
+    /// BLAKE3 checksum of the CHECKSUM file
+    pub checksum_bsum: Option<String>,
 }
 
 /// GHCR client for pushing packages
@@ -212,6 +214,12 @@ impl GhcrClient {
         if let Some(ref shasum) = meta.shasum {
             annotations.insert("dev.pkgforge.soar.shasum".to_string(), shasum.clone());
         }
+        if let Some(ref checksum_bsum) = meta.checksum_bsum {
+            annotations.insert(
+                "dev.pkgforge.soar.checksum_bsum".to_string(),
+                checksum_bsum.clone(),
+            );
+        }
 
         annotations
     }
diff --git a/sbuild/src/lib.rs b/sbuild/src/lib.rs
@@ -50,6 +50,7 @@ pub fn update_json_metadata(
     tag: &str,
     bsum: Option<&str>,
     shasum: Option<&str>,
+    checksum_bsum: Option<&str>,
     binary_size: Option<u64>,
     ghcr_total_size: Option<u64>,
 ) -> Result<(), String> {
@@ -86,6 +87,9 @@ pub fn update_json_metadata(
         if let Some(s) = shasum {
             obj.insert("shasum".to_string(), serde_json::json!(s));
         }
+        if let Some(cb) = checksum_bsum {
+            obj.insert("checksum_bsum".to_string(), serde_json::json!(cb));
+        }
 
         if let Some(s) = binary_size {
             obj.insert("size".to_string(), serde_json::json!(format_size(s)));
diff --git a/sbuild/src/utils.rs b/sbuild/src/utils.rs
@@ -185,3 +185,11 @@ pub fn is_static_elf<P: AsRef<Path>>(file_path: P) -> bool {
     let elf = Elf::parse(&mmap).unwrap();
     elf.interpreter.is_none()
 }
+
+pub fn expand_env_vars(input: &str, vars: &[(String, String)]) -> String {
+    let mut result = input.to_string();
+    for (key, value) in vars {
+        result = result.replace(&format!("${{{}}}", key), value);
+    }
+    result
+}

Original file line number	Diff line number	Diff line change
`@@ -42,6 +42,8 @@ pub struct PackageAnnotations {`
`42`	`42`	`pub bsum: Option<String>,`
`43`	`43`	`/// SHA256 checksum of the main binary`
`44`	`44`	`pub shasum: Option<String>,`
	`45`	`+ /// BLAKE3 checksum of the CHECKSUM file`
	`46`	`+ pub checksum_bsum: Option<String>,`
`45`	`47`	`}`
`46`	`48`
`47`	`49`	`/// GHCR client for pushing packages`
`@@ -212,6 +214,12 @@ impl GhcrClient {`
`212`	`214`	`if let Some(ref shasum) = meta.shasum {`
`213`	`215`	`annotations.insert("dev.pkgforge.soar.shasum".to_string(), shasum.clone());`
`214`	`216`	`}`
	`217`	`+ if let Some(ref checksum_bsum) = meta.checksum_bsum {`
	`218`	`+ annotations.insert(`
	`219`	`+ "dev.pkgforge.soar.checksum_bsum".to_string(),`
	`220`	`+ checksum_bsum.clone(),`
	`221`	`+ );`
	`222`	`+ }`
`215`	`223`
`216`	`224`	`annotations`
`217`	`225`	`}`