ci: update release

Signed-off-by: Rodolfo Mói de Oliveira <rodmoi.oliveira@gmail.com>

.github/workflows/ci.yml

@@ -1,3 +1,5 @@
+# Stolen from https://github.com/BurntSushi/ripgrep
+
 name: ci
 
 on:

.github/workflows/release.yml

@@ -1,134 +1,217 @@
-# Stolen from BurntSushi/ripgrep and kevinswiber/postman2openapi :D
-#
-# The way this works is a little weird. But basically, the create-release job
-# runs purely to initialize the GitHub release itself. Once done, the upload
-# URL of the release is saved as an artifact.
-#
-# The build-release job runs only once create-release is finished. It gets
-# the release upload URL by downloading the corresponding artifact (which was
-# uploaded by create-release). It then builds the release executables for each
-# supported platform and attaches them as release assets to the previously
-# created release.
-#
-# The key here is that we create the release only once.
+# Stolen from https://github.com/BurntSushi/ripgrep
 
 name: release
+
+# Only do the release on x.y.z tags.
 on:
   push:
-    # # Enable when testing release infrastructure on a branch.
-    # branches:
-    #   - build
     tags:
-      - '[0-9]+.[0-9]+.[0-9]+**'
+      - "[0-9]+.[0-9]+.[0-9]+"
+
+# We need this to be able to create releases.
+permissions:
+  contents: write
+
 jobs:
   create-release:
     name: create-release
     runs-on: ubuntu-latest
-    # # Set to force version number, e.g., when no tag exists.
-    # env:
-    #   CNJ_VERSION: TEST-0.0.1
-    outputs:
-      cnj_version: ${{ env.CNJ_VERSION }}
     steps:
       - uses: actions/checkout@v4
       - name: Get the release version from the tag
+        if: env.VERSION == ''
+        run: echo "VERSION=${{ github.ref_name }}" >> $GITHUB_ENV
+      - name: Show the version
+        run: |
+          echo "version is: $VERSION"
+      - name: Check that tag version and Cargo.toml version are the same
         shell: bash
-        if: env.CNJ_VERSION == ''
         run: |
-          echo "CNJ_VERSION=$GITHUB_REF_NAME" >> $GITHUB_ENV
-          echo "version is: ${{ env.CNJ_VERSION }}"
+          if ! grep -q "version = \"$VERSION\"" Cargo.toml; then
+            echo "version does not match Cargo.toml" >&2
+            exit 1
+          fi
       - name: Create GitHub release
         env:
-          GH_TOKEN: ${{ github.token }}
-        run: gh release create ${{ env.CNJ_VERSION }}
+          GITHUB_TOKEN: ${{ github.token }}
+        run: gh release create ${{ env.VERSION }} --title ${{ env.VERSION }}
+    # # Set to force version number, e.g., when no tag exists.
+    # env:
+    #   VERSION: TEST-0.0.1
+    outputs:
+      version: ${{ env.VERSION }}
 
   build-release:
-    name: build-release
+    name: '[rust] build-release ${{ matrix.target }}'
     needs: ['create-release']
     runs-on: ${{ matrix.os }}
     env:
-      # For some builds, we use cross to test on 32-bit and big-endian systems.
+      # For some builds, we use cross to test on 32-bit and big-endian
+      # systems.
       CARGO: cargo
       # When CARGO is set to CROSS, this is set to `--target matrix.target`.
       TARGET_FLAGS: ""
       # When CARGO is set to CROSS, TARGET_DIR includes matrix.target.
       TARGET_DIR: ./target
+      # Bump this as appropriate. We pin to a version to make sure CI
+      # continues to work as cross releases in the past have broken things
+      # in subtle ways.
+      CROSS_VERSION: v0.2.5
       # Emit backtraces on panics.
       RUST_BACKTRACE: 1
     strategy:
+      fail-fast: false
       matrix:
