ci: fix workflows (#533)

QaidVoid · web-flow · commit f0856db128dc · 2026-03-15T16:26:03.000Z
diff --git a/.github/workflows/build-on-change.yaml b/.github/workflows/build-on-change.yaml
@@ -7,10 +7,6 @@ on:
     paths:
       - 'binaries/**/*.yaml'
       - 'packages/**/*.yaml'
-  pull_request:
-    types: [closed]
-    branches:
-      - main
   workflow_dispatch:
     inputs:
       recipe_path:
@@ -34,7 +30,6 @@ concurrency:
 
 jobs:
   detect-changes:
-    if: github.event_name == 'push' || github.event_name == 'workflow_dispatch' || (github.event_name == 'pull_request' && github.event.pull_request.merged == true)
     runs-on: ubuntu-latest
     outputs:
       changed_recipes: ${{ steps.filter.outputs.recipes_to_build }}
diff --git a/.github/workflows/pr-build-test.yaml b/.github/workflows/pr-build-test.yaml
@@ -142,41 +142,44 @@ jobs:
       - name: Download sbuild
         run: |
           curl -fsSL "https://github.com/pkgforge/sbuilder/releases/download/nightly/sbuild-x86_64-linux" \
-            -o /usr/local/bin/sbuild || exit 0
-          chmod +x /usr/local/bin/sbuild
+            -o /usr/local/bin/sbuild && chmod +x /usr/local/bin/sbuild
+          sbuild --version
 
-      - name: Download existing cache
+      - name: Download build status artifacts
+        uses: actions/download-artifact@v7
+        with:
+          pattern: build-status-*
+          path: /tmp/build-statuses
+          merge-multiple: true
         continue-on-error: true
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          gh release download build-cache -p build_cache.sdb -D /tmp/ --repo "${{ github.repository }}" || \
-            sbuild cache --cache /tmp/build_cache.sdb init
 
-      - name: Update cache with recipe hashes
+      - name: Update cache with build results
+        env:
+          SBUILD_CACHE_URI: ${{ secrets.SBUILD_CACHE_URI }}
         run: |
+          # sbuild updates cache directly on success via SBUILD_CACHE_URI.
+          # This step only records failures/skips that sbuild didn't handle.
           RECIPES='${{ needs.detect-changes.outputs.changed_recipes }}'
-          BUILD_RESULT="${{ needs.build.result }}"
 
           echo "$RECIPES" | jq -c '.[]' | while read -r recipe; do
             path=$(echo "$recipe" | jq -r '.path')
 
-            # Extract pkg_id from recipe YAML for cache operations
+            # Extract pkg_id and pkg name from recipe YAML for cache operations
             pkg_id=""
             pkg_name=""
             if [ -f "$path" ]; then
               pkg_id=$(grep -E '^pkg_id:' "$path" | head -1 | sed 's/pkg_id:[[:space:]]*//; s/^["'"'"']//; s/["'"'"']$//')
               pkg_name=$(grep -E '^pkg:' "$path" | head -1 | sed 's/pkg:[[:space:]]*//; s/^["'"'"']//; s/["'"'"']$//')
             fi
-            # Fallback to pkg field then directory name
+            # Fallback to pkg name from recipe
             if [ -z "$pkg_id" ]; then
               pkg_id="${pkg_name:-$(basename "$(dirname "$path")")}"
             fi
 
             # Extract version from recipe's pkgver field
             pkg_version=""
             if [ -f "$path" ]; then
-              pkg_version=$(grep -E "^pkgver:" "$path" | head -1 | sed 's/pkgver:[[:space:]]*//; s/^["'"'"']//; s/["'"'"']$//')
+              pkg_version=$(grep -E "^pkgver:" "$path" | head -1 | sed 's/pkgver:[[:space:]]*//; s/^["'"'"']//; s/["'"'"']$//' || echo "")
             fi
 
             # Skip if we have no version
@@ -185,31 +188,68 @@ jobs:
               continue
             fi
 
-            # Compute recipe hash (excluding version for consistency)
-            if [ -f "$path" ]; then
+            # Compute recipe hash
+            if [ -f "$path" ] && command -v sbuild &>/dev/null; then
               recipe_hash=$(sbuild meta hash --exclude-version "$path" 2>/dev/null || sha256sum "$path" | cut -d' ' -f1)
             else
-              recipe_hash=""
+              recipe_hash=$(sha256sum "$path" 2>/dev/null | cut -d' ' -f1 || echo "")
             fi
 
-            status="success"
-            if [ "$BUILD_RESULT" != "success" ]; then
-              status="failure"
-            fi
+            # Process build status for each host architecture
+            for host in x86_64-linux aarch64-linux; do
+              status=""
+
+              if [ -d "/tmp/build-statuses" ]; then
+                for status_file in /tmp/build-statuses/build-status.json /tmp/build-statuses/*/build-status.json; do
+                  [ -f "$status_file" ] || continue
+
+                  recipe_url=$(jq -r '.recipe_url // ""' "$status_file" 2>/dev/null || echo "")
+                  file_host=$(jq -r '.host // ""' "$status_file" 2>/dev/null || echo "")
+
+                  if echo "$recipe_url" | grep -q "$path" && [ "$file_host" = "$host" ]; then
+                    file_status=$(jq -r '.status // ""' "$status_file" 2>/dev/null || echo "")
+                    case "$file_status" in
+                      failure) status="failed" ;;
+                      skipped) status="skipped" ;;
+                      success) status="" ;;  # Already handled by sbuild
+                      *) status="" ;;
+                    esac
+                    break
+                  fi
+                done
+              fi
+
+              # Only update cache for failed/skipped (success handled by sbuild)
+              if [ -z "$status" ]; then
+                continue
+              fi
 
-            echo "Caching: $pkg_id v${pkg_version} (hash: ${recipe_hash:0:16}..., status: $status)"
+              echo "Package: $pkg_id ($host), Version: $pkg_version, Status: $status"
 
-            sbuild cache --cache /tmp/build_cache.sdb update \
-              --package "$pkg_id" \
-              --version "$pkg_version" \
-              --hash "$recipe_hash" \
-              --status "$status" || true
+              sbuild cache update \
+                --package "$pkg_id" \
+                --host "$host" \
+                --version "$pkg_version" \
+                --hash "$recipe_hash" \
+                --status "$status" || echo "Warning: Failed to update cache for $pkg_id ($host)"
+            done
           done
 
-      - name: Upload updated cache
+      - name: Generate build summary
+        env:
+          SBUILD_CACHE_URI: ${{ secrets.SBUILD_CACHE_URI }}
+        run: |
+          sbuild cache gh-summary \
+            --title "PR Build Results" \
+            --host x86_64-linux || true
+
+      - name: Export cache to SQLite and upload
         env:
           GH_TOKEN: ${{ github.token }}
+          SBUILD_CACHE_URI: ${{ secrets.SBUILD_CACHE_URI }}
         run: |
+          sbuild cache export --output /tmp/build_cache.sdb || true
+
           if [ -f "/tmp/build_cache.sdb" ]; then
             gh release upload build-cache /tmp/build_cache.sdb --clobber --repo "${{ github.repository }}" || {
               gh release create build-cache \
diff --git a/.github/workflows/rolling-rebuilds.yaml b/.github/workflows/rolling-rebuilds.yaml
@@ -92,29 +92,21 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v6
 
-      - name: Cache remote_pkgver state
-        id: cache
-        uses: actions/cache@v5
-        with:
-          path: .rolling-state.json
-          key: rolling-remote-versions-v1
-          restore-keys: |
-            rolling-remote-versions-v1
+      - name: Download sbuild
+        run: |
+          curl -fsSL "https://github.com/pkgforge/sbuilder/releases/download/nightly/sbuild-x86_64-linux" \
+            -o /usr/local/bin/sbuild && chmod +x /usr/local/bin/sbuild
+          sbuild --version
 
       - name: Check for source updates
         id: check
         env:
           GITHUB_TOKEN: ${{ github.token }}
           GHCR_OWNER: ${{ github.repository_owner }}
+          SBUILD_CACHE_URI: ${{ secrets.SBUILD_CACHE_URI }}
         run: |
           TO_REBUILD="[]"
           PACKAGES='${{ needs.find-rolling-packages.outputs.packages }}'
-          STATE_FILE=".rolling-state.json"
-
-          # Initialize state file if doesn't exist
-          if [ ! -f "$STATE_FILE" ]; then
-            echo "{}" > "$STATE_FILE"
-          fi
 
           # Function to extract pkgver script from x_exec block
           extract_pkgver_script() {
@@ -181,6 +173,12 @@ jobs:
             grep -E "^ghcr_pkg:" "$file" | head -1 | sed 's/^ghcr_pkg:[[:space:]]*//; s/^"//; s/"$//'
           }
 
