fix: install linux arm64 cross compiler in release ci

Author: Thanga-Ganapathy

.github/workflows/release.yml

@@ -49,6 +49,14 @@ jobs:
           # - { rust_target: "i686-pc-windows-msvc", os: "windows-latest", ext: ".exe", name: "windows", arch: "x86" }  # edit me
     steps:
       - uses: actions/checkout@v4
+      - name: Install Linux aarch64 cross toolchain
+        if: matrix.rust_target == 'aarch64-unknown-linux-gnu'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc-aarch64-linux-gnu
+      - name: Configure Linux aarch64 linker
+        if: matrix.rust_target == 'aarch64-unknown-linux-gnu'
+        run: echo "CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc" >> "$GITHUB_ENV"
       - name: Build otf-release
         run: rustup target add ${{ matrix.rust_target }} && cargo build --release --target ${{ matrix.rust_target }}  # edit me: cross-compile with ${{ matrix.rust_target }}
       - uses: actions/upload-artifact@v4

Cargo.lock

@@ -10,7 +10,8 @@
 //! - **Publish** is an optional shell command (`publish`, e.g. `npx jsr publish`). When present
 //!   the package publishes through `otf-release publish` (which then tags + makes the GitHub
 //!   Release); when absent the package is build-only.
-//! - **No dependency graph / lockfile / ranges.**
+//! - **No dependency graph / ranges.** A generic package that versions a root `Cargo.toml`
+//!   refreshes `Cargo.lock` after version writes so Rust build-only releases stay consistent.
 
 use std::path::{Path, PathBuf};
 use std::process::Command;
@@ -21,6 +22,8 @@ use toml_edit::{value, DocumentMut, Item};
 
 use otf_release_core::adapter::{Adapter, Bump, DepKind, Pkg};
 
