build_binary.yml

name: 'Build Binary'
description: |
  This workflow builds the binary files for Linux. The build binaries are stored as artifact
  and may be reused by other workflows.

on:
  push:
    branches: ['main']
    tags: ['*']

  pull_request:
    branches: ['*']

jobs:
  setup-matrix:
    name: 'Setup matrix'
    runs-on: ubuntu-24.04
    steps:
      - id: setup-matrix
        uses: loat-dev/generate-matrix@v1.0.0
        with:
          matrix: |
            include:
              - runner: ubuntu-24.04
                target: x86_64-linux-gnu
                arch: x86_64
                image: quay.io/pypa/manylinux_2_28_x86_64@sha256:4dc41da7df20400310c80d162a2fe2d2c2f3d9734d8dec20f6b9843711618deb

              - runner: ubuntu-24.04-arm
                target: aarch64-linux-gnu
                arch: aarch64
                image: quay.io/pypa/manylinux_2_28_aarch64@sha256:29a6ceb78de5b00494e6e7456a72782a4cb54238de102e7491d15fe47789b4d1

    outputs:
      matrix: ${{ steps.setup-matrix.outputs.matrix }}

  generate-target-metadata:
    name: 'Generate target metadata (${{ matrix.target }})'
    needs: ['setup-matrix']
    runs-on: ${{ matrix.runner }}
    env:
      ASTREIN_VERSION: '3.0.0'

    strategy:
      fail-fast: false
      matrix: ${{ fromJson(needs.setup-matrix.outputs.matrix) }}

    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v7
        with:
          fetch-depth: 0

      - name: 'Install native compiler'
        run: |
          sudo apt-get update
          sudo apt-get install -y \
            gcc-14 \
            g++-14

      - name: 'Setup ASTrein'
        id: astrein
        uses: Katze719/setup-astrein@v1
        with:
          version: ${{ env.ASTREIN_VERSION }}

      - name: 'Setup CMake'
        uses: jwlawson/actions-setup-cmake@v2
        with:
          cmake-version: '3.31.x'

      - name: 'Configure native metadata context'
        run: |
          cmake -S . \
            -B "build/ffi/${{ matrix.arch }}" \
            -G Ninja \
            -DCMAKE_BUILD_TYPE=Release \
            -DCMAKE_C_COMPILER=gcc-14 \
            -DCMAKE_CXX_COMPILER=g++-14 \
            -DCPP_BINDINGS_LINUX_ENABLE_FFI_JSON_EXPORT=ON \
            -DCPP_BINDINGS_LINUX_ASTREIN_EXECUTABLE="${{ steps.astrein.outputs.path }}" \
            -DCPP_BINDINGS_LINUX_FFI_JSON_OUTPUT="${GITHUB_WORKSPACE}/dist/ffi/${{ matrix.arch }}.ffi.json"

      - name: 'Generate metadata'
        run: |
          cmake --build "build/ffi/${{ matrix.arch }}" \
            --target cpp_bindings_linux_ffi_json

      - name: 'Upload target-specific FFI metadata'
        uses: actions/upload-artifact@v7
        with:
          if-no-files-found: error
          name: cpp-bindings-linux-ffi-${{ matrix.target }}
          path: dist/ffi/${{ matrix.arch }}.ffi.json

  generate-metadata:
    name: 'Generate metadata'
    needs: ['generate-target-metadata']
    runs-on: ubuntu-24.04
    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v7
        with:
          fetch-depth: 0

      - name: 'Setup CMake'
        uses: jwlawson/actions-setup-cmake@v2
        with:
          cmake-version: '3.31.x'

      - name: 'Install package-context compiler'
        run: |
          sudo apt-get update
          sudo apt-get install -y \
            gcc-14 \
            g++-14

      - name: 'Configure package context'
        run: |
          cmake -S . \
            -B build/package \
            -G Ninja \
            -DCMAKE_BUILD_TYPE=Release \
            -DCMAKE_C_COMPILER=gcc-14 \
            -DCMAKE_CXX_COMPILER=g++-14

      - name: 'Set package version'
        id: version
        run: |
          . build/package/env.sh
          echo "PACKAGE_VERSION=${PACKAGE_VERSION}" >> "${GITHUB_OUTPUT}"

      - name: 'Check package version'
        id: check-tag
        env:
          PACKAGE_VERSION: ${{ steps.version.outputs.PACKAGE_VERSION }}
        run: |
          if [[ "${PACKAGE_VERSION}" =~ ^(0|[1-9][[:digit:]]*)\.(0|[1-9][[:digit:]]*)\.(0|[1-9][[:digit:]]*)(-(alpha|rc|beta|experimental)\.[1-9][[:digit:]]*)?$ ]]; then
            echo "Version \"${PACKAGE_VERSION}\" is a valid package version."
            echo "IS_VALID_PACKAGE_VERSION=true" >> "${GITHUB_OUTPUT}"
          else
            echo "Version \"${PACKAGE_VERSION}\" is not a valid package version."
            echo "IS_VALID_PACKAGE_VERSION=false" >> "${GITHUB_OUTPUT}"
          fi

      - name: 'Download target-specific FFI metadata'
        uses: actions/download-artifact@v8
        with:
          pattern: cpp-bindings-linux-ffi-*
          path: dist/ffi
          merge-multiple: true

      - name: 'Upload combined FFI metadata'
        uses: actions/upload-artifact@v7
        with:
          if-no-files-found: error
          name: cpp-bindings-linux-ffi
          path: dist/ffi/*.ffi.json
    
    outputs:
      package_version: ${{ steps.version.outputs.PACKAGE_VERSION }}
      is_valid_package_version: ${{ steps.check-tag.outputs.IS_VALID_PACKAGE_VERSION }}

  build-binary:
    name: 'Build binary (${{ matrix.target }})'
    needs: ['setup-matrix']
    runs-on: ${{ matrix.runner }}
    container:
      image: ${{ matrix.image }}

    strategy:
      fail-fast: false
      matrix: ${{ fromJson(needs.setup-matrix.outputs.matrix) }}

    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v7
        with:
          fetch-depth: 0

      - name: 'Enable Git metadata in the build container'
        run: |
          git config --global --add safe.directory "${GITHUB_WORKSPACE}"
          git rev-parse --verify HEAD

      - name: 'Configure portable release'
        run: |
          cmake -S . \
            -B build \
            -G "Unix Makefiles" \
            -DCMAKE_BUILD_TYPE=Release \
            -DCMAKE_C_COMPILER=gcc \
            -DCMAKE_CXX_COMPILER=g++ \
            -DCPP_BINDINGS_LINUX_PORTABLE_CPU_BASELINE=ON \
            -DCPP_BINDINGS_LINUX_STATIC_CXX_RUNTIME=ON

      - name: 'Build and test'
        run: |
          cmake --build build \
            --target cpp_bindings_linux cpp_bindings_linux_tests \
            --parallel 4
          ctest --test-dir build \
            --output-on-failure \
            --output-junit test-report.xml

      - name: 'Stage and verify binary'
        run: |
          mkdir -p "dist/${{ matrix.target }}"
          cp -L build/libcpp_bindings_linux.so \
            "dist/${{ matrix.target }}/libcpp_bindings_linux.so"
          ./scripts/verify_release_binary.sh \
            "dist/${{ matrix.target }}/libcpp_bindings_linux.so" \
            "${{ matrix.target }}"

      - name: 'Upload test report'
        if: always()
        uses: actions/upload-artifact@v7
        with:
          if-no-files-found: warn
          name: test-report-${{ matrix.target }}
          path: build/test-report.xml

      - name: 'Upload binary'
        uses: actions/upload-artifact@v7
        with:
          if-no-files-found: error
          name: libcpp_bindings_linux-${{ matrix.target }}
          path: dist/${{ matrix.target }}/libcpp_bindings_linux.so

  test-unit-cpp:
    name: 'Run: Test Unit C++'
    needs: ['build-binary']
    uses: './.github/workflows/test_unit_cpp.yml'
    permissions:
      contents: read
      checks: write

    with:
      artifact-name: libcpp_bindings_linux-x86_64-linux-gnu

  create-release:
    name: 'Create GitHub release'
    needs:
      - setup-matrix
      - generate-metadata
      - build-binary
      - test-unit-cpp

    if: github.ref_type == 'tag' && needs.generate-metadata.outputs.is_valid_package_version == 'true'
    runs-on: ubuntu-24.04
    permissions:
      contents: write

    steps:
      - name: 'Download binaries'
        uses: actions/download-artifact@v8
        with:
          pattern: libcpp_bindings_linux-*
          path: release/binaries

      - name: 'Download FFI metadata'
        uses: actions/download-artifact@v8
        with:
          name: cpp-bindings-linux-ffi
          path: release/ffi

      - name: 'Name release assets'
        env:
          MATRIX_JSON: ${{ needs.setup-matrix.outputs.matrix }}

        run: |
          mkdir -p release/assets
          echo "${MATRIX_JSON}" | jq -c '.include[]' | while read -r entry; do
            target=$(jq -r '.target' <<< "${entry}")
            arch=$(jq -r '.arch' <<< "${entry}")

            cp "release/binaries/libcpp_bindings_linux-${target}/libcpp_bindings_linux.so" \
              "release/assets/libcpp_bindings_linux-${target}.so"
            cp "release/ffi/${arch}.ffi.json" \
              "release/assets/cpp_bindings_linux-${target}.ffi.json"
          done

      - name: 'Create GitHub release'
        uses: softprops/action-gh-release@v2
        with:
          name: 'v${{ needs.generate-metadata.outputs.package_version }}'
          tag_name: ${{ github.ref_name }}
          generate_release_notes: true
          files: release/assets/*

  publish-jsr:
    name: 'Run: Publish JSR'
    needs: 
      - 'setup-matrix'
      - 'generate-metadata'
      - 'build-binary'
      - 'test-unit-cpp'

    uses: './.github/workflows/publish_jsr.yml'
    permissions:
      contents: read
      id-token: write

    with:
      publish: ${{ needs.generate-metadata.outputs.is_valid_package_version == 'true' }}
      version: ${{ needs.generate-metadata.outputs.package_version }}
      matrix: ${{ needs.setup-matrix.outputs.matrix }}
      artifact-name-prefix: libcpp_bindings_linux
      ffi-artifact-name: cpp-bindings-linux-ffi