fix: set correct architecture for package

Author: Arvid Gerstmann

src/generator.rs

@@ -4,11 +4,22 @@ use anyhow::Context;
 
 use crate::cargo_schema::CargoManifest;
 use crate::nfpm_schema;
+use crate::triple::LlvmTriple;
+
+#[derive(Debug, Clone, Copy, clap::ValueEnum)]
+pub enum OutputFormat {
+    Apk,
+    Archlinux,
+    Deb,
+    Ipk,
+    Rpm,
+}
 
 pub fn get_config_from_metadata(
     _metadata: &cargo_metadata::Metadata,
     package: &cargo_metadata::Package,
     triple: &str,
+    format: OutputFormat,
 ) -> anyhow::Result<nfpm_schema::Config> {
     let manifest_str =
         std::fs::read_to_string(&package.manifest_path).context("reading Cargo.toml manifest")?;
@@ -24,7 +35,14 @@ pub fn get_config_from_metadata(
     merge_base_config_with_package(package, &mut base_config)
         .context("merging config with manifest values")?;
 
-    base_config.arch = Some(triple_to_goarch(triple)?);
+    let parsed = LlvmTriple::new(triple).context("parsing cargo target triple")?;
+    base_config.arch = match format {
+        OutputFormat::Apk => Some(parsed.to_apk_arch()?.to_owned()),
+        OutputFormat::Archlinux => Some(parsed.to_archlinux_arch()?.to_owned()),
+        OutputFormat::Deb => Some(parsed.to_deb_arch()?.to_owned()),
+        OutputFormat::Ipk => Some(parsed.to_ipk_arch()?.to_owned()),
+        OutputFormat::Rpm => Some(parsed.to_rpm_arch()?.to_owned()),
+    };
 
     // Set some sane defaults.
     if base_config.epoch.is_none() {
@@ -50,22 +68,6 @@ pub fn get_config_from_metadata(
     Ok(base_config)
 }
 
-/// Triple must follow the general format from LLVM:
-///
-/// The triple has the format `<arch><sub>-<vendor>-<sys>-<env>`
-fn triple_to_goarch(triple: &str) -> anyhow::Result<String> {
-    let (arch, _) = triple.split_once('-').context("triple malformed")?;
-    let goarch = match arch {
-        "aarch64" | "arm64" | "arm64e" => "arm64",
-        "i686" => "386",
-        "x86_64" => "amd64",
-        "arm" | "armv6" | "armv6k" | "armv7" | "armv7k" | "armv7s" | "armv7a" => "arm",
-        arch => return Err(anyhow::anyhow!("unsupported arch: {arch}")),
-    };
-
-    Ok(goarch.to_owned())
-}
-
 fn merge_base_config_with_package(
     package: &cargo_metadata::Package,
     config: &mut nfpm_schema::Config,

src/lib.rs

@@ -5,3 +5,4 @@ pub mod cargo_schema;
 pub mod generator;
 pub mod nfpm;
 pub mod nfpm_schema;
+pub mod triple;

src/main.rs

@@ -2,7 +2,7 @@ use std::process::Command;
 
 use anyhow::Context;
 use cargo_nfpm::cargo::{self, ProjectBuilder};
-use cargo_nfpm::generator::get_config_from_metadata;
+use cargo_nfpm::generator::{get_config_from_metadata, OutputFormat};
 use cargo_nfpm::nfpm::download_nfpm;
 use cargo_nfpm::nfpm_schema::{ContentElement, FileInfo};
 use clap::Parser;
@@ -18,6 +18,7 @@ pub struct CliArgs {
 
 #[derive(clap::Subcommand, Debug)]
 pub enum Commands {
+    /// Call `cargo-nfpm`.
     Nfpm(NfpmArgs),
 }
 
@@ -29,18 +30,11 @@ pub struct NfpmArgs {
 
 #[derive(clap::Subcommand, Debug)]
 pub enum NfpmCommands {
+    /// Creates a package based on the `Cargo.toml` config
+    #[clap(aliases = ["pkg", "p"])]
     Package(PackageArgs),
 }
 
-#[derive(Debug, Clone, Copy, clap::ValueEnum)]
-pub enum OutputFormat {
-    Apk,
-    ArchLinux,
-    Deb,
-    Ipk,
-    Rpm,
-}
-
 #[derive(clap::Args, Debug)]
 pub struct PackageArgs {
     /// Package to build (see `cargo help pkgid`)
@@ -67,7 +61,7 @@ pub struct PackageArgs {
     #[arg(long, action = clap::ArgAction::SetTrue)]
     no_vendor: bool,
 
-    /// Output format.
+    /// Package format.
     #[arg(long, short)]
     format: OutputFormat,
 
@@ -139,7 +133,7 @@ fn main() -> anyhow::Result<()> {
         builder.build()?;
     }
 
-    let mut config = get_config_from_metadata(&metadata, package, &triple)
+    let mut config = get_config_from_metadata(&metadata, package, &triple, args.format)
         .context("create config from Cargo manifest")?;
 
     let auto_add_binary = if let Some(contents) = &config.contents {
@@ -182,7 +176,7 @@ fn main() -> anyhow::Result<()> {
 
     let packager = match args.format {
         OutputFormat::Apk => "apk",
-        OutputFormat::ArchLinux => "archlinux",
+        OutputFormat::Archlinux => "archlinux",
         OutputFormat::Deb => "deb",
         OutputFormat::Ipk => "ipk",
         OutputFormat::Rpm => "rpm",

src/triple.rs

@@ -0,0 +1,103 @@
+//! Rust Triple manipulation and information query.
+
+use anyhow::Context;
+
+/// An LLVM triple in the format: `<arch><sub>-<vendor>-<sys>-<env>`.
+pub struct LlvmTriple {
+    inner: String,
+}
+
+impl LlvmTriple {
+    /// Triple must follow the following format:
+    ///
+    /// `<arch><sub>-<vendor>-<sys>-<env>`.
+    pub fn new<S>(triple: S) -> anyhow::Result<Self>
+    where
+        S: AsRef<str>,
+    {
+        let inner = String::from(triple.as_ref());
+
+        let mut split = inner.split('-');
+        let _arch = split.next().context("missing architecture component")?;
+        let _vendor = split.next().context("missing vendor component")?;
+        let _sys = split.next().context("missing sys component")?;
+        let _env = split.next().context("missing env component")?;
+
+        Ok(Self { inner })
+    }
+
+    pub fn arch(&self) -> &str {
+        let (arch, _) = self.inner.split_once('-').expect("validation wrong");
+        arch
+    }
+
+    pub fn to_rpm_arch(&self) -> anyhow::Result<&'static str> {
+        let arch = self.arch();
+        let ret = match arch {
+            "aarch64" | "arm64" | "arm64e" => "aarch64",
+            "i686" => "i386",
+            "x86_64" => "x86_64",
+            "arm" | "armv6" | "armv6k" => "armv6hl",
+            "armv7" | "armv7k" | "armv7s" | "armv7a" => "armv7hl",
+            arch => return Err(anyhow::anyhow!("unsupported arch: {arch}")),
+        };
+
+        Ok(ret)
+    }
+
+    /// Architecture for `DEB` files is defined here: https://wiki.debian.org/ArchitectureSpecificsMemo
+    pub fn to_deb_arch(&self) -> anyhow::Result<&'static str> {
+        let arch = self.arch();
+        let ret = match arch {
+            "aarch64" | "arm64" | "arm64e" => "arm64",
+            "i686" => "i386",
+            "x86_64" => "amd64",
+            "arm" | "armv6" | "armv6k" | "armv7" | "armv7k" | "armv7s" | "armv7a" => "arm",
+            arch => return Err(anyhow::anyhow!("unsupported arch: {arch}")),
+        };
+
+        Ok(ret)
+    }
+
+    pub fn to_ipk_arch(&self) -> anyhow::Result<&'static str> {
+        let arch = self.arch();
+        let ret = match arch {
+            "aarch64" | "arm64" | "arm64e" => "arm64",
+            "i686" => "i386",
+            "x86_64" => "x86_64",
+            "arm" | "armv6" | "armv6k" => "armhf",
+            "armv7" | "armv7k" | "armv7s" | "armv7a" => "armhf",
+            arch => return Err(anyhow::anyhow!("unsupported arch: {arch}")),
+        };
+
+        Ok(ret)
+    }
+
+    pub fn to_apk_arch(&self) -> anyhow::Result<&'static str> {
+        let arch = self.arch();
+        let ret = match arch {
+            "aarch64" | "arm64" | "arm64e" => "aarch64",
+            "i686" => "x86",
+            "x86_64" => "x86_64",
+            "arm" | "armv6" | "armv6k" => "armhf",
+            "armv7" | "armv7k" | "armv7s" | "armv7a" => "armv7",
+            arch => return Err(anyhow::anyhow!("unsupported arch: {arch}")),
+        };
+
+        Ok(ret)
+    }
+
+    pub fn to_archlinux_arch(&self) -> anyhow::Result<&'static str> {
+        let arch = self.arch();
+        let ret = match arch {
+            "aarch64" | "arm64" | "arm64e" => "aarch64",
+            "i686" => "i686",
+            "x86_64" => "x86_64",
+            "arm" | "armv6" | "armv6k" => "armv6h",
+            "armv7" | "armv7k" | "armv7s" | "armv7a" => "armv7h",
+            arch => return Err(anyhow::anyhow!("unsupported arch: {arch}")),
+        };
+
+        Ok(ret)
+    }
+}