full_ci.yml

name: full CI

on:
  merge_group:
  pull_request:
    branches:
      - libc-0.2

jobs:
  docker_linux_tier1:
    permissions:
      contents: read # to fetch code (actions/checkout)

    name: Docker Linux Tier1
    runs-on: ubuntu-22.04
    strategy:
      fail-fast: true
      matrix:
        target: [
          i686-unknown-linux-gnu,
          x86_64-unknown-linux-gnu,
        ]
    steps:
      - uses: actions/checkout@v4
      - name: Setup Rust toolchain
        run: TARGET=${{ matrix.target }} sh ./ci/install-rust.sh
      - name: Execute run-docker.sh
        run: LIBC_CI=1 sh ./ci/run-docker.sh ${{ matrix.target }}

  macos:
    permissions:
      contents: read # to fetch code (actions/checkout)

    name: macOS
    runs-on: macos-13
    strategy:
      fail-fast: true
      matrix:
        target: [
          x86_64-apple-darwin,
        ]
    steps:
      - uses: actions/checkout@v4
      - name: Setup Rust toolchain
        run: TARGET=${{ matrix.target }} sh ./ci/install-rust.sh
      - name: Execute run.sh
        run: LIBC_CI=1 sh ./ci/run.sh ${{ matrix.target }}

  windows:
    permissions:
      contents: read # to fetch code (actions/checkout)

    name: Windows
    runs-on: windows-2022
    env:
      OS: windows
    strategy:
      fail-fast: true
      matrix:
        include:
          - target: x86_64-pc-windows-gnu
            env:
              ARCH_BITS: 64
              ARCH: x86_64
          - target: x86_64-pc-windows-msvc
          #- target: i686-pc-windows-gnu
          #  env:
          #    ARCH_BITS: 32
          #    ARCH: i686
          - target: i686-pc-windows-msvc
    steps:
      - uses: actions/checkout@v4
      - name: Self-update rustup
        run: rustup self update
        shell: bash
      - name: Setup Rust toolchain
        run: TARGET=${{ matrix.target }} sh ./ci/install-rust.sh
        shell: bash
      - name: Execute run.sh
        run: LIBC_CI=1 sh ./ci/run.sh ${{ matrix.target }}
        shell: bash

  style_check:
    permissions:
      contents: read # to fetch code (actions/checkout)

    name: Style check
    runs-on: ubuntu-22.04
    steps:
      - uses: actions/checkout@v4
      - name: Setup Rust toolchain
        run: sh ./ci/install-rust.sh
      - name: Check style
        run: sh ci/style.sh

  docker_linux_tier2:
    permissions:
      contents: read # to fetch code (actions/checkout)

    name: Docker Linux Tier2
    needs: [docker_linux_tier1, style_check]
    runs-on: ubuntu-22.04
    strategy:
      fail-fast: true
      max-parallel: 12
      matrix:
        target: [
          aarch64-linux-android,
          aarch64-unknown-linux-gnu,
          aarch64-unknown-linux-musl,
          arm-linux-androideabi,
          arm-unknown-linux-gnueabihf,
          arm-unknown-linux-musleabihf,
          i686-linux-android,
          i686-unknown-linux-musl,
          powerpc-unknown-linux-gnu,
          powerpc64-unknown-linux-gnu,
          powerpc64le-unknown-linux-gnu,
          s390x-unknown-linux-gnu,
          riscv64gc-unknown-linux-gnu,
          # FIXME: A recent nightly causes a linker failure:
          # https://github.com/rust-lang/rust/issues/76679
          # See this comment for more details:
          # https://github.com/rust-lang/libc/pull/2225#issuecomment-880696737
          #wasm32-wasi,
          sparc64-unknown-linux-gnu,
          wasm32-unknown-emscripten,
          x86_64-linux-android,
          # FIXME: Exec format error (os error 8)
          #x86_64-unknown-linux-gnux32,
          x86_64-unknown-linux-musl,
          # FIXME: It seems some items in `src/unix/mod.rs`
          # aren't defined on redox actually.
          # x86_64-unknown-redox,
        ]
    steps:
      - uses: actions/checkout@v4
      - name: Setup Rust toolchain
        run: TARGET=${{ matrix.target }} sh ./ci/install-rust.sh
      - name: Execute run-docker.sh
        run: LIBC_CI=1 sh ./ci/run-docker.sh ${{ matrix.target }}

  # These targets are tier 3 or otherwise need to have CI build std via -Zbuild-std.
  # Because of this, only the nightly compiler can be used on these targets.
  docker_linux_build_std:
    permissions:
      contents: read # to fetch code (actions/checkout)

    if: ${{ false }} # This is currently broken
    name: Docker Linux Build-Std Targets
    needs: [docker_linux_tier1, style_check]
    runs-on: ubuntu-22.04
    strategy:
      fail-fast: true
      max-parallel: 12
      matrix:
        target: [
          armv7-unknown-linux-uclibceabihf
        ]
    steps:
      - uses: actions/checkout@v4
      - name: Setup Rust toolchain
        run: TOOLCHAIN=nightly INSTALL_RUST_SRC=1 sh ./ci/install-rust.sh
      - name: Execute run-docker.sh
        run: LIBC_CI=1 TOOLCHAIN=nightly LIBC_CI_ZBUILD_STD=1 sh ./ci/run-docker.sh ${{ matrix.target }}

  # devkitpro's pacman needs to be connected from Docker.
  docker_switch:
    permissions:
      contents: read # to fetch code (actions/checkout)

    name: Docker Switch
    needs: [docker_linux_tier1, style_check]
    runs-on: ubuntu-22.04
    steps:
      - uses: actions/checkout@v4
      - name: Setup Rust toolchain
        run: sh ./ci/install-rust.sh
      - name: Execute run-docker.sh
        run: LIBC_CI=1 sh ./ci/run-docker.sh switch

  build_channels_linux:
    permissions:
      contents: read # to fetch code (actions/checkout)

    name: Build Channels Linux
    needs: docker_linux_tier2
    runs-on: ubuntu-22.04
    env:
      OS: linux
    strategy:
      fail-fast: true
      max-parallel: 5
      matrix:
        toolchain: [
          stable,
          beta,
          nightly,
          # FIXME: Disabled due to:
          # error: failed to parse registry's information for: serde
          #1.13.0,
          1.19.0,
          1.24.0,
          1.25.0,
          1.30.0,
        ]
    steps:
      - uses: actions/checkout@v4
      - name: Setup Rust toolchain
        run: TOOLCHAIN=${{ matrix.toolchain }} sh ./ci/install-rust.sh
      - name: Execute build.sh
        run: LIBC_CI=1 TOOLCHAIN=${{ matrix.toolchain }} sh ./ci/build.sh

  build_channels_macos:
    permissions:
      contents: read # to fetch code (actions/checkout)

    name: Build Channels macOS
    needs: macos
    env:
      OS: macos
    strategy:
      fail-fast: true
      max-parallel: 4
      matrix:
        target:
          - { toolchain: stable, os: macos-13 }
          - { toolchain: beta, os: macos-13 }
          - { toolchain: nightly, os: macos-13 }
    runs-on: ${{ matrix.target.os }}
    steps:
      - uses: actions/checkout@v4
      - name: Setup Rust toolchain
        run: TOOLCHAIN=${{ matrix.target.toolchain }} sh ./ci/install-rust.sh
      - name: Execute build.sh
        run: LIBC_CI=1 TOOLCHAIN=${{ matrix.target.toolchain }} sh ./ci/build.sh

  build_channels_windows:
    permissions:
      contents: read # to fetch code (actions/checkout)

    name: Build Channels Windows
    runs-on: windows-2022
    env:
      OS: windows
    strategy:
      fail-fast: true
      matrix:
        toolchain: [
          1.19.0,
          1.24.0,
          1.25.0,
          1.30.0,
          stable,
        ]
    steps:
      - uses: actions/checkout@v4
      - name: Self-update rustup
        run: rustup self update
        shell: bash
      - name: Execute build.sh
        run: LIBC_CI=1 TOOLCHAIN=${{ matrix.toolchain }} sh ./ci/build.sh
        shell: bash

  check_cfg:
    permissions:
      contents: read # to fetch code (actions/checkout)

    name: "Check #[cfg]s"
    runs-on: ubuntu-22.04
    steps:
      - uses: actions/checkout@v4
      - name: Setup Rust toolchain
        run: TOOLCHAIN=nightly sh ./ci/install-rust.sh
      - name: Build with check-cfg
        run: LIBC_CI=1 LIBC_CHECK_CFG=1 cargo build -Z unstable-options -Z check-cfg

  # One job that "summarizes" the success state of this pipeline. This can then be added to branch
  # protection, rather than having to add each job separately.
  success:
    name: success
    runs-on: ubuntu-22.04
    needs: [
      docker_linux_tier1,
      docker_linux_tier2,
      #docker_linux_build_std,
      macos,
      windows,
      style_check,
      docker_switch,
      build_channels_linux,
      build_channels_macos,
      build_channels_windows,
    ]
    # Github branch protection is exceedingly silly and treats "jobs skipped because a dependency
    # failed" as success. So we have to do some contortions to ensure the job fails if any of its
    # dependencies fails.
    if: always() # make sure this is never "skipped"
    steps:
      # Manually check the status of all dependencies. `if: failure()` does not work.
      - name: check if any dependency failed
        run: jq --exit-status 'all(.result == "success")' <<< '${{ toJson(needs) }}'