+use crate::command::{CommandRunner, SystemRunner};
+
 /// One generic project, as configured in `release.toml`.
 #[derive(Debug, Clone)]
 pub struct GenericPkg {
@@ -37,13 +40,27 @@ pub struct GenericPkg {
 pub struct GenericAdapter {
     root: PathBuf,
     packages: Vec<GenericPkg>,
+    runner: Box<dyn CommandRunner>,
 }
 
 impl GenericAdapter {
     pub fn new(root: impl Into<PathBuf>, packages: Vec<GenericPkg>) -> Self {
         Self {
             root: root.into(),
             packages,
+            runner: Box::new(SystemRunner),
+        }
+    }
+
+    pub fn with_runner(
+        root: impl Into<PathBuf>,
+        packages: Vec<GenericPkg>,
+        runner: Box<dyn CommandRunner>,
+    ) -> Self {
+        Self {
+            root: root.into(),
+            packages,
+            runner,
         }
     }
 
@@ -57,6 +74,15 @@ impl GenericAdapter {
     fn manifest_path(&self, pkg: &GenericPkg) -> PathBuf {
         self.root.join(&pkg.manifest)
     }
+
+    fn updates_cargo_lockfile(&self, root: &Path) -> bool {
+        root.join("Cargo.lock").exists()
+            && self.packages.iter().any(|pkg| {
+                pkg.manifest
+                    .file_name()
+                    .is_some_and(|name| name == "Cargo.toml")
+            })
+    }
 }
 
 /// Find the version value for `field` in manifest `text`. Matches `"field"…:…"value"` (JSON) and
@@ -276,7 +302,13 @@ impl Adapter for GenericAdapter {
         Ok(())
     }
 
-    fn update_lockfile(&self, _root: &Path) -> Result<()> {
+    fn update_lockfile(&self, root: &Path) -> Result<()> {
+        if self.updates_cargo_lockfile(root) {
+            let out = self.runner.run("cargo", &["update", "--workspace"], root)?;
+            if !out.success {
+                bail!("`cargo update --workspace` failed:\n{}", out.stderr);
+            }
+        }
         Ok(())
     }
 
@@ -327,6 +359,40 @@ impl Adapter for GenericAdapter {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::command::{CommandOutput, CommandRunner};
+    use std::sync::{Arc, Mutex};
+
+    type Calls = Arc<Mutex<Vec<(String, Vec<String>, PathBuf)>>>;
+
+    #[derive(Clone)]
+    struct FakeRunner {
+        out: CommandOutput,
+        calls: Calls,
+    }
+
+    impl FakeRunner {
+        fn new(success: bool, stdout: &str, stderr: &str) -> Self {
+            Self {
+                out: CommandOutput {
+                    success,
+                    stdout: stdout.into(),
+                    stderr: stderr.into(),
+                },
+                calls: Arc::new(Mutex::new(Vec::new())),
+            }
+        }
+    }
+
+    impl CommandRunner for FakeRunner {
+        fn run(&self, program: &str, args: &[&str], cwd: &Path) -> Result<CommandOutput> {
+            self.calls.lock().unwrap().push((
+                program.to_string(),
+                args.iter().map(|arg| arg.to_string()).collect(),
+                cwd.to_path_buf(),
+            ));
+            Ok(self.out.clone())
+        }
+    }
 
     fn pkg(name: &str, manifest: &str, publish: Option<&str>) -> GenericPkg {
         GenericPkg {
@@ -390,6 +456,49 @@ mod tests {
         assert_eq!(a.discover_packages().unwrap()[0].version, "0.4.0");
     }
 
+    #[test]
+    fn cargo_toml_manifest_refreshes_cargo_lockfile() {
+        let tmp = tempfile::tempdir().unwrap();
+        std::fs::write(tmp.path().join("Cargo.toml"), "version = \"0.1.0\"\n").unwrap();
+        std::fs::write(tmp.path().join("Cargo.lock"), "").unwrap();
+        let runner = FakeRunner::new(true, "", "");
+        let calls = runner.calls.clone();
+        let a = GenericAdapter::with_runner(
+            tmp.path(),
+            vec![pkg("x", "Cargo.toml", None)],
+            Box::new(runner),
+        );
+
+        a.update_lockfile(tmp.path()).unwrap();
+
+        assert_eq!(
+            *calls.lock().unwrap(),
+            vec![(
+                "cargo".to_string(),
+                vec!["update".to_string(), "--workspace".to_string()],
+                tmp.path().to_path_buf()
+            )]
+        );
+    }
+
+    #[test]
+    fn non_cargo_manifest_does_not_refresh_lockfile() {
+        let tmp = tempfile::tempdir().unwrap();
+        std::fs::write(tmp.path().join("deno.json"), "{\"version\":\"1.0.0\"}").unwrap();
+        std::fs::write(tmp.path().join("Cargo.lock"), "").unwrap();
+        let runner = FakeRunner::new(true, "", "");
+        let calls = runner.calls.clone();
+        let a = GenericAdapter::with_runner(
+            tmp.path(),
+            vec![pkg("x", "deno.json", None)],
+            Box::new(runner),
+        );
+
+        a.update_lockfile(tmp.path()).unwrap();
+
+        assert!(calls.lock().unwrap().is_empty());
+    }
+
     #[test]
     fn reads_and_writes_nested_json_version_field() {
         let tmp = tempfile::tempdir().unwrap();

crates/adapters/src/generic.rs

@@ -475,6 +475,23 @@ fn render_build_job(s: &mut String, entry: &PackageEntry) {
 
     s.push_str("    steps:\n");
     s.push_str("      - uses: actions/checkout@v4\n");
+    if entry.matrix
+        && entry
+            .targets
+            .iter()
+            .any(|target| target.name == "linux" && target.arch == "aarch64")
+    {
+        s.push_str("      - name: Install Linux aarch64 cross toolchain\n");
+        s.push_str("        if: matrix.rust_target == 'aarch64-unknown-linux-gnu'\n");
+        s.push_str("        run: |\n");
+        s.push_str("          sudo apt-get update\n");
+        s.push_str("          sudo apt-get install -y gcc-aarch64-linux-gnu\n");
+        s.push_str("      - name: Configure Linux aarch64 linker\n");
+        s.push_str("        if: matrix.rust_target == 'aarch64-unknown-linux-gnu'\n");
+        s.push_str(
+            "        run: echo \"CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc\" >> \"$GITHUB_ENV\"\n",
+        );
+    }
     match entry.adapter {
         Ecosystem::Cargo => {
             s.push_str("      - uses: dtolnay/rust-toolchain@stable\n");

crates/core/src/init.rs

@@ -18,7 +18,10 @@ a release PR, and a publish/release workflow scaffold. Implemented in
   package is `publish` mode and ships through `otf-release publish`, which runs your command and
   then tags + creates the GitHub Release. When omitted, the package is `build-only`.
 - **Build** is optional — `command` + `artifacts`, like any other adapter, for staging files.
-- **No dependency graph, lockfile, or ranges** — those trait methods are no-ops.
+- **No dependency graph or ranges** — those trait methods are no-ops.
+- **Lockfile** is normally a no-op. If a generic package versions a root `Cargo.toml` and
+  `Cargo.lock` exists, `otf-release version` runs `cargo update --workspace` so the lockfile is
+  refreshed in the release commit.
 
 ## `release.toml`