+          # Function to extract pkg_id from recipe
+          get_pkg_id() {
+            local file="$1"
+            grep -E "^pkg_id:" "$file" | head -1 | sed 's/^pkg_id:[[:space:]]*//; s/^"//; s/"$//'
+          }
+
           echo "$PACKAGES" | jq -c '.[]' | while IFS= read -r pkg; do
             path=$(echo "$pkg" | jq -r '.path')
             family=$(echo "$pkg" | jq -r '.family')
@@ -192,24 +190,37 @@ jobs:
               pkg_name="$family"  # fallback to family name
             fi
 
-            # Check for ghcr_pkg
-            ghcr_pkg=$(get_ghcr_pkg "$path")
+            # Extract pkg_id for cache lookup
+            pkg_id=$(get_pkg_id "$path")
 
-            echo "::group::Checking $family/$name (pkg: $pkg_name)"
+            echo "::group::Checking $family/$name (pkg_id: $pkg_id)"
 
-            # Skip if no ghcr_pkg
-            if [ -z "$ghcr_pkg" ]; then
-              echo "No ghcr_pkg set - cannot track version, skipping"
+            # Skip if no pkg_id
+            if [ -z "$pkg_id" ]; then
+              echo "No pkg_id set - cannot check cache, skipping"
               echo "::endgroup::"
               continue
             fi
 
             NEEDS_REBUILD=false
             NEW_VERSION=""
