native-build.yml

name: 'fprime-build-native-scala'
on:
  workflow_call:
    inputs:
      working-directory:
        description: "Working directory to use when running commands"
        required: false
        default: .
        type: string
      build:
        description: "Build command for generating compiled JARs"
        required: false
        default: ./install
        type: string
      output-directory:
        description: "Directory for output of the build"
        required: false
        default: ./bin
        type: string
      test:
        description: "Test command used to generate tracing and prove output"
        required: false
        default: ./test
        type: string
      trace:
        description: "Turn off tracing step"
        required: false
        default: true
        type: boolean
      trace-directory:
        description: "Directory for tracing output"
        required: false
        default: trace/META-INF/native-image
        type: string
      extra-tools:
        description: "Extra meta-package tools publish"
        required: false
        default: ""
        type: string
jobs:
  build-jars:
    runs-on: "ubuntu-22.04"
    name: "Build Standard JARs"
    steps:
      - name: "Checkout repository"
        uses: actions/checkout@v3
        with:
          submodules: recursive
      - name: "Setup Native Image Tools"
        uses: ./.github/actions/native-tools-setup
      - name: "Building JAR files"
        run: |
          cd ${{ inputs.working-directory }}
          ${{ inputs.build }} ${{ inputs.output-directory }}
        shell: bash
      - name: "Archiving JARs package"
        uses: actions/upload-artifact@v4
        with:
          name: build-jar
          path: ${{ inputs.output-directory }}/fpp.jar
          retention-days: 5
          if-no-files-found: error
      - if: ${{ inputs.trace }}
        name: "Tracing JARs via Unit-Tests"
        run: |
          cd ${{ inputs.working-directory }}
          mkdir -p "${{ inputs.trace-directory }}"
          export TRACE_METADATA_DIRECTORY="$( pwd )/${{ inputs.trace-directory }}"
          export PATH="${NATIVE_IMAGE_TOOLS_PATH}:${PATH}"
          ${{ inputs.test }}
          echo -e "Trace output files:\n$( find ${{ inputs.trace-directory }} -name *.json )"
      - if: ${{ inputs.trace }}
        name: "Archiving Tracing"
        uses: actions/upload-artifact@v4
        with:
          name: jar-traces
          path: ${{ inputs.trace-directory }}/*.json
          retention-days: 5
          if-no-files-found: error
  generate-run-matricies:
    outputs:
      native: ${{ steps.set-matrix.outputs.native }}
      tags: ${{ steps.set-matrix.outputs.tags }}
    runs-on: ubuntu-22.04
    steps:
      - id: set-matrix
        shell: python
        run: |
          import os
          import json
          import sys
          matrix = {
            "run": [
              {
                "runner": "macos-14",
                "tag": "macosx_14_0_arm64"
              },
              {
                "runner": "macos-15-intel",
                "tag": "macosx_15_0_x86_64"
              },
              {
                "runner": "ubuntu-22.04",
                "tag": "manylinux_2_28_x86_64",
                "container": "quay.io/pypa/manylinux_2_28_x86_64"
              },
              {
                "runner": "ubuntu-22.04-arm",
                "tag": "manylinux_2_28_aarch64",
                "container": "quay.io/pypa/manylinux_2_28_aarch64"
              }
              
            ]
          }
          tags = {"tag": ["jar"] + [run["tag"] for run in matrix["run"]]}
          with open(os.environ["GITHUB_OUTPUT"], "a") as file_handle:
            for file_stream in [sys.stdout, file_handle]:
              print(f"native={json.dumps(matrix)}", file=file_stream)
              print(f"tags={json.dumps(tags)}", file=file_stream)
  build-native-images:
    needs: [build-jars, generate-run-matricies]
    strategy:
      matrix: ${{ fromJson(needs.generate-run-matricies.outputs.native) }}
    runs-on: ${{ matrix.run.runner }}
    container:
      image:  ${{ matrix.run.container || '' }}
    steps:
      - name: "Checkout repository"
        uses: actions/checkout@v3
        with:
          submodules: recursive
      - name: "Download JARs"
        uses: actions/download-artifact@v4
        with:
          name: build-jar
          path:  ${{ inputs.output-directory }}
      - if: ${{ inputs.trace }}
        name: "Download Tracing"
        uses: actions/download-artifact@v4
        with:
          name: jar-traces
          path: ${{ inputs.trace-directory }}
      - name: "Setting up GraalVM/Java Environment"
        uses: ./.github/actions/native-tools-setup
      - name: "Build Native Images"
        uses: ./.github/actions/build-native-images
        with:
          binary-directory: ${{ inputs.output-directory }}
          trace-directory: ${{ inputs.trace-directory }}
      - name: "Archive Native Images"
        uses: actions/upload-artifact@v4
        with:
          name: build-${{ matrix.run.tag }}
          path:  ${{ inputs.output-directory }}/fpp
          retention-days: 5
          if-no-files-found: error
      - name: "Testing Native Images via Unit-Tests"
        run: |
          # Generate wrappers for tools
          tool_names=`cat ${{ inputs.working-directory }}/compiler/tools.txt`
          for tool in $tool_names
          do
              tool_wrapper="${{ inputs.output-directory }}/fpp-$tool"
              echo "Generating wrapper for fpp-$tool in $tool_wrapper"
              echo '#!/bin/sh
              "`dirname $0`/fpp" '$tool' "$@"' > $tool_wrapper
              chmod +x $tool_wrapper
          done
          cd ${{ inputs.working-directory }}
          ${{ inputs.test }}
  build-wheels:
    needs: [build-jars, build-native-images, generate-run-matricies]
    runs-on: ubuntu-22.04
    strategy:
      matrix: ${{ fromJson(needs.generate-run-matricies.outputs.tags) }}
    steps:
      - name: "Checkout repository"
        uses: actions/checkout@v3
        with:
          submodules: recursive
      - name: "Make Output Directory"
        run: mkdir -p ${{ inputs.output-directory }}
      - name: "Download Package"
        uses: actions/download-artifact@v4
        with:
          name: build-${{ matrix.tag }}
          path: ${{ inputs.output-directory }}
      - name: "Run Builder"
        run: |
          pip install build
          # Place the native files in the python package and determine platform options
          PLATFORM_OPTIONS=""
          if [[ "${{ matrix.tag }}" != "jar" ]]; then
            PLATFORM_OPTIONS="--config-setting=--build-option=--plat-name=${{ matrix.tag }}"
            cp -vr ${{ inputs.output-directory }}/fpp python/fprime_fpp/
          else
            cp -vr ${{ inputs.output-directory }}/*.jar python/fprime_fpp/
          fi
          # Github archiving clears executable flag, so put it back
          chmod +x python/fprime_fpp/fpp*
          python3 -m build --wheel --outdir packages/dist $PLATFORM_OPTIONS .
        shell: bash
      - name: "Archiving Wheels"
        uses: actions/upload-artifact@v4
        with:
          name: wheels-${{ matrix.tag }}
          path: packages/dist/*
          retention-days: 5
          if-no-files-found: error
  test-wheels:
    needs: [build-wheels, generate-run-matricies]
    strategy:
      matrix: ${{ fromJson(needs.generate-run-matricies.outputs.native) }}
    runs-on: ${{ matrix.run.runner }}
    steps:
      - name: "Setup Native Image Tools"
        uses: fprime-community/native-images-action@unified-tool
      - name: "Download Native Wheels"
        uses: actions/download-artifact@v4
        with:
          name: wheels-${{ matrix.run.tag }}
          path: ${{ inputs.output-directory }}/native
      - name: "Download JAR Wheels"
        uses: actions/download-artifact@v4
        with:
          name: wheels-jar
          path: ${{ inputs.output-directory }}/jars
      - name: "Test Packages"
        run: |
          for subdir in native jars
          do
              python3 -m venv ./test-${subdir}
              . ./test-${subdir}/bin/activate
              echo "[INFO] Testin ${subdir} Wheels"
              $NATIVE_IMAGE_TOOLS_PATH/test-wheels "${{ inputs.output-directory }}/${subdir}" "${{ inputs.meta-package }}" || exit $?
          done
        shell: bash
  publish-wheels:
    if: ${{ github.event_name == 'release' }}
    needs: [test-wheels, generate-run-matricies]
    runs-on: ubuntu-22.04
    strategy:
      matrix: ${{ fromJson(needs.generate-run-matricies.outputs.tags) }}
    steps:
      - name: "Download Package"
        uses: actions/download-artifact@v4
        with:
          name: wheels-${{ matrix.tag }}
          path: dist
      - name: "Install Builder"
        run: pip install twine
        shell: bash
      - name: Publish distributions to TestPyPI
        env:
          TWINE_PASSWORD: ${{ secrets.TESTPYPI_CREDENTIAL }}
        run: |
          twine upload -r testpypi -u "__token__" dist/*
        shell: bash
      - name: Publish distributions to PyPI
        env:
          TWINE_PASSWORD: ${{ secrets.PYPI_CREDENTIAL }}
        run: |
          twine upload -u "__token__" dist/*
        shell: bash