mirror of
https://github.com/openai/codex.git
synced 2026-05-16 01:02:48 +00:00
7f3f228a60
Add an opt-in rust-ci-full path that builds the Windows arm64 nextest archive on Windows x64, uploads it, and runs Windows arm64 shard jobs from that archive instead of recompiling in every shard. Co-authored-by: Codex <noreply@openai.com>
1250 lines
50 KiB
YAML
1250 lines
50 KiB
YAML
name: rust-ci-full
|
|
run-name: >-
|
|
rust-ci-full${{
|
|
github.event_name == 'workflow_dispatch' &&
|
|
format(
|
|
' windows-nextest-{0} arm64-shards-{1}{2}',
|
|
inputs.windows_nextest_threads || 'default',
|
|
inputs.windows_arm64_partitions || '1',
|
|
inputs.windows_arm64_archive == 'true' && ' arm64-archive' || ''
|
|
) ||
|
|
contains(github.ref_name, 'arm64-cross-archive') && ' arm64-cross-archive' ||
|
|
contains(github.ref_name, 'arm64-shards-4') && ' arm64-shards-4' ||
|
|
contains(github.ref_name, 'arm64-shards-2') && ' arm64-shards-2' ||
|
|
''
|
|
}}
|
|
on:
|
|
push:
|
|
branches:
|
|
- main
|
|
- "**full-ci**"
|
|
workflow_dispatch:
|
|
inputs:
|
|
windows_nextest_threads:
|
|
description: "Optional nextest --test-threads override for Windows test jobs"
|
|
required: false
|
|
type: string
|
|
windows_arm64_partitions:
|
|
description: "Number of Windows arm64 nextest partitions"
|
|
required: false
|
|
default: "1"
|
|
type: choice
|
|
options:
|
|
- "1"
|
|
- "2"
|
|
- "4"
|
|
windows_arm64_archive:
|
|
description: "Build Windows arm64 nextest archive on Windows x64, then run it on Windows arm64"
|
|
required: false
|
|
default: "false"
|
|
type: choice
|
|
options:
|
|
- "false"
|
|
- "true"
|
|
|
|
# CI builds in debug (dev) for faster signal.
|
|
|
|
jobs:
|
|
# --- CI that doesn't need specific targets ---------------------------------
|
|
general:
|
|
name: Format / etc
|
|
runs-on: ubuntu-24.04
|
|
defaults:
|
|
run:
|
|
working-directory: codex-rs
|
|
steps:
|
|
- uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
|
|
- uses: dtolnay/rust-toolchain@a0b273b48ed29de4470960879e8381ff45632f26 # 1.93.0
|
|
with:
|
|
components: rustfmt
|
|
- name: cargo fmt
|
|
run: cargo fmt -- --config imports_granularity=Item --check
|
|
|
|
cargo_shear:
|
|
name: cargo shear
|
|
runs-on: ubuntu-24.04
|
|
defaults:
|
|
run:
|
|
working-directory: codex-rs
|
|
steps:
|
|
- uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
|
|
- uses: dtolnay/rust-toolchain@a0b273b48ed29de4470960879e8381ff45632f26 # 1.93.0
|
|
- uses: taiki-e/install-action@44c6d64aa62cd779e873306675c7a58e86d6d532 # v2.62.49
|
|
with:
|
|
tool: cargo-shear
|
|
version: 1.11.2
|
|
- name: cargo shear
|
|
run: cargo shear
|
|
|
|
argument_comment_lint_package:
|
|
name: Argument comment lint package
|
|
runs-on: ubuntu-24.04
|
|
env:
|
|
CARGO_DYLINT_VERSION: 5.0.0
|
|
DYLINT_LINK_VERSION: 5.0.0
|
|
steps:
|
|
- uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
|
|
- uses: dtolnay/rust-toolchain@a0b273b48ed29de4470960879e8381ff45632f26 # 1.93.0
|
|
with:
|
|
toolchain: nightly-2025-09-18
|
|
components: llvm-tools-preview, rustc-dev, rust-src
|
|
- name: Cache cargo-dylint tooling
|
|
id: cargo_dylint_cache
|
|
uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
|
|
with:
|
|
path: |
|
|
~/.cargo/bin/cargo-dylint
|
|
~/.cargo/bin/dylint-link
|
|
~/.cargo/registry/index
|
|
~/.cargo/registry/cache
|
|
~/.cargo/git/db
|
|
key: argument-comment-lint-${{ runner.os }}-${{ env.CARGO_DYLINT_VERSION }}-${{ env.DYLINT_LINK_VERSION }}-${{ hashFiles('tools/argument-comment-lint/Cargo.lock', 'tools/argument-comment-lint/rust-toolchain', '.github/workflows/rust-ci.yml', '.github/workflows/rust-ci-full.yml') }}
|
|
- name: Install cargo-dylint tooling
|
|
if: ${{ steps.cargo_dylint_cache.outputs.cache-hit != 'true' }}
|
|
shell: bash
|
|
run: |
|
|
cargo install --locked cargo-dylint --version "$CARGO_DYLINT_VERSION"
|
|
cargo install --locked dylint-link --version "$DYLINT_LINK_VERSION"
|
|
- name: Check Python wrapper syntax
|
|
run: python3 -m py_compile tools/argument-comment-lint/wrapper_common.py tools/argument-comment-lint/run.py tools/argument-comment-lint/run-prebuilt-linter.py tools/argument-comment-lint/test_wrapper_common.py
|
|
- name: Test Python wrapper helpers
|
|
run: python3 -m unittest discover -s tools/argument-comment-lint -p 'test_*.py'
|
|
- name: Test argument comment lint package
|
|
working-directory: tools/argument-comment-lint
|
|
run: cargo test
|
|
env:
|
|
RUST_MIN_STACK: "8388608" # 8 MiB
|
|
|
|
argument_comment_lint_prebuilt:
|
|
name: Argument comment lint - ${{ matrix.name }}
|
|
runs-on: ${{ matrix.runs_on || matrix.runner }}
|
|
timeout-minutes: 30
|
|
strategy:
|
|
fail-fast: false
|
|
matrix:
|
|
include:
|
|
- name: Linux
|
|
runner: ubuntu-24.04
|
|
- name: macOS
|
|
runner: macos-15-xlarge
|
|
- name: Windows
|
|
runner: windows-x64
|
|
runs_on:
|
|
group: codex-runners
|
|
labels: codex-windows-x64
|
|
steps:
|
|
- uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
|
|
- uses: ./.github/actions/setup-bazel-ci
|
|
with:
|
|
target: ${{ runner.os }}
|
|
install-test-prereqs: true
|
|
- name: Install Linux sandbox build dependencies
|
|
if: ${{ runner.os == 'Linux' }}
|
|
shell: bash
|
|
run: |
|
|
sudo DEBIAN_FRONTEND=noninteractive apt-get update
|
|
sudo DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends pkg-config libcap-dev
|
|
- name: Run argument comment lint on codex-rs via Bazel
|
|
if: ${{ runner.os != 'Windows' }}
|
|
env:
|
|
BUILDBUDDY_API_KEY: ${{ secrets.BUILDBUDDY_API_KEY }}
|
|
shell: bash
|
|
run: |
|
|
bazel_targets="$(./tools/argument-comment-lint/list-bazel-targets.sh)"
|
|
./.github/scripts/run-bazel-ci.sh \
|
|
-- \
|
|
build \
|
|
--config=argument-comment-lint \
|
|
--keep_going \
|
|
--build_metadata=COMMIT_SHA=${GITHUB_SHA} \
|
|
-- \
|
|
${bazel_targets}
|
|
- name: Run argument comment lint on codex-rs via Bazel
|
|
if: ${{ runner.os == 'Windows' }}
|
|
env:
|
|
BUILDBUDDY_API_KEY: ${{ secrets.BUILDBUDDY_API_KEY }}
|
|
shell: bash
|
|
run: |
|
|
./.github/scripts/run-argument-comment-lint-bazel.sh \
|
|
--config=argument-comment-lint \
|
|
--platforms=//:local_windows \
|
|
--keep_going \
|
|
--build_metadata=COMMIT_SHA=${GITHUB_SHA}
|
|
|
|
# --- CI to validate on different os/targets --------------------------------
|
|
lint_build:
|
|
name: Lint/Build — ${{ matrix.runner }} - ${{ matrix.target }}${{ matrix.profile == 'release' && ' (release)' || '' }}
|
|
runs-on: ${{ matrix.runs_on || matrix.runner }}
|
|
timeout-minutes: 30
|
|
defaults:
|
|
run:
|
|
working-directory: codex-rs
|
|
env:
|
|
# Speed up repeated builds across CI runs by caching compiled objects, except on
|
|
# arm64 macOS runners cross-targeting x86_64 where ring/cc-rs can produce
|
|
# mixed-architecture archives under sccache.
|
|
USE_SCCACHE: ${{ (matrix.runner == 'macos-15-xlarge' && matrix.target == 'x86_64-apple-darwin') && 'false' || 'true' }}
|
|
CARGO_INCREMENTAL: "0"
|
|
SCCACHE_CACHE_SIZE: 10G
|
|
SCCACHE_IDLE_TIMEOUT: "0"
|
|
# In rust-ci, representative release-profile checks use thin LTO for faster feedback.
|
|
CARGO_PROFILE_RELEASE_LTO: ${{ matrix.profile == 'release' && 'thin' || 'fat' }}
|
|
|
|
strategy:
|
|
fail-fast: false
|
|
matrix:
|
|
include:
|
|
- runner: macos-15-xlarge
|
|
target: aarch64-apple-darwin
|
|
profile: dev
|
|
- runner: macos-15-xlarge
|
|
target: x86_64-apple-darwin
|
|
profile: dev
|
|
- runner: ubuntu-24.04
|
|
target: x86_64-unknown-linux-musl
|
|
profile: dev
|
|
runs_on:
|
|
group: codex-runners
|
|
labels: codex-linux-x64
|
|
- runner: ubuntu-24.04
|
|
target: x86_64-unknown-linux-gnu
|
|
profile: dev
|
|
runs_on:
|
|
group: codex-runners
|
|
labels: codex-linux-x64
|
|
- runner: ubuntu-24.04-arm
|
|
target: aarch64-unknown-linux-musl
|
|
profile: dev
|
|
runs_on:
|
|
group: codex-runners
|
|
labels: codex-linux-arm64
|
|
- runner: ubuntu-24.04-arm
|
|
target: aarch64-unknown-linux-gnu
|
|
profile: dev
|
|
runs_on:
|
|
group: codex-runners
|
|
labels: codex-linux-arm64
|
|
- runner: windows-x64
|
|
target: x86_64-pc-windows-msvc
|
|
profile: dev
|
|
runs_on:
|
|
group: codex-runners
|
|
labels: codex-windows-x64
|
|
- runner: windows-arm64
|
|
target: aarch64-pc-windows-msvc
|
|
profile: dev
|
|
runs_on:
|
|
group: codex-runners
|
|
labels: codex-windows-arm64
|
|
|
|
# Also run representative release builds on Mac and Linux because
|
|
# there could be release-only build errors we want to catch.
|
|
# Hopefully this also pre-populates the build cache to speed up
|
|
# releases.
|
|
- runner: macos-15-xlarge
|
|
target: aarch64-apple-darwin
|
|
profile: release
|
|
- runner: ubuntu-24.04
|
|
target: x86_64-unknown-linux-musl
|
|
profile: release
|
|
runs_on:
|
|
group: codex-runners
|
|
labels: codex-linux-x64
|
|
- runner: ubuntu-24.04-arm
|
|
target: aarch64-unknown-linux-musl
|
|
profile: release
|
|
runs_on:
|
|
group: codex-runners
|
|
labels: codex-linux-arm64
|
|
- runner: windows-x64
|
|
target: x86_64-pc-windows-msvc
|
|
profile: release
|
|
runs_on:
|
|
group: codex-runners
|
|
labels: codex-windows-x64
|
|
- runner: windows-arm64
|
|
target: aarch64-pc-windows-msvc
|
|
profile: release
|
|
runs_on:
|
|
group: codex-runners
|
|
labels: codex-windows-arm64
|
|
|
|
steps:
|
|
- uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
|
|
- name: Configure Dev Drive (Windows)
|
|
if: ${{ runner.os == 'Windows' }}
|
|
shell: pwsh
|
|
run: ../.github/scripts/setup-dev-drive.ps1
|
|
- name: Install Linux build dependencies
|
|
if: ${{ runner.os == 'Linux' }}
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
if command -v apt-get >/dev/null 2>&1; then
|
|
sudo apt-get update -y
|
|
packages=(pkg-config libcap-dev)
|
|
if [[ "${{ matrix.target }}" == 'x86_64-unknown-linux-musl' || "${{ matrix.target }}" == 'aarch64-unknown-linux-musl' ]]; then
|
|
packages+=(libubsan1)
|
|
fi
|
|
sudo DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends "${packages[@]}"
|
|
fi
|
|
- uses: dtolnay/rust-toolchain@a0b273b48ed29de4470960879e8381ff45632f26 # 1.93.0
|
|
with:
|
|
targets: ${{ matrix.target }}
|
|
components: clippy
|
|
|
|
- if: ${{ matrix.target == 'x86_64-unknown-linux-musl' || matrix.target == 'aarch64-unknown-linux-musl'}}
|
|
name: Use hermetic Cargo home (musl)
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
cargo_home="${GITHUB_WORKSPACE}/.cargo-home"
|
|
mkdir -p "${cargo_home}/bin"
|
|
echo "CARGO_HOME=${cargo_home}" >> "$GITHUB_ENV"
|
|
echo "${cargo_home}/bin" >> "$GITHUB_PATH"
|
|
: > "${cargo_home}/config.toml"
|
|
|
|
- name: Compute lockfile hash
|
|
id: lockhash
|
|
working-directory: codex-rs
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
echo "hash=$(sha256sum Cargo.lock | cut -d' ' -f1)" >> "$GITHUB_OUTPUT"
|
|
echo "toolchain_hash=$(sha256sum rust-toolchain.toml | cut -d' ' -f1)" >> "$GITHUB_OUTPUT"
|
|
|
|
# Explicit cache restore: split cargo home vs target, so we can
|
|
# avoid caching the large target dir on the gnu-dev job.
|
|
- name: Restore cargo home cache
|
|
id: cache_cargo_home_restore
|
|
uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
|
|
with:
|
|
path: |
|
|
~/.cargo/bin/
|
|
~/.cargo/registry/index/
|
|
~/.cargo/registry/cache/
|
|
~/.cargo/git/db/
|
|
${{ github.workspace }}/.cargo-home/bin/
|
|
${{ github.workspace }}/.cargo-home/registry/index/
|
|
${{ github.workspace }}/.cargo-home/registry/cache/
|
|
${{ github.workspace }}/.cargo-home/git/db/
|
|
key: cargo-home-${{ matrix.runner }}-${{ matrix.target }}-${{ matrix.profile }}-${{ steps.lockhash.outputs.hash }}-${{ steps.lockhash.outputs.toolchain_hash }}
|
|
restore-keys: |
|
|
cargo-home-${{ matrix.runner }}-${{ matrix.target }}-${{ matrix.profile }}-
|
|
|
|
# Install and restore sccache cache
|
|
- name: Install sccache
|
|
if: ${{ env.USE_SCCACHE == 'true' }}
|
|
uses: taiki-e/install-action@cca35edeb1d01366c2843b68fc3ca441446d73d3 # v2.77.1
|
|
with:
|
|
tool: sccache@0.14.0
|
|
fallback: none
|
|
|
|
- name: Configure sccache backend
|
|
if: ${{ env.USE_SCCACHE == 'true' }}
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
if [[ -n "${ACTIONS_CACHE_URL:-}" && -n "${ACTIONS_RUNTIME_TOKEN:-}" ]]; then
|
|
echo "SCCACHE_GHA_ENABLED=true" >> "$GITHUB_ENV"
|
|
echo "Using sccache GitHub backend"
|
|
else
|
|
echo "SCCACHE_GHA_ENABLED=false" >> "$GITHUB_ENV"
|
|
if [[ -n "${DEV_DRIVE:-}" ]]; then
|
|
echo "SCCACHE_DIR=${DEV_DRIVE}\\.sccache" >> "$GITHUB_ENV"
|
|
else
|
|
echo "SCCACHE_DIR=${{ github.workspace }}/.sccache" >> "$GITHUB_ENV"
|
|
fi
|
|
echo "Using sccache local disk + actions/cache fallback"
|
|
fi
|
|
|
|
- name: Enable sccache wrapper
|
|
if: ${{ env.USE_SCCACHE == 'true' }}
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
wrapper="$(command -v sccache)"
|
|
if [[ "${RUNNER_OS}" == "Windows" ]] && command -v cygpath >/dev/null 2>&1; then
|
|
wrapper="$(cygpath -w "${wrapper}")"
|
|
fi
|
|
echo "RUSTC_WRAPPER=${wrapper}" >> "$GITHUB_ENV"
|
|
echo "CARGO_BUILD_RUSTC_WRAPPER=${wrapper}" >> "$GITHUB_ENV"
|
|
|
|
- name: Restore sccache cache (fallback)
|
|
if: ${{ env.USE_SCCACHE == 'true' && env.SCCACHE_GHA_ENABLED != 'true' }}
|
|
id: cache_sccache_restore
|
|
uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
|
|
with:
|
|
path: ${{ env.SCCACHE_DIR }}
|
|
key: sccache-${{ matrix.runner }}-${{ matrix.target }}-${{ matrix.profile }}-${{ steps.lockhash.outputs.hash }}-${{ github.run_id }}
|
|
restore-keys: |
|
|
sccache-${{ matrix.runner }}-${{ matrix.target }}-${{ matrix.profile }}-${{ steps.lockhash.outputs.hash }}-
|
|
sccache-${{ matrix.runner }}-${{ matrix.target }}-${{ matrix.profile }}-
|
|
|
|
- name: Start sccache server (Windows)
|
|
if: ${{ env.USE_SCCACHE == 'true' && runner.os == 'Windows' }}
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
sccache --start-server
|
|
sccache --show-stats
|
|
|
|
- if: ${{ matrix.target == 'x86_64-unknown-linux-musl' || matrix.target == 'aarch64-unknown-linux-musl'}}
|
|
name: Disable sccache wrapper (musl)
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
echo "RUSTC_WRAPPER=" >> "$GITHUB_ENV"
|
|
echo "CARGO_BUILD_RUSTC_WRAPPER=" >> "$GITHUB_ENV"
|
|
echo "RUSTC_WORKSPACE_WRAPPER=" >> "$GITHUB_ENV"
|
|
|
|
- if: ${{ matrix.target == 'x86_64-unknown-linux-musl' || matrix.target == 'aarch64-unknown-linux-musl'}}
|
|
name: Prepare APT cache directories (musl)
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
sudo mkdir -p /var/cache/apt/archives /var/lib/apt/lists
|
|
sudo chown -R "$USER:$USER" /var/cache/apt /var/lib/apt/lists
|
|
|
|
- if: ${{ matrix.target == 'x86_64-unknown-linux-musl' || matrix.target == 'aarch64-unknown-linux-musl'}}
|
|
name: Restore APT cache (musl)
|
|
id: cache_apt_restore
|
|
uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
|
|
with:
|
|
path: |
|
|
/var/cache/apt
|
|
key: apt-${{ matrix.runner }}-${{ matrix.target }}-v1
|
|
|
|
- if: ${{ matrix.target == 'x86_64-unknown-linux-musl' || matrix.target == 'aarch64-unknown-linux-musl'}}
|
|
name: Install Zig
|
|
uses: mlugg/setup-zig@d1434d08867e3ee9daa34448df10607b98908d29 # v2.2.1
|
|
with:
|
|
version: 0.14.0
|
|
|
|
- if: ${{ matrix.target == 'x86_64-unknown-linux-musl' || matrix.target == 'aarch64-unknown-linux-musl'}}
|
|
name: Install musl build tools
|
|
env:
|
|
DEBIAN_FRONTEND: noninteractive
|
|
TARGET: ${{ matrix.target }}
|
|
APT_UPDATE_ARGS: -o Acquire::Retries=3
|
|
APT_INSTALL_ARGS: --no-install-recommends
|
|
shell: bash
|
|
run: bash "${GITHUB_WORKSPACE}/.github/scripts/install-musl-build-tools.sh"
|
|
|
|
- if: ${{ matrix.target == 'x86_64-unknown-linux-musl' || matrix.target == 'aarch64-unknown-linux-musl'}}
|
|
name: Configure rustc UBSan wrapper (musl host)
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
ubsan=""
|
|
if command -v ldconfig >/dev/null 2>&1; then
|
|
ubsan="$(ldconfig -p | grep -m1 'libubsan\.so\.1' | sed -E 's/.*=> (.*)$/\1/')"
|
|
fi
|
|
wrapper_root="${RUNNER_TEMP:-/tmp}"
|
|
wrapper="${wrapper_root}/rustc-ubsan-wrapper"
|
|
cat > "${wrapper}" <<EOF
|
|
#!/usr/bin/env bash
|
|
set -euo pipefail
|
|
if [[ -n "${ubsan}" ]]; then
|
|
export LD_PRELOAD="${ubsan}\${LD_PRELOAD:+:\${LD_PRELOAD}}"
|
|
fi
|
|
exec "\$1" "\${@:2}"
|
|
EOF
|
|
chmod +x "${wrapper}"
|
|
echo "RUSTC_WRAPPER=${wrapper}" >> "$GITHUB_ENV"
|
|
echo "RUSTC_WORKSPACE_WRAPPER=" >> "$GITHUB_ENV"
|
|
|
|
- if: ${{ matrix.target == 'x86_64-unknown-linux-musl' || matrix.target == 'aarch64-unknown-linux-musl'}}
|
|
name: Clear sanitizer flags (musl)
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
# Clear global Rust flags so host/proc-macro builds don't pull in UBSan.
|
|
echo "RUSTFLAGS=" >> "$GITHUB_ENV"
|
|
echo "CARGO_ENCODED_RUSTFLAGS=" >> "$GITHUB_ENV"
|
|
echo "RUSTDOCFLAGS=" >> "$GITHUB_ENV"
|
|
# Override any runner-level Cargo config rustflags as well.
|
|
echo "CARGO_BUILD_RUSTFLAGS=" >> "$GITHUB_ENV"
|
|
echo "CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUSTFLAGS=" >> "$GITHUB_ENV"
|
|
echo "CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_RUSTFLAGS=" >> "$GITHUB_ENV"
|
|
echo "CARGO_TARGET_X86_64_UNKNOWN_LINUX_MUSL_RUSTFLAGS=" >> "$GITHUB_ENV"
|
|
echo "CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_RUSTFLAGS=" >> "$GITHUB_ENV"
|
|
|
|
sanitize_flags() {
|
|
local input="$1"
|
|
input="${input//-fsanitize=undefined/}"
|
|
input="${input//-fno-sanitize-recover=undefined/}"
|
|
input="${input//-fno-sanitize-trap=undefined/}"
|
|
echo "$input"
|
|
}
|
|
|
|
cflags="$(sanitize_flags "${CFLAGS-}")"
|
|
cxxflags="$(sanitize_flags "${CXXFLAGS-}")"
|
|
echo "CFLAGS=${cflags}" >> "$GITHUB_ENV"
|
|
echo "CXXFLAGS=${cxxflags}" >> "$GITHUB_ENV"
|
|
|
|
- if: ${{ matrix.target == 'x86_64-unknown-linux-musl' || matrix.target == 'aarch64-unknown-linux-musl' }}
|
|
name: Configure musl rusty_v8 artifact overrides and verify checksums
|
|
uses: ./.github/actions/setup-rusty-v8-musl
|
|
with:
|
|
target: ${{ matrix.target }}
|
|
|
|
- name: Install cargo-chef
|
|
if: ${{ matrix.profile == 'release' }}
|
|
uses: taiki-e/install-action@44c6d64aa62cd779e873306675c7a58e86d6d532 # v2.62.49
|
|
with:
|
|
tool: cargo-chef
|
|
version: 0.1.71
|
|
|
|
- name: Pre-warm dependency cache (cargo-chef)
|
|
if: ${{ matrix.profile == 'release' }}
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
RECIPE="${RUNNER_TEMP}/chef-recipe.json"
|
|
cargo chef prepare --recipe-path "$RECIPE"
|
|
cargo chef cook --recipe-path "$RECIPE" --target ${{ matrix.target }} --release
|
|
|
|
- name: cargo clippy
|
|
run: cargo clippy --target ${{ matrix.target }} --tests --profile ${{ matrix.profile }} --timings -- -D warnings
|
|
|
|
- name: Upload Cargo timings (clippy)
|
|
if: always()
|
|
uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
|
|
with:
|
|
name: cargo-timings-rust-ci-clippy-${{ matrix.target }}-${{ matrix.profile }}
|
|
path: codex-rs/target/**/cargo-timings/cargo-timing.html
|
|
if-no-files-found: warn
|
|
|
|
# Save caches explicitly; make non-fatal so cache packaging
|
|
# never fails the overall job. Only save when key wasn't hit.
|
|
- name: Save cargo home cache
|
|
if: always() && !cancelled() && steps.cache_cargo_home_restore.outputs.cache-hit != 'true'
|
|
continue-on-error: true
|
|
uses: actions/cache/save@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
|
|
with:
|
|
path: |
|
|
~/.cargo/bin/
|
|
~/.cargo/registry/index/
|
|
~/.cargo/registry/cache/
|
|
~/.cargo/git/db/
|
|
${{ github.workspace }}/.cargo-home/bin/
|
|
${{ github.workspace }}/.cargo-home/registry/index/
|
|
${{ github.workspace }}/.cargo-home/registry/cache/
|
|
${{ github.workspace }}/.cargo-home/git/db/
|
|
key: cargo-home-${{ matrix.runner }}-${{ matrix.target }}-${{ matrix.profile }}-${{ steps.lockhash.outputs.hash }}-${{ steps.lockhash.outputs.toolchain_hash }}
|
|
|
|
- name: Save sccache cache (fallback)
|
|
if: always() && !cancelled() && env.USE_SCCACHE == 'true' && env.SCCACHE_GHA_ENABLED != 'true'
|
|
continue-on-error: true
|
|
uses: actions/cache/save@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
|
|
with:
|
|
path: ${{ env.SCCACHE_DIR }}
|
|
key: sccache-${{ matrix.runner }}-${{ matrix.target }}-${{ matrix.profile }}-${{ steps.lockhash.outputs.hash }}-${{ github.run_id }}
|
|
|
|
- name: sccache stats
|
|
if: always() && env.USE_SCCACHE == 'true'
|
|
continue-on-error: true
|
|
run: sccache --show-stats || true
|
|
|
|
- name: sccache summary
|
|
if: always() && env.USE_SCCACHE == 'true'
|
|
shell: bash
|
|
run: |
|
|
{
|
|
echo "### sccache stats — ${{ matrix.target }} (${{ matrix.profile }})";
|
|
echo;
|
|
echo '```';
|
|
sccache --show-stats || true;
|
|
echo '```';
|
|
} >> "$GITHUB_STEP_SUMMARY"
|
|
|
|
- name: Save APT cache (musl)
|
|
if: always() && !cancelled() && (matrix.target == 'x86_64-unknown-linux-musl' || matrix.target == 'aarch64-unknown-linux-musl') && steps.cache_apt_restore.outputs.cache-hit != 'true'
|
|
continue-on-error: true
|
|
uses: actions/cache/save@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
|
|
with:
|
|
path: |
|
|
/var/cache/apt
|
|
key: apt-${{ matrix.runner }}-${{ matrix.target }}-v1
|
|
|
|
test_matrix:
|
|
name: Select test matrix
|
|
runs-on: ubuntu-24.04
|
|
outputs:
|
|
matrix: ${{ steps.matrix.outputs.matrix }}
|
|
windows_arm64_archive_matrix: ${{ steps.matrix.outputs.windows_arm64_archive_matrix }}
|
|
windows_arm64_archive: ${{ steps.matrix.outputs.windows_arm64_archive }}
|
|
env:
|
|
WINDOWS_ARM64_PARTITIONS: >-
|
|
${{
|
|
github.event_name == 'workflow_dispatch' && inputs.windows_arm64_partitions ||
|
|
contains(github.ref_name, 'arm64-shards-4') && '4' ||
|
|
contains(github.ref_name, 'arm64-shards-2') && '2' ||
|
|
'1'
|
|
}}
|
|
WINDOWS_ARM64_ARCHIVE: >-
|
|
${{
|
|
github.event_name == 'workflow_dispatch' && inputs.windows_arm64_archive ||
|
|
contains(github.ref_name, 'arm64-cross-archive') && 'true' ||
|
|
'false'
|
|
}}
|
|
steps:
|
|
- name: Build test matrix
|
|
id: matrix
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
case "${WINDOWS_ARM64_PARTITIONS}" in
|
|
1|2|4) ;;
|
|
*)
|
|
echo "Unsupported WINDOWS_ARM64_PARTITIONS=${WINDOWS_ARM64_PARTITIONS}" >&2
|
|
exit 1
|
|
;;
|
|
esac
|
|
case "${WINDOWS_ARM64_ARCHIVE}" in
|
|
true|false) ;;
|
|
*)
|
|
echo "Unsupported WINDOWS_ARM64_ARCHIVE=${WINDOWS_ARM64_ARCHIVE}" >&2
|
|
exit 1
|
|
;;
|
|
esac
|
|
|
|
python3 - <<'PY' >> "$GITHUB_OUTPUT"
|
|
import json
|
|
import os
|
|
|
|
windows_arm64_partitions = int(os.environ["WINDOWS_ARM64_PARTITIONS"])
|
|
windows_arm64_archive = os.environ["WINDOWS_ARM64_ARCHIVE"] == "true"
|
|
|
|
def row(runner, target, profile, *, timeout_minutes=None, remote_env=None, runs_on=None, partition_index=None):
|
|
partition_suffix = ""
|
|
partition_name = ""
|
|
nextest_partition = ""
|
|
if partition_index is not None and windows_arm64_partitions > 1:
|
|
partition_suffix = f"-part-{partition_index}-of-{windows_arm64_partitions}"
|
|
partition_name = f" (part {partition_index}/{windows_arm64_partitions})"
|
|
nextest_partition = f"hash:{partition_index}/{windows_arm64_partitions}"
|
|
|
|
entry = {
|
|
"runner": runner,
|
|
"target": target,
|
|
"profile": profile,
|
|
"partition_suffix": partition_suffix,
|
|
"partition_name": partition_name,
|
|
"nextest_partition": nextest_partition,
|
|
}
|
|
if timeout_minutes is not None:
|
|
entry["timeout_minutes"] = timeout_minutes
|
|
if remote_env is not None:
|
|
entry["remote_env"] = remote_env
|
|
if runs_on is not None:
|
|
entry["runs_on"] = runs_on
|
|
return entry
|
|
|
|
codex_runners = {
|
|
"linux-x64": {"group": "codex-runners", "labels": "codex-linux-x64"},
|
|
"linux-arm64": {"group": "codex-runners", "labels": "codex-linux-arm64"},
|
|
"windows-x64": {"group": "codex-runners", "labels": "codex-windows-x64"},
|
|
"windows-arm64": {"group": "codex-runners", "labels": "codex-windows-arm64"},
|
|
}
|
|
|
|
include = [
|
|
row("macos-15-xlarge", "aarch64-apple-darwin", "dev"),
|
|
row(
|
|
"ubuntu-24.04",
|
|
"x86_64-unknown-linux-gnu",
|
|
"dev",
|
|
remote_env="true",
|
|
runs_on=codex_runners["linux-x64"],
|
|
),
|
|
row(
|
|
"ubuntu-24.04-arm",
|
|
"aarch64-unknown-linux-gnu",
|
|
"dev",
|
|
runs_on=codex_runners["linux-arm64"],
|
|
),
|
|
row(
|
|
"windows-x64",
|
|
"x86_64-pc-windows-msvc",
|
|
"dev",
|
|
runs_on=codex_runners["windows-x64"],
|
|
),
|
|
]
|
|
|
|
windows_arm64_rows = []
|
|
for partition_index in range(1, windows_arm64_partitions + 1):
|
|
windows_arm64_rows.append(
|
|
row(
|
|
"windows-arm64",
|
|
"aarch64-pc-windows-msvc",
|
|
"dev",
|
|
timeout_minutes=75,
|
|
runs_on=codex_runners["windows-arm64"],
|
|
partition_index=partition_index,
|
|
)
|
|
)
|
|
|
|
if not windows_arm64_archive:
|
|
include.extend(windows_arm64_rows)
|
|
|
|
print("matrix<<JSON")
|
|
print(json.dumps({"include": include}, separators=(",", ":")))
|
|
print("JSON")
|
|
print("windows_arm64_archive_matrix<<JSON")
|
|
print(json.dumps({"include": windows_arm64_rows}, separators=(",", ":")))
|
|
print("JSON")
|
|
print(f"windows_arm64_archive={'true' if windows_arm64_archive else 'false'}")
|
|
PY
|
|
|
|
windows_arm64_test_archive:
|
|
name: Build Windows arm64 nextest archive
|
|
needs: test_matrix
|
|
if: ${{ needs.test_matrix.outputs.windows_arm64_archive == 'true' }}
|
|
runs-on:
|
|
group: codex-runners
|
|
labels: codex-windows-x64
|
|
timeout-minutes: 45
|
|
defaults:
|
|
run:
|
|
working-directory: codex-rs
|
|
env:
|
|
USE_SCCACHE: "true"
|
|
CARGO_INCREMENTAL: "0"
|
|
SCCACHE_CACHE_SIZE: 10G
|
|
SCCACHE_IDLE_TIMEOUT: "0"
|
|
WINDOWS_ARM64_ARCHIVE_FILE: windows-arm64-nextest-archive.tar.zst
|
|
steps:
|
|
- uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
|
|
- name: Configure Dev Drive (Windows)
|
|
shell: pwsh
|
|
run: ../.github/scripts/setup-dev-drive.ps1
|
|
|
|
# Some integration tests rely on DotSlash being installed.
|
|
# See https://github.com/openai/codex/pull/7617.
|
|
- name: Install DotSlash
|
|
uses: facebook/install-dotslash@1e4e7b3e07eaca387acb98f1d4720e0bee8dbb6a # v2
|
|
|
|
- uses: dtolnay/rust-toolchain@a0b273b48ed29de4470960879e8381ff45632f26 # 1.93.0
|
|
with:
|
|
targets: aarch64-pc-windows-msvc
|
|
|
|
- name: Compute lockfile hash
|
|
id: lockhash
|
|
working-directory: codex-rs
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
echo "hash=$(sha256sum Cargo.lock | cut -d' ' -f1)" >> "$GITHUB_OUTPUT"
|
|
echo "toolchain_hash=$(sha256sum rust-toolchain.toml | cut -d' ' -f1)" >> "$GITHUB_OUTPUT"
|
|
|
|
- name: Restore cargo home cache
|
|
id: cache_cargo_home_restore
|
|
uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
|
|
with:
|
|
path: |
|
|
~/.cargo/bin/
|
|
~/.cargo/registry/index/
|
|
~/.cargo/registry/cache/
|
|
~/.cargo/git/db/
|
|
key: cargo-home-windows-x64-aarch64-pc-windows-msvc-dev-${{ steps.lockhash.outputs.hash }}-${{ steps.lockhash.outputs.toolchain_hash }}
|
|
restore-keys: |
|
|
cargo-home-windows-x64-aarch64-pc-windows-msvc-dev-
|
|
|
|
- name: Install sccache
|
|
if: ${{ env.USE_SCCACHE == 'true' }}
|
|
uses: taiki-e/install-action@cca35edeb1d01366c2843b68fc3ca441446d73d3 # v2.77.1
|
|
with:
|
|
tool: sccache@0.14.0
|
|
fallback: none
|
|
|
|
- name: Configure sccache backend
|
|
if: ${{ env.USE_SCCACHE == 'true' }}
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
if [[ -n "${ACTIONS_CACHE_URL:-}" && -n "${ACTIONS_RUNTIME_TOKEN:-}" ]]; then
|
|
echo "SCCACHE_GHA_ENABLED=true" >> "$GITHUB_ENV"
|
|
echo "Using sccache GitHub backend"
|
|
else
|
|
echo "SCCACHE_GHA_ENABLED=false" >> "$GITHUB_ENV"
|
|
if [[ -n "${DEV_DRIVE:-}" ]]; then
|
|
echo "SCCACHE_DIR=${DEV_DRIVE}\\.sccache" >> "$GITHUB_ENV"
|
|
else
|
|
echo "SCCACHE_DIR=${{ github.workspace }}/.sccache" >> "$GITHUB_ENV"
|
|
fi
|
|
echo "Using sccache local disk + actions/cache fallback"
|
|
fi
|
|
|
|
- name: Enable sccache wrapper
|
|
if: ${{ env.USE_SCCACHE == 'true' }}
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
wrapper="$(command -v sccache)"
|
|
if [[ "${RUNNER_OS}" == "Windows" ]] && command -v cygpath >/dev/null 2>&1; then
|
|
wrapper="$(cygpath -w "${wrapper}")"
|
|
fi
|
|
echo "RUSTC_WRAPPER=${wrapper}" >> "$GITHUB_ENV"
|
|
echo "CARGO_BUILD_RUSTC_WRAPPER=${wrapper}" >> "$GITHUB_ENV"
|
|
|
|
- name: Restore sccache cache (fallback)
|
|
if: ${{ env.USE_SCCACHE == 'true' && env.SCCACHE_GHA_ENABLED != 'true' }}
|
|
id: cache_sccache_restore
|
|
uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
|
|
with:
|
|
path: ${{ env.SCCACHE_DIR }}
|
|
key: sccache-windows-x64-aarch64-pc-windows-msvc-dev-archive-${{ steps.lockhash.outputs.hash }}-${{ github.run_id }}
|
|
restore-keys: |
|
|
sccache-windows-x64-aarch64-pc-windows-msvc-dev-archive-${{ steps.lockhash.outputs.hash }}-
|
|
sccache-windows-x64-aarch64-pc-windows-msvc-dev-${{ steps.lockhash.outputs.hash }}-
|
|
sccache-windows-x64-aarch64-pc-windows-msvc-dev-
|
|
|
|
- name: Start sccache server
|
|
if: ${{ env.USE_SCCACHE == 'true' }}
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
sccache --start-server
|
|
sccache --show-stats
|
|
|
|
- uses: taiki-e/install-action@44c6d64aa62cd779e873306675c7a58e86d6d532 # v2.62.49
|
|
with:
|
|
tool: nextest@0.9.103
|
|
|
|
- name: Build nextest archive
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
archive_dir="${RUNNER_TEMP}/nextest-archive"
|
|
mkdir -p "${archive_dir}"
|
|
cargo nextest archive \
|
|
--target aarch64-pc-windows-msvc \
|
|
--cargo-profile ci-test \
|
|
--timings \
|
|
--archive-file "${archive_dir}/${WINDOWS_ARM64_ARCHIVE_FILE}"
|
|
|
|
- name: Upload nextest archive
|
|
uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
|
|
with:
|
|
name: windows-arm64-nextest-archive
|
|
path: ${{ runner.temp }}/nextest-archive/${{ env.WINDOWS_ARM64_ARCHIVE_FILE }}
|
|
if-no-files-found: error
|
|
retention-days: 1
|
|
|
|
- name: Upload Cargo timings (nextest archive)
|
|
if: always()
|
|
uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
|
|
with:
|
|
name: cargo-timings-rust-ci-nextest-aarch64-pc-windows-msvc-dev-archive
|
|
path: codex-rs/target/**/cargo-timings/cargo-timing.html
|
|
if-no-files-found: warn
|
|
|
|
- name: Save cargo home cache
|
|
if: always() && !cancelled() && steps.cache_cargo_home_restore.outputs.cache-hit != 'true'
|
|
continue-on-error: true
|
|
uses: actions/cache/save@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
|
|
with:
|
|
path: |
|
|
~/.cargo/bin/
|
|
~/.cargo/registry/index/
|
|
~/.cargo/registry/cache/
|
|
~/.cargo/git/db/
|
|
key: cargo-home-windows-x64-aarch64-pc-windows-msvc-dev-${{ steps.lockhash.outputs.hash }}-${{ steps.lockhash.outputs.toolchain_hash }}
|
|
|
|
- name: Save sccache cache (fallback)
|
|
if: always() && !cancelled() && env.USE_SCCACHE == 'true' && env.SCCACHE_GHA_ENABLED != 'true'
|
|
continue-on-error: true
|
|
uses: actions/cache/save@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
|
|
with:
|
|
path: ${{ env.SCCACHE_DIR }}
|
|
key: sccache-windows-x64-aarch64-pc-windows-msvc-dev-archive-${{ steps.lockhash.outputs.hash }}-${{ github.run_id }}
|
|
|
|
- name: sccache stats
|
|
if: always() && env.USE_SCCACHE == 'true'
|
|
continue-on-error: true
|
|
run: sccache --show-stats || true
|
|
|
|
- name: sccache summary
|
|
if: always() && env.USE_SCCACHE == 'true'
|
|
shell: bash
|
|
run: |
|
|
{
|
|
echo "### sccache stats — aarch64-pc-windows-msvc (archive)";
|
|
echo;
|
|
echo '```';
|
|
sccache --show-stats || true;
|
|
echo '```';
|
|
} >> "$GITHUB_STEP_SUMMARY"
|
|
|
|
tests:
|
|
name: Tests — ${{ matrix.runner }} - ${{ matrix.target }}${{ matrix.remote_env == 'true' && ' (remote)' || '' }}${{ matrix.partition_name }}
|
|
needs: test_matrix
|
|
runs-on: ${{ matrix.runs_on || matrix.runner }}
|
|
# Perhaps we can bring this back down once we finish the cutover from
|
|
# tui_app_server/ to tui/. Incidentally, windows-arm64 was the main offender
|
|
# for exceeding the timeout.
|
|
timeout-minutes: ${{ matrix.timeout_minutes || 45 }}
|
|
defaults:
|
|
run:
|
|
working-directory: codex-rs
|
|
env:
|
|
# Speed up repeated builds across CI runs by caching compiled objects, except on
|
|
# arm64 macOS runners cross-targeting x86_64 where ring/cc-rs can produce
|
|
# mixed-architecture archives under sccache.
|
|
USE_SCCACHE: ${{ (matrix.runner == 'macos-15-xlarge' && matrix.target == 'x86_64-apple-darwin') && 'false' || 'true' }}
|
|
CARGO_INCREMENTAL: "0"
|
|
SCCACHE_CACHE_SIZE: 10G
|
|
SCCACHE_IDLE_TIMEOUT: "0"
|
|
WINDOWS_NEXTEST_THREADS: ${{ github.event_name == 'workflow_dispatch' && inputs.windows_nextest_threads || '' }}
|
|
|
|
strategy:
|
|
fail-fast: false
|
|
matrix: ${{ fromJSON(needs.test_matrix.outputs.matrix) }}
|
|
|
|
steps:
|
|
- uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
|
|
- name: Configure Dev Drive (Windows)
|
|
if: ${{ runner.os == 'Windows' }}
|
|
shell: pwsh
|
|
run: ../.github/scripts/setup-dev-drive.ps1
|
|
- name: Install Linux build dependencies
|
|
if: ${{ runner.os == 'Linux' }}
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
if command -v apt-get >/dev/null 2>&1; then
|
|
sudo apt-get update -y
|
|
sudo DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends pkg-config libcap-dev
|
|
fi
|
|
|
|
# Some integration tests rely on DotSlash being installed.
|
|
# See https://github.com/openai/codex/pull/7617.
|
|
- name: Install DotSlash
|
|
uses: facebook/install-dotslash@1e4e7b3e07eaca387acb98f1d4720e0bee8dbb6a # v2
|
|
|
|
- uses: dtolnay/rust-toolchain@a0b273b48ed29de4470960879e8381ff45632f26 # 1.93.0
|
|
with:
|
|
targets: ${{ matrix.target }}
|
|
|
|
- name: Compute lockfile hash
|
|
id: lockhash
|
|
working-directory: codex-rs
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
echo "hash=$(sha256sum Cargo.lock | cut -d' ' -f1)" >> "$GITHUB_OUTPUT"
|
|
echo "toolchain_hash=$(sha256sum rust-toolchain.toml | cut -d' ' -f1)" >> "$GITHUB_OUTPUT"
|
|
|
|
- name: Restore cargo home cache
|
|
id: cache_cargo_home_restore
|
|
uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
|
|
with:
|
|
path: |
|
|
~/.cargo/bin/
|
|
~/.cargo/registry/index/
|
|
~/.cargo/registry/cache/
|
|
~/.cargo/git/db/
|
|
key: cargo-home-${{ matrix.runner }}-${{ matrix.target }}-${{ matrix.profile }}-${{ steps.lockhash.outputs.hash }}-${{ steps.lockhash.outputs.toolchain_hash }}
|
|
restore-keys: |
|
|
cargo-home-${{ matrix.runner }}-${{ matrix.target }}-${{ matrix.profile }}-
|
|
|
|
- name: Install sccache
|
|
if: ${{ env.USE_SCCACHE == 'true' }}
|
|
uses: taiki-e/install-action@cca35edeb1d01366c2843b68fc3ca441446d73d3 # v2.77.1
|
|
with:
|
|
tool: sccache@0.14.0
|
|
fallback: none
|
|
|
|
- name: Configure sccache backend
|
|
if: ${{ env.USE_SCCACHE == 'true' }}
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
if [[ -n "${ACTIONS_CACHE_URL:-}" && -n "${ACTIONS_RUNTIME_TOKEN:-}" ]]; then
|
|
echo "SCCACHE_GHA_ENABLED=true" >> "$GITHUB_ENV"
|
|
echo "Using sccache GitHub backend"
|
|
else
|
|
echo "SCCACHE_GHA_ENABLED=false" >> "$GITHUB_ENV"
|
|
if [[ -n "${DEV_DRIVE:-}" ]]; then
|
|
echo "SCCACHE_DIR=${DEV_DRIVE}\\.sccache" >> "$GITHUB_ENV"
|
|
else
|
|
echo "SCCACHE_DIR=${{ github.workspace }}/.sccache" >> "$GITHUB_ENV"
|
|
fi
|
|
echo "Using sccache local disk + actions/cache fallback"
|
|
fi
|
|
|
|
- name: Enable sccache wrapper
|
|
if: ${{ env.USE_SCCACHE == 'true' }}
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
wrapper="$(command -v sccache)"
|
|
if [[ "${RUNNER_OS}" == "Windows" ]] && command -v cygpath >/dev/null 2>&1; then
|
|
wrapper="$(cygpath -w "${wrapper}")"
|
|
fi
|
|
echo "RUSTC_WRAPPER=${wrapper}" >> "$GITHUB_ENV"
|
|
echo "CARGO_BUILD_RUSTC_WRAPPER=${wrapper}" >> "$GITHUB_ENV"
|
|
|
|
- name: Restore sccache cache (fallback)
|
|
if: ${{ env.USE_SCCACHE == 'true' && env.SCCACHE_GHA_ENABLED != 'true' }}
|
|
id: cache_sccache_restore
|
|
uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
|
|
with:
|
|
path: ${{ env.SCCACHE_DIR }}
|
|
key: sccache-${{ matrix.runner }}-${{ matrix.target }}-${{ matrix.profile }}${{ matrix.partition_suffix }}-${{ steps.lockhash.outputs.hash }}-${{ github.run_id }}
|
|
restore-keys: |
|
|
sccache-${{ matrix.runner }}-${{ matrix.target }}-${{ matrix.profile }}${{ matrix.partition_suffix }}-${{ steps.lockhash.outputs.hash }}-
|
|
sccache-${{ matrix.runner }}-${{ matrix.target }}-${{ matrix.profile }}-${{ steps.lockhash.outputs.hash }}-
|
|
sccache-${{ matrix.runner }}-${{ matrix.target }}-${{ matrix.profile }}-
|
|
|
|
- name: Start sccache server (Windows)
|
|
if: ${{ env.USE_SCCACHE == 'true' && runner.os == 'Windows' }}
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
sccache --start-server
|
|
sccache --show-stats
|
|
|
|
- uses: taiki-e/install-action@44c6d64aa62cd779e873306675c7a58e86d6d532 # v2.62.49
|
|
with:
|
|
tool: nextest@0.9.103
|
|
|
|
- name: Enable unprivileged user namespaces (Linux)
|
|
if: runner.os == 'Linux'
|
|
run: |
|
|
# Required for bubblewrap to work on Linux CI runners.
|
|
sudo sysctl -w kernel.unprivileged_userns_clone=1
|
|
# Ubuntu 24.04+ can additionally gate unprivileged user namespaces
|
|
# behind AppArmor.
|
|
if sudo sysctl -a 2>/dev/null | grep -q '^kernel.apparmor_restrict_unprivileged_userns'; then
|
|
sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0
|
|
fi
|
|
|
|
- name: Set up remote test env (Docker)
|
|
if: ${{ runner.os == 'Linux' && matrix.remote_env == 'true' }}
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
export CODEX_TEST_REMOTE_ENV_CONTAINER_NAME=codex-remote-test-env
|
|
source "${GITHUB_WORKSPACE}/scripts/test-remote-env.sh"
|
|
echo "CODEX_TEST_REMOTE_ENV=${CODEX_TEST_REMOTE_ENV}" >> "$GITHUB_ENV"
|
|
echo "CODEX_TEST_REMOTE_EXEC_SERVER_URL=${CODEX_TEST_REMOTE_EXEC_SERVER_URL}" >> "$GITHUB_ENV"
|
|
|
|
- name: tests
|
|
id: test
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
nextest_args=(
|
|
--no-fail-fast
|
|
--target "${{ matrix.target }}"
|
|
--cargo-profile ci-test
|
|
--timings
|
|
)
|
|
if [[ "${{ runner.os }}" == "Windows" && -n "${WINDOWS_NEXTEST_THREADS}" ]]; then
|
|
nextest_args+=(--test-threads "${WINDOWS_NEXTEST_THREADS}")
|
|
fi
|
|
if [[ -n "${NEXTEST_PARTITION}" ]]; then
|
|
nextest_args+=(--partition "${NEXTEST_PARTITION}")
|
|
fi
|
|
cargo nextest run "${nextest_args[@]}"
|
|
env:
|
|
RUST_BACKTRACE: 1
|
|
RUST_MIN_STACK: "8388608" # 8 MiB
|
|
NEXTEST_STATUS_LEVEL: leak
|
|
NEXTEST_PARTITION: ${{ matrix.nextest_partition }}
|
|
|
|
- name: Upload Cargo timings (nextest)
|
|
if: always()
|
|
uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
|
|
with:
|
|
name: cargo-timings-rust-ci-nextest-${{ matrix.target }}-${{ matrix.profile }}${{ matrix.partition_suffix }}
|
|
path: codex-rs/target/**/cargo-timings/cargo-timing.html
|
|
if-no-files-found: warn
|
|
|
|
- name: Save cargo home cache
|
|
if: always() && !cancelled() && steps.cache_cargo_home_restore.outputs.cache-hit != 'true'
|
|
continue-on-error: true
|
|
uses: actions/cache/save@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
|
|
with:
|
|
path: |
|
|
~/.cargo/bin/
|
|
~/.cargo/registry/index/
|
|
~/.cargo/registry/cache/
|
|
~/.cargo/git/db/
|
|
key: cargo-home-${{ matrix.runner }}-${{ matrix.target }}-${{ matrix.profile }}-${{ steps.lockhash.outputs.hash }}-${{ steps.lockhash.outputs.toolchain_hash }}
|
|
|
|
- name: Save sccache cache (fallback)
|
|
if: always() && !cancelled() && env.USE_SCCACHE == 'true' && env.SCCACHE_GHA_ENABLED != 'true'
|
|
continue-on-error: true
|
|
uses: actions/cache/save@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
|
|
with:
|
|
path: ${{ env.SCCACHE_DIR }}
|
|
key: sccache-${{ matrix.runner }}-${{ matrix.target }}-${{ matrix.profile }}${{ matrix.partition_suffix }}-${{ steps.lockhash.outputs.hash }}-${{ github.run_id }}
|
|
|
|
- name: sccache stats
|
|
if: always() && env.USE_SCCACHE == 'true'
|
|
continue-on-error: true
|
|
run: sccache --show-stats || true
|
|
|
|
- name: sccache summary
|
|
if: always() && env.USE_SCCACHE == 'true'
|
|
shell: bash
|
|
run: |
|
|
{
|
|
echo "### sccache stats — ${{ matrix.target }} (tests)";
|
|
echo;
|
|
echo '```';
|
|
sccache --show-stats || true;
|
|
echo '```';
|
|
} >> "$GITHUB_STEP_SUMMARY"
|
|
|
|
- name: Tear down remote test env
|
|
if: ${{ always() && runner.os == 'Linux' && matrix.remote_env == 'true' }}
|
|
shell: bash
|
|
run: |
|
|
set +e
|
|
if [[ "${{ steps.test.outcome }}" != "success" ]]; then
|
|
docker logs codex-remote-test-env || true
|
|
fi
|
|
docker rm -f codex-remote-test-env >/dev/null 2>&1 || true
|
|
|
|
- name: verify tests passed
|
|
if: steps.test.outcome == 'failure'
|
|
run: |
|
|
echo "Tests failed. See logs for details."
|
|
exit 1
|
|
|
|
windows_arm64_archive_tests:
|
|
name: Tests — windows-arm64 archive - aarch64-pc-windows-msvc${{ matrix.partition_name }}
|
|
needs:
|
|
[
|
|
test_matrix,
|
|
windows_arm64_test_archive,
|
|
]
|
|
if: ${{ needs.test_matrix.outputs.windows_arm64_archive == 'true' && needs.windows_arm64_test_archive.result == 'success' }}
|
|
runs-on: ${{ matrix.runs_on || matrix.runner }}
|
|
timeout-minutes: ${{ matrix.timeout_minutes || 45 }}
|
|
defaults:
|
|
run:
|
|
working-directory: codex-rs
|
|
env:
|
|
WINDOWS_NEXTEST_THREADS: ${{ github.event_name == 'workflow_dispatch' && inputs.windows_nextest_threads || '' }}
|
|
WINDOWS_ARM64_ARCHIVE_FILE: windows-arm64-nextest-archive.tar.zst
|
|
strategy:
|
|
fail-fast: false
|
|
matrix: ${{ fromJSON(needs.test_matrix.outputs.windows_arm64_archive_matrix) }}
|
|
|
|
steps:
|
|
- uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
|
|
- name: Configure Dev Drive (Windows)
|
|
shell: pwsh
|
|
run: ../.github/scripts/setup-dev-drive.ps1
|
|
|
|
# Some integration tests rely on DotSlash being installed.
|
|
# See https://github.com/openai/codex/pull/7617.
|
|
- name: Install DotSlash
|
|
uses: facebook/install-dotslash@1e4e7b3e07eaca387acb98f1d4720e0bee8dbb6a # v2
|
|
|
|
- uses: dtolnay/rust-toolchain@a0b273b48ed29de4470960879e8381ff45632f26 # 1.93.0
|
|
|
|
- uses: taiki-e/install-action@44c6d64aa62cd779e873306675c7a58e86d6d532 # v2.62.49
|
|
with:
|
|
tool: nextest@0.9.103
|
|
|
|
- name: Download nextest archive
|
|
uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
|
|
with:
|
|
name: windows-arm64-nextest-archive
|
|
path: ${{ runner.temp }}/windows-arm64-nextest-archive
|
|
|
|
- name: tests
|
|
id: test
|
|
shell: bash
|
|
run: |
|
|
set -euo pipefail
|
|
archive_file="${RUNNER_TEMP}/windows-arm64-nextest-archive/${WINDOWS_ARM64_ARCHIVE_FILE}"
|
|
workspace_root="$(pwd)"
|
|
extract_dir="${RUNNER_TEMP}/nextest-extract${{ matrix.partition_suffix }}"
|
|
if [[ "${RUNNER_OS}" == "Windows" ]] && command -v cygpath >/dev/null 2>&1; then
|
|
archive_file="$(cygpath -w "${archive_file}")"
|
|
workspace_root="$(cygpath -w "${workspace_root}")"
|
|
extract_dir="$(cygpath -w "${extract_dir}")"
|
|
fi
|
|
nextest_args=(
|
|
--no-fail-fast
|
|
--archive-file "${archive_file}"
|
|
--workspace-remap "${workspace_root}"
|
|
--extract-to "${extract_dir}"
|
|
--extract-overwrite
|
|
)
|
|
if [[ -n "${WINDOWS_NEXTEST_THREADS}" ]]; then
|
|
nextest_args+=(--test-threads "${WINDOWS_NEXTEST_THREADS}")
|
|
fi
|
|
if [[ -n "${NEXTEST_PARTITION}" ]]; then
|
|
nextest_args+=(--partition "${NEXTEST_PARTITION}")
|
|
fi
|
|
cargo nextest run "${nextest_args[@]}"
|
|
env:
|
|
RUST_BACKTRACE: 1
|
|
RUST_MIN_STACK: "8388608" # 8 MiB
|
|
NEXTEST_STATUS_LEVEL: leak
|
|
NEXTEST_PARTITION: ${{ matrix.nextest_partition }}
|
|
|
|
- name: verify tests passed
|
|
if: steps.test.outcome == 'failure'
|
|
run: |
|
|
echo "Tests failed. See logs for details."
|
|
exit 1
|
|
|
|
# --- Gatherer job for the full post-merge workflow --------------------------
|
|
results:
|
|
name: Full CI results
|
|
needs:
|
|
[
|
|
general,
|
|
cargo_shear,
|
|
argument_comment_lint_package,
|
|
argument_comment_lint_prebuilt,
|
|
lint_build,
|
|
test_matrix,
|
|
tests,
|
|
windows_arm64_test_archive,
|
|
windows_arm64_archive_tests,
|
|
]
|
|
if: always()
|
|
runs-on: ubuntu-24.04
|
|
steps:
|
|
- name: Summarize
|
|
shell: bash
|
|
run: |
|
|
echo "argpkg : ${{ needs.argument_comment_lint_package.result }}"
|
|
echo "arglint: ${{ needs.argument_comment_lint_prebuilt.result }}"
|
|
echo "general: ${{ needs.general.result }}"
|
|
echo "shear : ${{ needs.cargo_shear.result }}"
|
|
echo "lint : ${{ needs.lint_build.result }}"
|
|
echo "matrix : ${{ needs.test_matrix.result }}"
|
|
echo "tests : ${{ needs.tests.result }}"
|
|
echo "archive: ${{ needs.windows_arm64_test_archive.result }}"
|
|
echo "armins : ${{ needs.windows_arm64_archive_tests.result }}"
|
|
[[ '${{ needs.argument_comment_lint_package.result }}' == 'success' ]] || { echo 'argument_comment_lint_package failed'; exit 1; }
|
|
[[ '${{ needs.argument_comment_lint_prebuilt.result }}' == 'success' ]] || { echo 'argument_comment_lint_prebuilt failed'; exit 1; }
|
|
[[ '${{ needs.general.result }}' == 'success' ]] || { echo 'general failed'; exit 1; }
|
|
[[ '${{ needs.cargo_shear.result }}' == 'success' ]] || { echo 'cargo_shear failed'; exit 1; }
|
|
[[ '${{ needs.lint_build.result }}' == 'success' ]] || { echo 'lint_build failed'; exit 1; }
|
|
[[ '${{ needs.test_matrix.result }}' == 'success' ]] || { echo 'test_matrix failed'; exit 1; }
|
|
[[ '${{ needs.tests.result }}' == 'success' ]] || { echo 'tests failed'; exit 1; }
|
|
if [[ '${{ needs.test_matrix.outputs.windows_arm64_archive }}' == 'true' ]]; then
|
|
[[ '${{ needs.windows_arm64_test_archive.result }}' == 'success' ]] || { echo 'windows_arm64_test_archive failed'; exit 1; }
|
|
[[ '${{ needs.windows_arm64_archive_tests.result }}' == 'success' ]] || { echo 'windows_arm64_archive_tests failed'; exit 1; }
|
|
else
|
|
[[ '${{ needs.windows_arm64_test_archive.result }}' == 'skipped' ]] || { echo 'windows_arm64_test_archive unexpectedly ran'; exit 1; }
|
|
[[ '${{ needs.windows_arm64_archive_tests.result }}' == 'skipped' ]] || { echo 'windows_arm64_archive_tests unexpectedly ran'; exit 1; }
|
|
fi
|
|
|
|
- name: sccache summary note
|
|
if: always()
|
|
run: |
|
|
echo "Per-job sccache stats are attached to each matrix job's Step Summary."
|