-        build: [linux, macos, win-msvc, win-gnu, win32-msvc]
         include:
-          - build: linux
-            os: ubuntu-latest
-            rust: stable
-            target: x86_64-unknown-linux-musl
-          - build: macos
-            os: macos-latest
-            rust: stable
-            target: x86_64-apple-darwin
-          - build: win-msvc
-            os: windows-latest
-            rust: stable
-            target: x86_64-pc-windows-msvc
-          - build: win-gnu
-            os: windows-latest
-            rust: nightly-x86_64-gnu
-            target: x86_64-pc-windows-gnu
-          - build: win32-msvc
-            os: windows-latest
-            rust: stable
-            target: i686-pc-windows-msvc
+        - build: linux
+          os: ubuntu-latest
+          rust: nightly
+          target: x86_64-unknown-linux-musl
+          strip: x86_64-linux-musl-strip
+        - build: stable-x86
+          os: ubuntu-latest
+          rust: stable
+          target: i686-unknown-linux-gnu
+          strip: x86_64-linux-gnu-strip
+          qemu: i386
+        - build: stable-aarch64
+          os: ubuntu-latest
+          rust: stable
+          target: aarch64-unknown-linux-gnu
+          strip: aarch64-linux-gnu-strip
+          qemu: qemu-aarch64
+        - build: stable-arm-gnueabihf
+          os: ubuntu-latest
+          rust: stable
+          target: armv7-unknown-linux-gnueabihf
+          strip: arm-linux-gnueabihf-strip
+          qemu: qemu-arm
+        - build: stable-arm-musleabihf
+          os: ubuntu-latest
+          rust: stable
+          target: armv7-unknown-linux-musleabihf
+          strip: arm-linux-musleabihf-strip
+          qemu: qemu-arm
+        - build: stable-arm-musleabi
+          os: ubuntu-latest
+          rust: stable
+          target: armv7-unknown-linux-musleabi
+          strip: arm-linux-musleabi-strip
+          qemu: qemu-arm
+        - build: stable-powerpc64
+          os: ubuntu-latest
+          rust: stable
+          target: powerpc64-unknown-linux-gnu
+          strip: powerpc64-linux-gnu-strip
+          qemu: qemu-ppc64
+        - build: stable-s390x
+          os: ubuntu-latest
+          rust: stable
+          target: s390x-unknown-linux-gnu
+          strip: s390x-linux-gnu-strip
+          qemu: qemu-s390x
+        - build: macos
+          os: macos-latest
+          rust: nightly
+          target: x86_64-apple-darwin
+        - build: win-msvc
+          os: windows-latest
+          rust: nightly
+          target: x86_64-pc-windows-msvc
+        - build: win-gnu
+          os: windows-latest
+          rust: nightly-x86_64-gnu
+          target: x86_64-pc-windows-gnu
+        - build: win32-msvc
+          os: windows-latest
+          rust: nightly
+          target: i686-pc-windows-msvc
+
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
-        with:
-          fetch-depth: 1
+
+      # - name: Install packages (Ubuntu)
+      #   if: matrix.os == 'ubuntu-latest'
+      #   shell: bash
+      #   run: |
+      #     ci/ubuntu-install-packages
 
       - name: Install Rust
-        uses: ructions/toolchain@v2.0.0
+        uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ matrix.rust }}
-          profile: minimal
-          override: true
           target: ${{ matrix.target }}
 
       - name: Use Cross
+        if: matrix.os == 'ubuntu-latest' && matrix.target != ''
         shell: bash
         run: |
-          cargo install --bins --git https://github.com/rust-embedded/cross --tag v0.2.1
+          # In the past, new releases of 'cross' have broken CI. So for now, we
+          # pin it. We also use their pre-compiled binary releases because cross
+          # has over 100 dependencies and takes a bit to compile.
+          dir="$RUNNER_TEMP/cross-download"
+          mkdir "$dir"
+          echo "$dir" >> $GITHUB_PATH
+          cd "$dir"
+          curl -LO "https://github.com/cross-rs/cross/releases/download/$CROSS_VERSION/cross-x86_64-unknown-linux-musl.tar.gz"
+          tar xf cross-x86_64-unknown-linux-musl.tar.gz
           echo "CARGO=cross" >> $GITHUB_ENV
