Refactor

Author: ValentaTomas

.github/workflows/build.yml

@@ -2,49 +2,27 @@ name: Build Firecracker Versions
 
 on:
   workflow_call:
-    outputs:
-      versions:
-        description: "JSON array of versions that were built"
-        value: ${{ jobs.prepare.outputs.versions }}
+    inputs:
+      version:
+        required: true
+        type: string
+      hash:
+        required: true
+        type: string
+      version_name:
+        required: true
+        type: string
   workflow_dispatch:
 
 jobs:
-  prepare:
-    runs-on: ubuntu-latest
-    outputs:
-      versions: ${{ steps.set-versions.outputs.versions }}
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Parse versions from file
-        id: set-versions
-        run: |
-          versions=$(./scripts/parse-versions.sh firecracker_versions.txt)
-          echo "versions=$versions" >> $GITHUB_OUTPUT
-          echo "Building versions: $versions"
-
   build:
-    needs: prepare
     runs-on: ubuntu-latest
-    strategy:
-      fail-fast: true
-      matrix:
-        version: ${{ fromJson(needs.prepare.outputs.versions) }}
     steps:
       - uses: actions/checkout@v4
-
-      - name: Build Firecracker ${{ matrix.version }}
-        id: build
-        run: |
-          ./build.sh "${{ matrix.version }}"
-          # Read the computed version name (with hash) - format is "version_name:commit_hash"
-          version_info=$(cat built_versions.txt | tail -1)
-          version_name=$(echo "$version_info" | cut -d: -f1)
-          echo "version_name=$version_name" >> $GITHUB_OUTPUT
-
-      - name: Upload build artifact
-        uses: actions/upload-artifact@v4
+      - name: Build Firecracker ${{ inputs.version_name }}
+        run: ./build.sh "${{ inputs.version }}" "${{ inputs.hash }}" "${{ inputs.version_name }}"
+      - uses: actions/upload-artifact@v4
         with:
-          name: firecracker-${{ steps.build.outputs.version_name }}
+          name: firecracker-${{ inputs.version_name }}
           path: builds/
           retention-days: 7

.github/workflows/fc-versions.yml

@@ -13,55 +13,61 @@ permissions:
   contents: write
 
 jobs:
-  # Run parallel builds via reusable workflow
+  prepare:
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.set-matrix.outputs.matrix }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Parse versions and resolve hashes
+        id: set-matrix
+        run: |
+          versions_json=$(./scripts/parse-versions-with-hash.sh firecracker_versions.txt)
+          echo "matrix=$versions_json" >> $GITHUB_OUTPUT
+
   build:
+    needs: prepare
     uses: ./.github/workflows/build.yml
+    strategy:
+      fail-fast: true
+      matrix:
+        include: ${{ fromJson(needs.prepare.outputs.matrix) }}
+    with:
+      version: ${{ matrix.version }}
+      hash: ${{ matrix.hash }}
+      version_name: ${{ matrix.version_name }}
 
-  # Check CI status in parallel with builds (for faster feedback)
   check-ci:
-    name: Check FC repo CI status
     runs-on: ubuntu-latest
     outputs:
       ci_passed: ${{ steps.ci-check.outputs.ci_passed }}
     steps:
       - uses: actions/checkout@v4
-
-      - name: Check CI status for all versions
+      - name: Check CI status
         id: ci-check
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           output=$(./scripts/check-fc-ci.sh firecracker_versions.txt)
           echo "$output"
-          # Extract ci_passed from last line
           ci_passed=$(echo "$output" | grep "^ci_passed=" | cut -d= -f2)
           echo "ci_passed=$ci_passed" >> $GITHUB_OUTPUT
 
-  # Collect artifacts and publish (waits for both build and CI check)
   publish:
     name: Collect and upload builds
     needs: [build, check-ci]
     runs-on: ubuntu-22.04
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-
-      # Download all build artifacts
-      - name: Download all build artifacts
-        uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v4
         with:
           path: builds
           pattern: firecracker-*
           merge-multiple: true
-
-      - name: List downloaded builds
-        run: find builds -type f | head -20
-
       - name: CI check result
         run: |
-          echo "CI check passed: ${{ needs.check-ci.outputs.ci_passed }}"
           if [[ "${{ needs.check-ci.outputs.ci_passed }}" != "true" ]]; then
             echo "⚠️ CI checks did not pass - skipping GCS upload and release"
           fi
@@ -82,41 +88,22 @@ jobs:
           gzip: false
           parent: false
 
-      - name: Create releases for each Firecracker version
+      - name: Create releases
         if: github.ref_name == 'main' && needs.check-ci.outputs.ci_passed == 'true'
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           git config user.name "github-actions"
           git config user.email "[email protected]"
