toolchain.yml

name: toolchain
run-name: "${{ inputs.run_name != '' && format('{0} ({1})', inputs.run_name, inputs.compiler) || format('{0} ({1})', github.workflow, inputs.compiler) }}"

on: 
  # schedule:
  #   - cron:  '0 12 * * *'
  workflow_dispatch:
    inputs:
      build_target:
        description: "Build target"
        required: false
        default: "all-64bit"
        type: choice
        options:
        - 32bit
        - 64bit
        - 64bit-v3
        - all-64bit
        - all
      compiler:
        required: false
        default: "clang"
        type: choice
        options:
        - gcc
        - clang
      no_save_cache:
        description: "Don't save caches after success build"
        required: false
        default: false
        type: boolean
      trigger_build:
        description: "Trigger mpv build action after success build"
        required: false
        default: true
        type: boolean
      release:
        description: "Publish a release"
        required: false
        default: false
        type: boolean
      run_name:
        description: 'The name displayed in the list of workflow runs'
        required: false

jobs:
  params:
    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.script.outputs.matrix }}
      cache_suffix: ${{ steps.suffix.outputs.cache_suffix }}
    steps:
      - id: script
        uses: actions/github-script@v7
        with:
          script: |
            let matrix = {};
            let build_target = "${{ inputs.build_target }}"
            switch ( build_target ) {
              case "32bit":
                matrix.bit = ["32"];
                break;
              case "64bit":
                matrix.bit = ["64"];
                break;
              case "64bit-v3":
                matrix.bit = ["64-v3"];
                break;
              case "all-64bit":
                matrix.bit = ["64","64-v3"];
                break;
              case "all":
                matrix.bit = ["32","64","64-v3"];
                break;
              default:
                matrix.bit = ["64","64-v3"];
                break;
            }
            core.setOutput("matrix",JSON.stringify(matrix));

      - id: suffix
        run: |
          cache_suffix="$(date "+%Y-%m-%d")-${{ github.run_id }}-${{ github.run_attempt }}"
          echo "cache_suffix=$cache_suffix" >> "$GITHUB_OUTPUT"

  build:
    name: Build Toolchain
    needs: [params]
    runs-on: ubuntu-latest
    container:
      image: archlinux/archlinux:base-devel
    continue-on-error: true
    strategy:
      matrix: ${{ fromJson(needs.params.outputs.matrix) }}

    steps:
      - name: Install Dependencies
        run: |
          sudo echo -e "[multilib]\nInclude = /etc/pacman.d/mirrorlist" >> /etc/pacman.conf
          sudo pacman -Syu --noconfirm
          sudo pacman -S --noconfirm --needed git ninja cmake meson wget mimalloc
          mkdir -p /home/opt/7zip
          wget -qO - https://www.7-zip.org/a/7z2301-linux-x64.tar.xz | tar -xJf - -C /home/opt/7zip 7zzs
          sudo ln -s /home/opt/7zip/7zzs /usr/bin/7z
          git config --global user.name "github-actions[bot]"
          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
          git config --global pull.rebase true
          git config --global rebase.autoStash true
          git config --global fetch.prune true
      - uses: actions/checkout@v4

      - name: Checkout toolchain
        uses: actions/checkout@v4
        with:
          repository: shinchiro/mpv-winbuild-cmake
          path: mpv-winbuild-cmake
          fetch-depth: 0

      - name: Restore llvm cache
        if: ${{ inputs.compiler =='clang' }}
        uses: actions/cache/restore@v4.0.2
        with: 
          fail-on-cache-miss: true
          path: |
            mpv-winbuild-cmake/clang_root
          key: llvm-${{ needs.params.outputs.cache_suffix }}
          restore-keys: |
            llvm-

      - name: Build GCC Toolchain
        uses: ./action/build_toolchain
        if: ${{ inputs.compiler =='gcc' }}
        with:
          bit: "${{ matrix.bit }}"
          compiler: "gcc"
          command: "ninja -C $buildroot/build$bit gcc"

      - name: Build Clang Toolchain
        uses: ./action/build_toolchain
        if: ${{ inputs.compiler =='clang' }}
        with:
          bit: "${{ matrix.bit }}"
          compiler: "clang"
          command: "ninja -C $buildroot/build$bit rebuild_cache && cmake --build $buildroot/build$bit --target llvm-download && ninja -C $buildroot/build$bit llvm-clang"

      - name: Save Toolchain Cache
        if: ${{ inputs.no_save_cache != true }}
        uses: actions/cache/save@v4.0.2
        with:
          path: ${{ github.workspace }}/mpv-winbuild-cmake/build${{ matrix.bit }}
          key: toolchain-${{ inputs.compiler }}-build${{ matrix.bit }}-${{ needs.params.outputs.cache_suffix }}

      - name: Save clang_root cache
        if: ${{ inputs.compiler =='clang' && inputs.no_save_cache != true }}
        uses: actions/cache/save@v4.0.2
        with: 
          path: ${{ github.workspace }}/mpv-winbuild-cmake/clang_root
          key: ${{ matrix.bit }}-clang_root-${{ needs.params.outputs.cache_suffix }}

      - name: Collect logs
        if: ${{ always() }}
        run: |
          sudo 7z a logs.7z $(find mpv-winbuild-cmake -type f -iname "*-*.log" -or -wholename "*/ffbuild/config.log")
      - name: upload logs
        uses: actions/upload-artifact@v4
        if: ${{ always() }}
        with:
          name: ${{ matrix.bit }}_logs
          path: logs.7z

  rust:
    name: Install Rust Toolchain
    needs: [params]
    runs-on: ubuntu-latest
    container:
      image: archlinux/archlinux:base-devel
    continue-on-error: true

    steps:
      - name: Install Dependencies
        run: |
          sudo pacman -Syu --noconfirm
          sudo pacman -S --noconfirm --needed git ninja cmake meson wget
          git config --global user.name "github-actions[bot]"
          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
          git config --global pull.rebase true
          git config --global rebase.autoStash true
          git config --global fetch.prune true
      - uses: actions/checkout@v4

      - name: Checkout toolchain
        uses: actions/checkout@v4
        with:
          repository: shinchiro/mpv-winbuild-cmake
          path: mpv-winbuild-cmake
          fetch-depth: 0

      - name: Install Rust Toolchain
        uses: ./action/build_toolchain
        with:
          bit: "64-v3"
          command: "ninja -C $buildroot/build$bit rustup && ninja -C $buildroot/build$bit cargo-clean"

      - name: Save Rust Cache
        if: ${{ inputs.no_save_cache != true }}
        uses: actions/cache/save@v4.0.2
        with:
          path: ${{ github.workspace }}/mpv-winbuild-cmake/install_rustup
          key: rust-${{ needs.params.outputs.cache_suffix }}

  trigger:
    needs: [build,params,rust]
    if: ${{ always() && inputs.trigger_build != false && !contains(needs.*.result, 'failure') && !contains(needs.*.result, 'cancelled') }}
    runs-on: ubuntu-latest
    permissions:
      actions: write

    steps:
      - name: Trigger mpv build workflow
        uses: actions/github-script@v7
        with:
          retries: 3
          script: |
            let build_target=new Set();
            const release = ${{ inputs.release }};
            const targets = {"build64-v3":"64bit-v3","build64":"64bit","build32":"32bit"}
            const repo="${{github.repository}}".split('/')[1];
            const cache_suffix="${{ needs.params.outputs.cache_suffix }}";
            const cache = await github.rest.actions.getActionsCacheList({
              owner: '${{github.repository_owner}}',
              repo,
              ref: '${{github.ref}}',
              key: 'toolchain-${{ inputs.compiler }}-',
              sort: 'created_at',
              per_page: 20,
            })
            if(cache?.data?.actions_caches){
              let success=cache.data.actions_caches.filter((i) => i.key.endsWith(cache_suffix));
              for(const i of success){
                for(const [key, value] of Object.entries(targets)){
                  if (i.key.includes(key)) {
                    build_target.add(value);
                    core.info(`Found success ${value} build cache: ${i.key}.`)
                    break;
                  }
                }
              }
            }
            if(build_target.size>0){
              if(build_target.has("64bit-v3") && build_target.has("64bit")) {
                build_target.delete("64bit-v3");
                build_target.delete("64bit");
                build_target.add("all-64bit");
              }
              if(build_target.has("all-64bit") && build_target.has("32bit")) {
                build_target.delete("all-64bit");
                build_target.delete("32bit");
                build_target.add("all");
              }
              for (const t of build_target){
                await github.rest.actions.createWorkflowDispatch({
                  owner: '${{github.repository_owner}}',
                  repo,
                  ref: '${{github.ref}}',
                  workflow_id: 'mpv.yml',
                  inputs: {
                    build_target: t,
                    compiler: "${{ inputs.compiler }}",
                    needclean: true,
                    release: release
                  }
                })
              }
            } else {
              core.setFailed("Don't find any success build cache");
            }