prerelease.yml

name: Pre-release Build

on:
  push:
    branches:
      - main
  workflow_dispatch:
    inputs:
      version:
        description: "Pre-release version (e.g. 0.9.0-alpha.1)"
        required: true
        type: string
      channel:
        description: "Channel"
        required: true
        type: choice
        options: [alpha, beta, rc]
        default: alpha

permissions:
  contents: write
  packages: write

jobs:
  version:
    name: Resolve Version
    runs-on: ubuntu-latest
    outputs:
      version: ${{ steps.v.outputs.version }}
    steps:
      - uses: actions/checkout@v6
        with:
          fetch-depth: 0

      - name: Determine version
        id: v
        run: |
          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
            echo "version=${{ inputs.version }}" >> $GITHUB_OUTPUT
          else
            BASE=$(grep -m1 '^version' Cargo.toml | sed 's/[^"]*"\([^"]*\)".*/\1/')
            COUNT=$(git rev-list --count HEAD)
            echo "version=${BASE}-alpha.${COUNT}" >> $GITHUB_OUTPUT
          fi

  build-binaries:
    name: Build ${{ matrix.binary }} (${{ matrix.arch }})
    runs-on: ${{ matrix.runner }}
    needs: version
    strategy:
      fail-fast: false
      matrix:
        binary:
          - csfx-updater
          - csfx-agent
        arch:
          - amd64
          - arm64
        include:
          - arch: amd64
            runner: ubuntu-latest
            target: x86_64-unknown-linux-musl
          - arch: arm64
            runner: ubuntu-24.04-arm
            target: aarch64-unknown-linux-musl
    steps:
      - uses: actions/checkout@v6

      - name: Install build dependencies
        run: |
          sudo apt-get update
          if [ "${{ matrix.arch }}" = "amd64" ]; then
            sudo apt-get install -y musl-tools protobuf-compiler
          else
            sudo apt-get install -y gcc-aarch64-linux-gnu musl-tools protobuf-compiler
          fi

      - name: Install Rust toolchain
        uses: dtolnay/rust-toolchain@stable
        with:
          targets: ${{ matrix.target }}

      - name: Cache cargo
        uses: actions/cache@v5
        with:
          path: |
            ~/.cargo/registry
            ~/.cargo/git
            target
          key: ${{ matrix.binary }}-${{ matrix.arch }}-${{ hashFiles('**/Cargo.lock') }}

      - name: Build
        env:
          CARGO_TARGET_X86_64_UNKNOWN_LINUX_MUSL_LINKER: musl-gcc
          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_LINKER: aarch64-linux-gnu-gcc
          CSFX_BUILD_VERSION: ${{ needs.version.outputs.version }}
        run: |
          cargo build --release --bin ${{ matrix.binary }} --target ${{ matrix.target }}
          cp target/${{ matrix.target }}/release/${{ matrix.binary }} ${{ matrix.binary }}-${{ matrix.arch }}
          sha256sum ${{ matrix.binary }}-${{ matrix.arch }} > ${{ matrix.binary }}-${{ matrix.arch }}.sha256

      - uses: actions/upload-artifact@v7
        with:
          name: ${{ matrix.binary }}-${{ matrix.arch }}
          path: |
            ${{ matrix.binary }}-${{ matrix.arch }}
            ${{ matrix.binary }}-${{ matrix.arch }}.sha256
          retention-days: 7

  build-frontend:
    name: Build frontend
    runs-on: ubuntu-latest
    needs: version
    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-node@v4
        with:
          node-version: "20"
          cache: "npm"
          cache-dependency-path: app/package-lock.json

      - name: Install dependencies
        working-directory: app
        run: npm ci

      - name: Build
        working-directory: app
        env:
          VITE_API_URL: ""
        run: npm run build

      - name: Archive
        run: tar -czf csfx-frontend.tar.gz -C app/build .

      - name: Checksum
        run: sha256sum csfx-frontend.tar.gz > csfx-frontend.tar.gz.sha256

      - uses: actions/upload-artifact@v4
        with:
          name: csfx-frontend
          path: |
            csfx-frontend.tar.gz
            csfx-frontend.tar.gz.sha256
          retention-days: 7

  build-cp-binaries:
    name: Build CP ${{ matrix.binary }} (${{ matrix.arch }})
    runs-on: ${{ matrix.runner }}
    needs: version
    strategy:
      fail-fast: false
      matrix:
        binary:
          - api-gateway
          - registry
          - scheduler
          - volume-manager
          - failover-controller
          - sdn-controller
          - csfx-migrate
        arch:
          - amd64
          - arm64
        include:
          - arch: amd64
            runner: ubuntu-latest
            target: x86_64-unknown-linux-musl
          - arch: arm64
            runner: ubuntu-24.04-arm
            target: aarch64-unknown-linux-musl
    steps:
      - uses: actions/checkout@v6

      - name: Install build dependencies
        run: |
          sudo apt-get update
          if [ "${{ matrix.arch }}" = "amd64" ]; then
            sudo apt-get install -y musl-tools protobuf-compiler libpq-dev
          else
            sudo apt-get install -y gcc-aarch64-linux-gnu musl-tools protobuf-compiler libpq-dev
          fi

      - name: Install Rust toolchain
        uses: dtolnay/rust-toolchain@stable
        with:
          targets: ${{ matrix.target }}

      - name: Cache cargo
        uses: actions/cache@v5
        with:
          path: |
            ~/.cargo/registry
            ~/.cargo/git
            target
          key: cp-${{ matrix.binary }}-${{ matrix.arch }}-${{ hashFiles('**/Cargo.lock') }}

      - name: Build
        env:
          CARGO_TARGET_X86_64_UNKNOWN_LINUX_MUSL_LINKER: musl-gcc
          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_LINKER: aarch64-linux-gnu-gcc
          CSFX_BUILD_VERSION: ${{ needs.version.outputs.version }}
        run: |
          cargo build --release --bin ${{ matrix.binary }} --target ${{ matrix.target }}
          cp target/${{ matrix.target }}/release/${{ matrix.binary }} csfx-cp-${{ matrix.binary }}-${{ matrix.arch }}
          sha256sum csfx-cp-${{ matrix.binary }}-${{ matrix.arch }} > csfx-cp-${{ matrix.binary }}-${{ matrix.arch }}.sha256

      - uses: actions/upload-artifact@v7
        with:
          name: csfx-cp-${{ matrix.binary }}-${{ matrix.arch }}
          path: |
            csfx-cp-${{ matrix.binary }}-${{ matrix.arch }}
            csfx-cp-${{ matrix.binary }}-${{ matrix.arch }}.sha256
          retention-days: 7

  github-release:
    name: GitHub Pre-release
    runs-on: ubuntu-latest
    needs: [version, build-binaries, build-cp-binaries, build-frontend]
    steps:
      - uses: actions/checkout@v6

      - uses: actions/download-artifact@v8
        with:
          pattern: csfx-*
          merge-multiple: true

      - name: Create pre-release
        run: |
          VERSION="${{ needs.version.outputs.version }}"
          CP_BINS=""
          for svc in api-gateway registry scheduler volume-manager failover-controller sdn-controller csfx-migrate; do
            for arch in amd64 arm64; do
              CP_BINS="${CP_BINS} csfx-cp-${svc}-${arch} csfx-cp-${svc}-${arch}.sha256"
            done
          done

          gh release create "v${VERSION}" \
            --title "v${VERSION}" \
            --prerelease \
            --generate-notes \
            csfx-updater-amd64 \
            csfx-updater-amd64.sha256 \
            csfx-updater-arm64 \
            csfx-updater-arm64.sha256 \
            csfx-agent-amd64 \
            csfx-agent-amd64.sha256 \
            csfx-agent-arm64 \
            csfx-agent-arm64.sha256 \
            csfx-frontend.tar.gz \
            csfx-frontend.tar.gz.sha256 \
            ${CP_BINS}
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  update-infra:
    name: Update CSFX-Infra versions.nix
    runs-on: ubuntu-latest
    needs: [version, build-binaries, build-cp-binaries, build-frontend, github-release]
    steps:
      - uses: actions/checkout@v6
        with:
          repository: ${{ github.repository_owner }}/CSFX-Infra
          token: ${{ secrets.INFRA_REPO_TOKEN }}
          ref: main
          path: infra

      - uses: actions/download-artifact@v8
        with:
          pattern: csfx-agent-*
          path: /tmp/binaries
          merge-multiple: true

      - uses: actions/download-artifact@v8
        with:
          pattern: csfx-updater-*
          path: /tmp/binaries
          merge-multiple: true

      - uses: actions/download-artifact@v8
        with:
          pattern: csfx-cp-*
          path: /tmp/cp-binaries
          merge-multiple: true

      - uses: actions/download-artifact@v4
        with:
          name: csfx-frontend
          path: /tmp/frontend

      - name: Write versions.nix
        run: |
          VERSION="${{ needs.version.outputs.version }}"
          REPO="${{ github.repository }}"
          RELEASE_BASE="https://github.com/${REPO}/releases/download/v${VERSION}"

          get_sha256() {
            local file=$1
            awk '{print $1}' "/tmp/binaries/${file}.sha256" 2>/dev/null
          }

          get_cp_sha256() {
            local file=$1
            awk '{print $1}' "/tmp/cp-binaries/${file}.sha256" 2>/dev/null
          }

          FRONTEND_SHA256=$(awk '{print $1}' /tmp/frontend/csfx-frontend.tar.gz.sha256 2>/dev/null)

          cat > infra/versions.nix <<EOF
          {
            csfx = {
              version = "${VERSION}";
              agent = {
                amd64 = {
                  url    = "${RELEASE_BASE}/csfx-agent-amd64";
                  sha256 = "$(get_sha256 csfx-agent-amd64)";
                };
                arm64 = {
                  url    = "${RELEASE_BASE}/csfx-agent-arm64";
                  sha256 = "$(get_sha256 csfx-agent-arm64)";
                };
              };
              controlPlane = {
                migrate = {
                  amd64 = {
                    url    = "${RELEASE_BASE}/csfx-cp-csfx-migrate-amd64";
                    sha256 = "$(get_cp_sha256 csfx-cp-csfx-migrate-amd64)";
                  };
                  arm64 = {
                    url    = "${RELEASE_BASE}/csfx-cp-csfx-migrate-arm64";
                    sha256 = "$(get_cp_sha256 csfx-cp-csfx-migrate-arm64)";
                  };
                };
                api-gateway = {
                  amd64 = {
                    url    = "${RELEASE_BASE}/csfx-cp-api-gateway-amd64";
                    sha256 = "$(get_cp_sha256 csfx-cp-api-gateway-amd64)";
                  };
                  arm64 = {
                    url    = "${RELEASE_BASE}/csfx-cp-api-gateway-arm64";
                    sha256 = "$(get_cp_sha256 csfx-cp-api-gateway-arm64)";
                  };
                };
                registry = {
                  amd64 = {
                    url    = "${RELEASE_BASE}/csfx-cp-registry-amd64";
                    sha256 = "$(get_cp_sha256 csfx-cp-registry-amd64)";
                  };
                  arm64 = {
                    url    = "${RELEASE_BASE}/csfx-cp-registry-arm64";
                    sha256 = "$(get_cp_sha256 csfx-cp-registry-arm64)";
                  };
                };
                scheduler = {
                  amd64 = {
                    url    = "${RELEASE_BASE}/csfx-cp-scheduler-amd64";
                    sha256 = "$(get_cp_sha256 csfx-cp-scheduler-amd64)";
                  };
                  arm64 = {
                    url    = "${RELEASE_BASE}/csfx-cp-scheduler-arm64";
                    sha256 = "$(get_cp_sha256 csfx-cp-scheduler-arm64)";
                  };
                };
                volume-manager = {
                  amd64 = {
                    url    = "${RELEASE_BASE}/csfx-cp-volume-manager-amd64";
                    sha256 = "$(get_cp_sha256 csfx-cp-volume-manager-amd64)";
                  };
                  arm64 = {
                    url    = "${RELEASE_BASE}/csfx-cp-volume-manager-arm64";
                    sha256 = "$(get_cp_sha256 csfx-cp-volume-manager-arm64)";
                  };
                };
                failover-controller = {
                  amd64 = {
                    url    = "${RELEASE_BASE}/csfx-cp-failover-controller-amd64";
                    sha256 = "$(get_cp_sha256 csfx-cp-failover-controller-amd64)";
                  };
                  arm64 = {
                    url    = "${RELEASE_BASE}/csfx-cp-failover-controller-arm64";
                    sha256 = "$(get_cp_sha256 csfx-cp-failover-controller-arm64)";
                  };
                };
                sdn-controller = {
                  amd64 = {
                    url    = "${RELEASE_BASE}/csfx-cp-sdn-controller-amd64";
                    sha256 = "$(get_cp_sha256 csfx-cp-sdn-controller-amd64)";
                  };
                  arm64 = {
                    url    = "${RELEASE_BASE}/csfx-cp-sdn-controller-arm64";
                    sha256 = "$(get_cp_sha256 csfx-cp-sdn-controller-arm64)";
                  };
                };
                csfx-updater = {
                  amd64 = {
                    url    = "${RELEASE_BASE}/csfx-updater-amd64";
                    sha256 = "$(get_sha256 csfx-updater-amd64)";
                  };
                  arm64 = {
                    url    = "${RELEASE_BASE}/csfx-updater-arm64";
                    sha256 = "$(get_sha256 csfx-updater-arm64)";
                  };
                };
              };
              frontend = {
                url    = "${RELEASE_BASE}/csfx-frontend.tar.gz";
                sha256 = "${FRONTEND_SHA256}";
              };
            };
          }
          EOF

      - name: Commit and push versions.nix
        run: |
          VERSION="${{ needs.version.outputs.version }}"
          cd infra
          git config user.name "github-actions[bot]"
          git config user.email "github-actions[bot]@users.noreply.github.com"
          git add versions.nix
          git diff --cached --quiet && echo "no changes" && exit 0
          git commit -m "chore: update versions.nix for v${VERSION}"
          git push origin main
          git tag "v${VERSION}"
          git push origin "v${VERSION}"