-
           for dir in ./builds/*/; do
             version_name=$(basename "$dir")
-            binary_path="$dir/firecracker"
-
-            echo "Processing $version_name..."
-
-            # Check if tag already exists
-            if git rev-parse "refs/tags/$version_name" >/dev/null 2>&1; then
-              echo "Tag $version_name already exists, skipping..."
-              continue
-            fi
-
-            # Check if release already exists
-            if gh release view "$version_name" >/dev/null 2>&1; then
-              echo "Release $version_name already exists, skipping..."
+            if git rev-parse "refs/tags/$version_name" >/dev/null 2>&1 || gh release view "$version_name" >/dev/null 2>&1; then
               continue
             fi
-
-            echo "Creating tag and release for $version_name..."
-
-            # Create and push tag
             git tag "$version_name"
             git push origin "$version_name"
-
-            # Create release with the binary
             gh release create "$version_name" \
               --title "Firecracker $version_name" \
               --notes "Firecracker build: $version_name" \
-              "$binary_path#${version_name}"
+              "$dir/firecracker#${version_name}"
           done

build.sh

@@ -4,73 +4,34 @@ set -euo pipefail
 
 FIRECRACKER_REPO_URL="https://github.com/e2b-dev/firecracker.git"
 
-function build_version {
-  local version=$1
-
-  # Detect if the version is of the form tag_shorthash (e.g., v1.12.1_abcdef12)
-  if [[ "$version" =~ ^([^_]+)_([0-9a-fA-F]+)$ ]]; then
-    local tag="${BASH_REMATCH[1]}"
-    local shorthash="${BASH_REMATCH[2]}"
-    echo "Starting build for Firecracker tag: $tag and shorthash: $shorthash"
+if [[ $# -lt 3 ]]; then
+  echo "Usage: $0 <version> <hash> <version_name>" >&2
+  exit 1
+fi
 
-    echo "Checking out repo at tag: $tag"
-    git checkout "$tag"
+version="$1"
+fullhash="$2"
+version_name="$3"
 
-    # Find full hash from shorthash
-    fullhash=$(git rev-parse --verify "$shorthash^{commit}" 2>/dev/null || true)
-    if [[ -z "$fullhash" ]]; then
-      echo "Error: Could not resolve hash $shorthash"
-      exit 1
-    fi
+git clone $FIRECRACKER_REPO_URL firecracker
+cd firecracker
 
-    # Ensure that $fullhash is a descendant of $tag
-    if git merge-base --is-ancestor "$tag" "$fullhash"; then
-      echo "Shorthash $shorthash is AFTER tag $tag -- proceeding"
-      git checkout "$fullhash"
-    else
-      echo "Error: shorthash $shorthash is not a descendant of tag $tag"
-      exit 1
-    fi
-    version_name="${tag}_$shorthash"
-  else
-    echo "Starting build for Firecracker at commit: $version"
-    echo "Checking out repo for Firecracker at commit: $version"
-    git checkout "${version}"
-    
-    fullhash=$(git rev-parse HEAD)
-    # The format will be: latest_tag_latest_commit_hash — v1.7.0-dev_g8bb88311
-    version_name=$(git describe --tags --abbrev=0 "$fullhash")_$(git rev-parse --short HEAD)
+if [[ "$version" =~ ^([^_]+)_([0-9a-fA-F]+)$ ]]; then
+  tag="${BASH_REMATCH[1]}"
+  git checkout "$tag"
+  if ! git merge-base --is-ancestor "$tag" "$fullhash"; then
+    echo "Error: shorthash is not a descendant of tag $tag" >&2
+    exit 1
   fi
-
-  echo "Version name: $version_name"
-
-  echo "Building Firecracker version: $version_name"
-  # Build only the firecracker binary, skip jailer and snapshot-editor for faster builds
-  tools/devtool -y build --release -- --bin firecracker
-
-  echo "Copying finished build to builds directory"
-  mkdir -p "../builds/${version_name}"
-  cp build/cargo_target/x86_64-unknown-linux-musl/release/firecracker "../builds/${version_name}/firecracker"
-  
-  # Write version name and commit hash to file for CI to use
-  echo "${version_name}:${fullhash}" >> ../built_versions.txt
-}
-
-# If a version is passed as argument, build only that version
-# Otherwise, build all versions from firecracker_versions.txt
-if [[ $# -ge 1 ]]; then
-  versions=("$@")
+  git checkout "$fullhash"
 else
-  mapfile -t versions < <(grep -v '^ *#' firecracker_versions.txt | grep -v '^$')
+  git checkout "$fullhash"
 fi
 
-echo "Cloning the Firecracker repository"
-git clone $FIRECRACKER_REPO_URL firecracker
-cd firecracker
+tools/devtool -y build --release -- --bin firecracker
 
-for version in "${versions[@]}"; do
-  build_version "$version"
-done
+mkdir -p "../builds/${version_name}"
+cp build/cargo_target/x86_64-unknown-linux-musl/release/firecracker "../builds/${version_name}/firecracker"
 
 cd ..
 rm -rf firecracker

scripts/check-fc-ci.sh

@@ -1,6 +1,4 @@
 #!/bin/bash
-# Check CI status for all Firecracker versions
-# Outputs: ci_passed=true|false to stdout (for GitHub Actions)
 
 set -euo pipefail
 
@@ -13,34 +11,25 @@ if [[ ! -f "$VERSIONS_FILE" ]]; then
   exit 1
 fi
 
-# Clone FC repo to resolve commit hashes
 TEMP_DIR=$(mktemp -d)
 trap "rm -rf $TEMP_DIR" EXIT
 
-echo "Cloning FC repo to resolve commit hashes..."
 git clone --bare "$FIRECRACKER_REPO_URL" "$TEMP_DIR/fc-repo" 2>/dev/null
 cd "$TEMP_DIR/fc-repo"
 
 all_passed=true
 failed_versions=""
 
-# Read versions from file
 while IFS= read -r version || [[ -n "$version" ]]; do
-  # Skip comments and empty lines
   [[ "$version" =~ ^[[:space:]]*# ]] && continue
   [[ -z "$version" ]] && continue
 
-  echo "Processing version: $version"
-  
-  # Resolve commit hash
   if [[ "$version" =~ ^([^_]+)_([0-9a-fA-F]+)$ ]]; then
-    # Format: tag_shorthash
     tag="${BASH_REMATCH[1]}"
     shorthash="${BASH_REMATCH[2]}"
     commit_hash=$(git rev-parse --verify "$shorthash^{commit}" 2>/dev/null || echo "")
     version_name="${tag}_${shorthash}"
   else
-    # Plain tag
     commit_hash=$(git rev-parse --verify "${version}^{commit}" 2>/dev/null || echo "")
     if [[ -n "$commit_hash" ]]; then
       short_hash=$(git rev-parse --short "$commit_hash")
@@ -57,15 +46,10 @@ while IFS= read -r version || [[ -n "$version" ]]; do
     continue
   fi
 
-  echo "  Checking CI for $version_name (commit: $commit_hash)..."
-  
-  # Check combined commit status (returns total_count of statuses)
   status_response=$(gh api "/repos/${FIRECRACKER_REPO_API}/commits/${commit_hash}/status" 2>/dev/null || echo '{"state":"unknown","total_count":0}')
   status=$(echo "$status_response" | jq -r '.state')
   status_count=$(echo "$status_response" | jq -r '.total_count')
 
-  # Check check-runs (GitHub Actions)
-  # Order matters: check pending BEFORE success (null conclusion means in-progress)
   check_response=$(gh api "/repos/${FIRECRACKER_REPO_API}/commits/${commit_hash}/check-runs" 2>/dev/null || echo '{"total_count":0}')
   check_count=$(echo "$check_response" | jq -r '.total_count')
   check_conclusion=$(echo "$check_response" | jq -r '
@@ -77,20 +61,11 @@ while IFS= read -r version || [[ -n "$version" ]]; do
     end
   ')
 
-  echo "  Status: $status (count: $status_count), Check runs: $check_conclusion (count: $check_count)"
-  
-  # Handle the different cases
   if [[ "$status" == "failure" ]] || [[ "$check_conclusion" == "failure" ]]; then
     echo "  ❌ CI failed for $version_name"
     all_passed=false
     failed_versions="${failed_versions}${version_name} "
-  elif [[ "$check_conclusion" == "pending" ]]; then
-    # Only pending if there are actual check-runs in progress
-    echo "  ⏳ CI still running for $version_name"
-    all_passed=false
-    failed_versions="${failed_versions}${version_name}(pending) "
-  elif [[ "$status" == "pending" ]] && [[ "$status_count" -gt 0 ]]; then
-    # Only pending if there are actual statuses pending
+  elif [[ "$check_conclusion" == "pending" ]] || ([[ "$status" == "pending" ]] && [[ "$status_count" -gt 0 ]]); then
     echo "  ⏳ CI still running for $version_name"
     all_passed=false
     failed_versions="${failed_versions}${version_name}(pending) "
@@ -101,24 +76,15 @@ while IFS= read -r version || [[ -n "$version" ]]; do
   elif [[ "$status" == "success" ]] || [[ "$check_conclusion" == "success" ]]; then
     echo "  ✅ CI passed for $version_name"
   elif [[ "$status_count" -eq 0 ]] && [[ "$check_count" -eq 0 ]]; then
-    # No CI configured for this commit - treat as acceptable
     echo "  ℹ️ No CI checks found for $version_name (assuming OK)"
   elif [[ "$status" == "pending" ]] && [[ "$status_count" -eq 0 ]] && [[ "$check_conclusion" == "no_checks" ]]; then
-    # GitHub returns "pending" when there are no statuses - this is OK
     echo "  ℹ️ No CI checks found for $version_name (assuming OK)"
   else
-    # Catch-all for unexpected states
     echo "  ⚠️ Unexpected CI state for $version_name: status=$status, check_conclusion=$check_conclusion"
     all_passed=false
     failed_versions="${failed_versions}${version_name}(unexpected) "
   fi
 done < "$OLDPWD/$VERSIONS_FILE"
 
 echo ""
-if [[ "$all_passed" == "true" ]]; then
-  echo "All CI checks passed!"
-  echo "ci_passed=true"
-else
-  echo "CI checks failed or pending for: $failed_versions"
-  echo "ci_passed=false"
-fi
+[[ "$all_passed" == "true" ]] && echo "ci_passed=true" || echo "ci_passed=false"