+
+      - name: Set target variables
+        shell: bash
+        run: |
           echo "TARGET_FLAGS=--target ${{ matrix.target }}" >> $GITHUB_ENV
           echo "TARGET_DIR=./target/${{ matrix.target }}" >> $GITHUB_ENV
 
       - name: Show command used for Cargo
+        shell: bash
         run: |
           echo "cargo command is: ${{ env.CARGO }}"
           echo "target flag is: ${{ env.TARGET_FLAGS }}"
           echo "target dir is: ${{ env.TARGET_DIR }}"
 
       - name: Build release binary
-        run: ${{ env.CARGO }} build --verbose --release ${{ env.TARGET_FLAGS }}
+        shell: bash
+        run: |
+          ${{ env.CARGO }} build --verbose --release ${{ env.TARGET_FLAGS }}
+          if [ "${{ matrix.os }}" = "windows-latest" ]; then
+            bin="target/${{ matrix.target }}/release/cnj.exe"
+          else
+            bin="target/${{ matrix.target }}/release/cnj"
+          fi
+          echo "BIN=$bin" >> $GITHUB_ENV
+
+      - name: Strip release binary (macos)
+        if: matrix.os == 'macos-latest'
+        shell: bash
+        run: strip "$BIN"
 
-      - name: Strip release binary (linux and macos)
-        if: matrix.build == 'linux' || matrix.build == 'macos'
-        run: strip "target/${{ matrix.target }}/release/cnj"
+      - name: Strip release binary (cross)
+        if: env.CARGO == 'cross'
+        shell: bash
+        run: |
+          docker run --rm -v \
+            "$PWD/target:/target:Z" \
+            "ghcr.io/cross-rs/${{ matrix.target }}:main" \
+            "${{ matrix.strip }}" \
+            "/$BIN"
 
       - name: Build archive
         shell: bash
         run: |
-          staging="cnj-${{ needs.create-release.outputs.cnj_version }}-${{ matrix.target }}"
+          staging="cnj-${{ needs.create-release.outputs.version }}-${{ matrix.target }}"
           mkdir "$staging"/
           cp {README.md,LICENSE} "$staging/"
 
           if [ "${{ matrix.os }}" = "windows-latest" ]; then
-            cp "target/${{ matrix.target }}/release/cnj.exe" "$staging/"
+            cp "$BIN" "$staging/"
             7z a "$staging.zip" "$staging"
             certutil -hashfile "$staging.zip" SHA256 > "$staging.zip.sha256"
             echo "ASSET=$staging.zip" >> $GITHUB_ENV
             echo "ASSET_SUM=$staging.zip.sha256" >> $GITHUB_ENV
           else
-            cp "target/${{ matrix.target }}/release/cnj" "$staging/"
+            cp "$BIN" "$staging/"
             tar czf "$staging.tar.gz" "$staging"
             shasum -a 256 "$staging.tar.gz" > "$staging.tar.gz.sha256"
             echo "ASSET=$staging.tar.gz" >> $GITHUB_ENV
@@ -137,5 +220,5 @@ jobs:
 
       - name: Upload release archive
         env:
-          GH_TOKEN: ${{ github.token }}
-        run: gh release upload ${{ needs.create-release.outputs.cnj_version }} ${{ env.ASSET }} ${{ env.ASSET_SUM }}
+          GITHUB_TOKEN: ${{ github.token }}
+        run: gh release upload ${{ needs.create-release.outputs.version }} ${{ env.ASSET }} ${{ env.ASSET_SUM }}