btest-rs/.gitea/workflows/release.yml

name: Build & Release

on:
  push:
    tags:
      - 'v*'

jobs:
  release:
    runs_on: ubuntu-latest
    container:
      image: rust:1.86-slim
    steps:
      - name: Install dependencies
        run: |
          apt-get update && apt-get install -y --no-install-recommends \
            git curl jq ca-certificates zip \
            musl-tools \
            gcc-aarch64-linux-gnu \
            gcc-arm-linux-gnueabihf \
            gcc-mingw-w64-x86-64
          rustup target add \
            x86_64-unknown-linux-musl \
            aarch64-unknown-linux-musl \
            armv7-unknown-linux-musleabihf \
            x86_64-pc-windows-gnu

      - name: Install crane (OCI image tool)
        run: |
          CRANE_VERSION="0.20.3"
          curl -sL "https://github.com/google/go-containerregistry/releases/download/v${CRANE_VERSION}/go-containerregistry_Linux_x86_64.tar.gz" \
            | tar xz -C /usr/local/bin crane
          crane version

      - name: Ensure code is present
        run: |
          git config --global --add safe.directory '*'
          if [ ! -f "Cargo.toml" ]; then
            git clone --depth 1 --branch ${GITHUB_REF_NAME} ${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}.git /tmp/src
            cp -a /tmp/src/. .
          fi

      - name: Configure cross-linkers
        run: |
          mkdir -p .cargo
          cat > .cargo/config.toml << 'TOML'
          [target.aarch64-unknown-linux-musl]
          linker = "aarch64-linux-gnu-gcc"
          rustflags = ["-C", "target-feature=+crt-static"]

          [target.armv7-unknown-linux-musleabihf]
          linker = "arm-linux-gnueabihf-gcc"
          rustflags = ["-C", "target-feature=+crt-static"]

          [target.x86_64-pc-windows-gnu]
          linker = "x86_64-w64-mingw32-gcc"
          TOML

      - name: Build Linux x86_64
        run: cargo build --release --target x86_64-unknown-linux-musl

      - name: Build Linux aarch64
        run: cargo build --release --target aarch64-unknown-linux-musl

      - name: Build Linux armv7
        run: cargo build --release --target armv7-unknown-linux-musleabihf

      - name: Build Windows x86_64
        run: cargo build --release --target x86_64-pc-windows-gnu

      - name: Package all
        run: |
          mkdir -p /artifacts

          cd target/x86_64-unknown-linux-musl/release
          tar czf /artifacts/btest-linux-x86_64.tar.gz btest
          cd -

          cd target/aarch64-unknown-linux-musl/release
          tar czf /artifacts/btest-linux-aarch64.tar.gz btest
          cd -

          cd target/armv7-unknown-linux-musleabihf/release
          tar czf /artifacts/btest-linux-armv7.tar.gz btest
          cd -

          cd target/x86_64-pc-windows-gnu/release
          zip /artifacts/btest-windows-x86_64.zip btest.exe
          cd -

          cd /artifacts
          sha256sum * > checksums-sha256.txt
          cat checksums-sha256.txt
          ls -lh

      - name: Build and push Docker image
        env:
          TOKEN: ${{ secrets.RELEASE_TOKEN }}
        run: |
          TAG="${GITHUB_REF_NAME}"
          REGISTRY="git.manko.yoga"
          IMAGE="${REGISTRY}/manawenuz/btest-rs"

          # Authenticate crane with Gitea registry
          echo "${TOKEN}" | crane auth login "${REGISTRY}" -u token --password-stdin

          # Build OCI image from the static x86_64 binary
          # Create a minimal layer with just the binary
          mkdir -p /tmp/docker-root/usr/local/bin
          cp target/x86_64-unknown-linux-musl/release/btest /tmp/docker-root/usr/local/bin/btest
          chmod +x /tmp/docker-root/usr/local/bin/btest

          # Create tarball layer
          tar -cf /tmp/layer.tar -C /tmp/docker-root .

          # Push as scratch-based image
          crane append \
            --base=scratch \
            --new_layer=/tmp/layer.tar \
            --new_tag="${IMAGE}:${TAG}" \
            --set-entrypoint="/usr/local/bin/btest" \
            --set-cmd="-s"

          # Also tag as latest
          crane tag "${IMAGE}:${TAG}" latest

          echo "Docker image pushed:"
          echo "  ${IMAGE}:${TAG}"
          echo "  ${IMAGE}:latest"

      - name: Create release and upload
        env:
          TOKEN: ${{ secrets.RELEASE_TOKEN }}
        run: |
          TAG="${GITHUB_REF_NAME}"
          GITEA_URL="${GITHUB_SERVER_URL}"
          REPO="${GITHUB_REPOSITORY}"
          REGISTRY="git.manko.yoga"

          RELEASE_BODY="## Downloads

          | Platform | Architecture | File |
          |----------|-------------|------|
          | Linux | x86_64 | btest-linux-x86_64.tar.gz |
          | Linux | aarch64 (RPi 64-bit) | btest-linux-aarch64.tar.gz |
          | Linux | armv7 (RPi 32-bit) | btest-linux-armv7.tar.gz |
          | Windows | x86_64 | btest-windows-x86_64.zip |
          | macOS | aarch64 / x86_64 | Build locally or download after manual upload |
          | Docker | x86_64 | \`docker pull ${REGISTRY}/manawenuz/btest-rs:${TAG}\` |

          ### Quick Install (Linux)
          \`\`\`bash
          tar xzf btest-linux-x86_64.tar.gz
          sudo mv btest /usr/local/bin/
          \`\`\`

          ### Docker
          \`\`\`bash
          docker run --rm -p 2000:2000 -p 2001-2100:2001-2100/udp ${REGISTRY}/manawenuz/btest-rs:${TAG} -s -v
          \`\`\`"

          RELEASE_ID=$(curl -sf -X POST \
            -H "Authorization: token ${TOKEN}" \
            -H "Content-Type: application/json" \
            -d "$(jq -n --arg tag "$TAG" --arg name "btest-rs $TAG" --arg body "$RELEASE_BODY" \
              '{tag_name: $tag, name: $name, body: $body, draft: false, prerelease: false}')" \
            "${GITEA_URL}/api/v1/repos/${REPO}/releases" | jq -r '.id')

          echo "Created release ID: ${RELEASE_ID}"

          for file in /artifacts/*.tar.gz /artifacts/*.zip /artifacts/checksums-sha256.txt; do
            FILENAME=$(basename "$file")
            echo "Uploading: ${FILENAME}"
            curl -sf -X POST \
              -H "Authorization: token ${TOKEN}" \
              -F "attachment=@${file}" \
              "${GITEA_URL}/api/v1/repos/${REPO}/releases/${RELEASE_ID}/assets?name=${FILENAME}" \
              | jq -r '.name // .message'
          done

          echo "Release ${TAG} published!"