-            CACHED_VERSION=""
-
-            # Get cached remote_pkgver from state file
-            CACHED_VERSION=$(jq -r --arg key "$path" '.[$key] // ""' "$STATE_FILE")
+            STORED_VERSION=""
+
+            # Query MongoDB for stored version
+            CACHE_DATA=$(sbuild cache get --package "$pkg_id" --json 2>/dev/null || echo "{}")
+            REMOTE_VER=$(echo "$CACHE_DATA" | jq -r '.remote_version // ""')
+            CURRENT_VER=$(echo "$CACHE_DATA" | jq -r '.current_version // ""')
+            
+            # Use remote_version if set, otherwise fall back to current_version
+            if [ -n "$REMOTE_VER" ] && [ "$REMOTE_VER" != "null" ]; then
+              STORED_VERSION="$REMOTE_VER"
+              echo "Stored remote_version: $STORED_VERSION"
+            elif [ -n "$CURRENT_VER" ] && [ "$CURRENT_VER" != "null" ]; then
+              STORED_VERSION="$CURRENT_VER"
+              echo "No remote_version, using current_version: $STORED_VERSION"
+            else
+              echo "No stored version in cache"
+            fi
 
             # Try to extract and run pkgver script
             PKGVER_SCRIPT=$(extract_pkgver_script "$path")
@@ -220,17 +231,17 @@ jobs:
 
               if [ -n "$NEW_VERSION" ]; then
                 echo "New version from pkgver: $NEW_VERSION"
-                echo "Cached version: ${CACHED_VERSION:-<none>}"
+                echo "Stored version: ${STORED_VERSION:-<none>}"
 
-                # Compare new version with cached version
-                if [ -n "$CACHED_VERSION" ] && [ "$NEW_VERSION" != "$CACHED_VERSION" ]; then
-                  echo "Version changed: $CACHED_VERSION -> $NEW_VERSION"
+                # Compare new version with stored version
+                if [ -n "$STORED_VERSION" ] && [ "$NEW_VERSION" != "$STORED_VERSION" ]; then
+                  echo "Version changed: $STORED_VERSION -> $NEW_VERSION"
                   NEEDS_REBUILD=true
-                elif [ -z "$CACHED_VERSION" ]; then
-                  echo "No cached version - first build or cache cleared, will trigger rebuild"
+                elif [ -z "$STORED_VERSION" ]; then
+                  echo "No stored version - first build, will trigger rebuild"
                   NEEDS_REBUILD=true
                 else
-                  echo "Version unchanged (matches cache)"
+                  echo "Version unchanged (matches stored)"
                 fi
               else
                 echo "pkgver script returned empty result"
@@ -248,8 +259,6 @@ jobs:
               echo "Marking for rebuild"
               # Write to temp file to persist across subshell
               echo "$path|$NEW_VERSION" >> /tmp/to_rebuild.txt
-              # Update state file with new version
-              jq --arg key "$path" --arg ver "$NEW_VERSION" '.[$key] = $ver' "$STATE_FILE" > "$STATE_FILE.tmp" && mv "$STATE_FILE.tmp" "$STATE_FILE"
             else
               echo "No rebuild needed"
             fi
@@ -277,13 +286,6 @@ jobs:
             echo "has_updates=false" >> $GITHUB_OUTPUT
           fi
 
-      - name: Update rolling state cache
-        if: always()
-        run: |
-          if [ -f .rolling-state.json ]; then
-            echo "State file updated with $(jq 'length' .rolling-state.json) tracked versions"
-          fi
-
   rebuild:
     needs: [find-rolling-packages, check-for-updates]
     if: needs.check-for-updates.outputs.has_updates == 'true'
