From cef19a523c9130db8c363783d83e25cde5c8c6eb Mon Sep 17 00:00:00 2001 From: castrojo Date: Sat, 14 Nov 2026 13:50:14 -0500 Subject: [PATCH 1/8] fix(ci): keep advisory cache warming off the release critical path Image builds wait for graph classification and boot-tool preflight, not the four-hour cache seeder. Preserve all publication, boot-test, image-check and credential boundaries. A cold run may duplicate compilation while warming, but a slow producer cannot prevent release startup. Assisted-by: GPT-6.1 via GitHub Copilot Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Signed-off-by: castrojo --- .github/workflows/build.yml | 18 +++++++++--------- docs/skills/ci-tooling.md | 13 +++++++------ 2 files changed, 16 insertions(+), 15 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index e388a0a6..872ca4ac 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -152,15 +152,15 @@ jobs: # FSDK's kernel is most of a cold build # (docs/skills/ci-tooling.md#build-time-and-caches), and no upstream cache # holds it (our module certificate and kernel config patches change its - # key). These jobs build it (and Go) with no signing secrets, each against - # one committed module certificate, and push the key-free artifacts to the - # project CAS unless a remote already holds them; every build pulls them - # through project.conf (scripts/kernel-cache.sh): + # key). These jobs warm the key-free kernel/Go/GCC/Brew closure, each against + # one committed module certificate, and push it to the project CAS via + # scripts/kernel-cache.sh: # - kernel-cache: the release certificate, for release builds; # - kernel-cache-dev: the public INSECURE dev certificate that # `just gen-dev-keys` uses (files/dev-keys/), for pull requests, the - # nightly build and local builds. No job needs it, so it never delays - # a release. + # nightly build and local builds. + # Neither job gates image builds or releases. Cold runs can duplicate + # compilation while seeding fills the cache instead of waiting on it. # The cache only saves time: a failed seed must not hold back the release, # which checks build's and boot-test-result's own results. kernel-cache: @@ -269,9 +269,9 @@ jobs: run: bash scripts/ci/dogfood-preflight.sh build: - needs: [changes, kernel-cache, boot-test-preflight] - # Runs when kernel-cache is skipped (non-release builds) or failed: the - # cache only saves time. A failed preflight stops it. + needs: [changes, boot-test-preflight] + # Cache warming is advisory, never a release startup dependency. + # A failed boot-test preflight still stops the image build. if: ${{ !cancelled() && needs.changes.outputs.image == 'true' && needs.boot-test-preflight.result == 'success' }} # The signing secrets live in the `release` environment, which only main # may use. Every other build runs with no environment (an empty name): diff --git a/docs/skills/ci-tooling.md b/docs/skills/ci-tooling.md index 14dc1e5f..e942dd1e 100644 --- a/docs/skills/ci-tooling.md +++ b/docs/skills/ci-tooling.md @@ -400,11 +400,12 @@ version) and the NVIDIA Container Toolkit (Go); the driver sysext adds about on every push to `main` (`release=true`), run `scripts/kernel-cache.sh seed`, one per module certificate the kernel can trust (it is part of the kernel's cache key): - `kernel-cache` runs `seed release` with the committed release certificate - (`files/release-keys/linux-module-cert.crt`); `build` waits for it. + (`files/release-keys/linux-module-cert.crt`). - `kernel-cache-dev` runs `seed dev` with the public INSECURE dev certificate (`files/dev-keys/INSECURE-dev-module-key.crt`) that - `just gen-dev-keys` uses for every non-release build. No job waits for - it, so it never delays a release. + `just gen-dev-keys` uses for every non-release build. + Neither job gates image building or publication. Cold runs may duplicate + compilation while warming instead of waiting on a four-hour seed timeout. With no signing secrets and that one certificate staged as the only file of `files/boot-keys/modules/` (`seed` refuses anything else there: that @@ -428,9 +429,9 @@ version) and the NVIDIA Container Toolkit (Go); the driver sysext adds about The CAS is publicly readable: `seed` refuses if `bluefin-server/keys/boot-keys.bst` is anywhere in the graph it builds, and the job holds no signing secret. A content grep is no guard here: FSDK - sources (Go's TLS test data and others) carry 307 PEM private keys. The - seed step is `continue-on-error`, so a failed seed only costs time; the - next step then posts a warning and a step summary line. + sources (Go's TLS test data and others) carry 307 PEM private keys. + The seed step is `continue-on-error`; failures are posted as a warning and + step summary, without preventing an independently verified release. The former kernel/Go-only seed took 44 min and 15 GB on 16+ CPUs. Kernel, Go, GCC, Brew or their dependency changes reseed the affected targets. - **No other cache push.** `bluefin-server/keys/boot-keys.bst` imports From 6952a95054fbcb0280a18cb805f31e2c4c326568 Mon Sep 17 00:00:00 2001 From: castrojo Date: Sat, 14 Nov 2026 14:46:31 -0500 Subject: [PATCH 2/8] test(ci): remove the obsolete release cache gating requirement The failing unit explicitly required the kernel-cache build dependency removed by this PR. Delete that scheduling assertion rather than re-pin its inverse; preserve release-only seed and no-signing-key security checks. The active cache repair at 47ce75e already has successful unit checks and is unchanged. Assisted-by: GPT-6.1 via GitHub Copilot Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Signed-off-by: castrojo --- tests/unit/test_dev_module_key.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/tests/unit/test_dev_module_key.py b/tests/unit/test_dev_module_key.py index 66b74b41..94a99c51 100644 --- a/tests/unit/test_dev_module_key.py +++ b/tests/unit/test_dev_module_key.py @@ -135,7 +135,7 @@ def test_release_builds_check_their_keys_after_staging_them() -> None: assert release_branch.index("bash scripts/check-release-keys.sh") > staged -def test_both_kernel_variants_are_seeded_on_releases_and_only_release_gates_the_build() -> None: +def test_kernel_seeders_are_release_only_and_have_no_signing_keys() -> None: jobs = WORKFLOW["jobs"] for job, variant in (("kernel-cache", "release"), ("kernel-cache-dev", "dev")): assert jobs[job]["if"] == "needs.changes.outputs.release == 'true'" @@ -143,5 +143,3 @@ def test_both_kernel_variants_are_seeded_on_releases_and_only_release_gates_the_ assert f"bash scripts/kernel-cache.sh seed {variant}" in runs assert "BOOT_KEYS_TARBALL" not in str(jobs[job]) and "SYSUPDATE_SIGNING_KEY" not in str(jobs[job]) assert "gen-dev-keys" not in str(jobs[job]) - assert "kernel-cache" in jobs["build"]["needs"] - assert not any("kernel-cache-dev" in str(j.get("needs", "")) for j in jobs.values()) From cb792890c78338635d90a9b03e16233031ee5f6e Mon Sep 17 00:00:00 2001 From: castrojo Date: Sat, 14 Nov 2026 14:55:29 -0500 Subject: [PATCH 3/8] fix(ci): isolate cache warmers from the serialized release workflow Removing build.needs alone leaves the four-hour producers inside the workflow-wide main concurrency group, delaying later releases. Move the existing two seed jobs into a main-only cache-warm workflow with its own concurrency group; do not add producers or weaken environment restrictions. Migrate the credential, runner-disk and gate contracts and remove obsolete exceptions. Retain all image, boot and publication checks. Assisted-by: GPT-6.1 via GitHub Copilot Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Signed-off-by: castrojo --- .github/workflows/build.yml | 101 +--------------------------- .github/workflows/cache-warm.yml | 95 ++++++++++++++++++++++++++ docs/skills/ci-tooling.md | 13 ++-- tests/unit/test_build_modes.py | 6 -- tests/unit/test_ci_runner_disk.py | 2 +- tests/unit/test_dev_module_key.py | 12 +++- tests/unit/test_release_workflow.py | 28 +++----- tests/unit/test_required_checks.py | 2 - 8 files changed, 124 insertions(+), 135 deletions(-) create mode 100644 .github/workflows/cache-warm.yml diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 872ca4ac..26586e1c 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -149,100 +149,6 @@ jobs: - name: Validate Element Graph run: just validate - # FSDK's kernel is most of a cold build - # (docs/skills/ci-tooling.md#build-time-and-caches), and no upstream cache - # holds it (our module certificate and kernel config patches change its - # key). These jobs warm the key-free kernel/Go/GCC/Brew closure, each against - # one committed module certificate, and push it to the project CAS via - # scripts/kernel-cache.sh: - # - kernel-cache: the release certificate, for release builds; - # - kernel-cache-dev: the public INSECURE dev certificate that - # `just gen-dev-keys` uses (files/dev-keys/), for pull requests, the - # nightly build and local builds. - # Neither job gates image builds or releases. Cold runs can duplicate - # compilation while seeding fills the cache instead of waiting on it. - # The cache only saves time: a failed seed must not hold back the release, - # which checks build's and boot-test-result's own results. - kernel-cache: - needs: changes - if: needs.changes.outputs.release == 'true' - # CASD_CLIENT_KEY lives in this environment, which only main may use. - environment: bst-cache - runs-on: ubuntu-26.04 - timeout-minutes: 240 - permissions: - contents: read - steps: - - name: Checkout repository - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - with: - persist-credentials: false - - - name: Set up just - uses: taiki-e/install-action@cfdb7ed4ccc7c7dce37759eae89dc5674b469b39 # v2.90.3 - with: - tool: just@1.59.0 - - - name: Set up runner disk space - run: bash scripts/ci-runner-disk.sh - - - name: Build and push the kernel cache unless it exists - id: seed - continue-on-error: true - env: - CASD_CLIENT_CERT: ${{ vars.CASD_CLIENT_CERT }} - CASD_CLIENT_KEY: ${{ secrets.CASD_CLIENT_KEY }} - run: bash scripts/kernel-cache.sh seed release - - # continue-on-error turns the job green; say so, or a cache that never - # seeds goes unnoticed while every build compiles the kernel. - - name: Report a failed seed - if: steps.seed.outcome == 'failure' - run: | - msg="The kernel cache seed failed; this release builds the kernel itself. See the step above." - echo "::warning title=Kernel cache not seeded::${msg}" - echo "${msg}" >> "$GITHUB_STEP_SUMMARY" - - kernel-cache-dev: - needs: changes - if: needs.changes.outputs.release == 'true' - # CASD_CLIENT_KEY lives in this environment, which only main may use. - environment: bst-cache - runs-on: ubuntu-26.04 - timeout-minutes: 240 - permissions: - contents: read - steps: - - name: Checkout repository - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - with: - persist-credentials: false - - - name: Set up just - uses: taiki-e/install-action@cfdb7ed4ccc7c7dce37759eae89dc5674b469b39 # v2.90.3 - with: - tool: just@1.59.0 - - - name: Set up runner disk space - run: bash scripts/ci-runner-disk.sh - - - name: Build and push the dev kernel cache unless it exists - id: seed - continue-on-error: true - env: - CASD_CLIENT_CERT: ${{ vars.CASD_CLIENT_CERT }} - CASD_CLIENT_KEY: ${{ secrets.CASD_CLIENT_KEY }} - run: bash scripts/kernel-cache.sh seed dev - - # continue-on-error turns the job green; say so, or a cache that never - # seeds goes unnoticed while every build compiles the kernel. - - name: Report a failed seed - if: steps.seed.outcome == 'failure' - run: | - msg="The dev kernel cache seed failed; pull requests and the nightly build compile the kernel until a release seeds it. See the step above." - echo "::warning title=Kernel cache not seeded::${msg}" - echo "${msg}" >> "$GITHUB_STEP_SUMMARY" - # Installs what the boot test runs and checks every host tool its dogfood # scripts call is there (scripts/ci/dogfood-preflight.sh), in about a # minute, so a missing one fails before the build instead of after it. @@ -539,9 +445,6 @@ jobs: # parallel, one runner each; boot-test-result is their one gate. boot-test: needs: [changes, build] - # build needs kernel-cache, which is skipped outside release builds; a - # skipped job anywhere upstream skips this one unless it checks build's - # own result. if: ${{ !cancelled() && needs.build.result == 'success' }} runs-on: ubuntu-26.04 timeout-minutes: 60 @@ -754,9 +657,7 @@ jobs: # command is scripts/publish-release.sh, which release-dry-run rehearses on # each pull request that builds. release: - # Explicit results, not !failure(): a failed kernel-cache (only a cache) - # must not hold back a release, and nothing but a built, boot-tested and - # image-checked set may publish. + # Publish only a built, boot-tested and image-checked set. if: ${{ !cancelled() && needs.changes.outputs.release == 'true' && needs.build.result == 'success' && needs.boot-test-result.result == 'success' && needs.image-check.result == 'success' }} needs: [changes, build, boot-test-result, image-check] runs-on: ubuntu-26.04 diff --git a/.github/workflows/cache-warm.yml b/.github/workflows/cache-warm.yml new file mode 100644 index 00000000..b113ef20 --- /dev/null +++ b/.github/workflows/cache-warm.yml @@ -0,0 +1,95 @@ +name: Warm BuildStream cache + +on: + push: + branches: [main] + workflow_dispatch: + +# A seed must not occupy build.yml's serialized release queue. +# Finish the current warming run; GitHub keeps only the latest pending one. +concurrency: + group: cache-warm-${{ github.ref }} + cancel-in-progress: false + +permissions: + contents: read + +jobs: + kernel-cache: + if: github.ref == 'refs/heads/main' + # CASD_CLIENT_KEY lives in this environment, which only main may use. + environment: bst-cache + runs-on: ubuntu-26.04 + timeout-minutes: 240 + permissions: + contents: read + steps: + - name: Checkout repository + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + + - name: Set up just + uses: taiki-e/install-action@cfdb7ed4ccc7c7dce37759eae89dc5674b469b39 # v2.90.3 + with: + tool: just@1.59.0 + + - name: Set up runner disk space + run: bash scripts/ci-runner-disk.sh + + - name: Build and push the kernel cache unless it exists + id: seed + continue-on-error: true + env: + CASD_CLIENT_CERT: ${{ vars.CASD_CLIENT_CERT }} + CASD_CLIENT_KEY: ${{ secrets.CASD_CLIENT_KEY }} + run: bash scripts/kernel-cache.sh seed release + + # continue-on-error turns the job green; say so, or a cache that never + # seeds goes unnoticed while every build compiles the kernel. + - name: Report a failed seed + if: steps.seed.outcome == 'failure' + run: | + msg="The kernel cache seed failed; this release builds the kernel itself. See the step above." + echo "::warning title=Kernel cache not seeded::${msg}" + echo "${msg}" >> "$GITHUB_STEP_SUMMARY" + + kernel-cache-dev: + if: github.ref == 'refs/heads/main' + # CASD_CLIENT_KEY lives in this environment, which only main may use. + environment: bst-cache + runs-on: ubuntu-26.04 + timeout-minutes: 240 + permissions: + contents: read + steps: + - name: Checkout repository + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + + - name: Set up just + uses: taiki-e/install-action@cfdb7ed4ccc7c7dce37759eae89dc5674b469b39 # v2.90.3 + with: + tool: just@1.59.0 + + - name: Set up runner disk space + run: bash scripts/ci-runner-disk.sh + + - name: Build and push the dev kernel cache unless it exists + id: seed + continue-on-error: true + env: + CASD_CLIENT_CERT: ${{ vars.CASD_CLIENT_CERT }} + CASD_CLIENT_KEY: ${{ secrets.CASD_CLIENT_KEY }} + run: bash scripts/kernel-cache.sh seed dev + + # continue-on-error turns the job green; say so, or a cache that never + # seeds goes unnoticed while every build compiles the kernel. + - name: Report a failed seed + if: steps.seed.outcome == 'failure' + run: | + msg="The dev kernel cache seed failed; pull requests and the nightly build compile the kernel until a release seeds it. See the step above." + echo "::warning title=Kernel cache not seeded::${msg}" + echo "${msg}" >> "$GITHUB_STEP_SUMMARY" + diff --git a/docs/skills/ci-tooling.md b/docs/skills/ci-tooling.md index e942dd1e..00e63c24 100644 --- a/docs/skills/ci-tooling.md +++ b/docs/skills/ci-tooling.md @@ -183,7 +183,7 @@ one of these environments is refused before its first step. | Environment | Secrets | Jobs | |---|---|---| | `release` | `BOOT_KEYS_TARBALL`, `SYSUPDATE_SIGNING_KEY` | `build`, only when `changes` says `release=true` | -| `bst-cache` | `CASD_CLIENT_KEY` (`CASD_CLIENT_CERT` is a repository variable) | `kernel-cache`, `kernel-cache-dev` (releases only) | +| `bst-cache` | `CASD_CLIENT_KEY` (`CASD_CLIENT_CERT` is a repository variable) | `kernel-cache`, `kernel-cache-dev` in `cache-warm.yml` (main only) | | `trackers` | `MERGERAPTOR_APP_ID`, `MERGERAPTOR_PRIVATE_KEY` | `track-junctions`, `track-binaries`' `propose` | `build` serves releases and every other build, so it names the environment @@ -222,6 +222,7 @@ use: remove only this repository from their repository access. | `validate` | `build.yml` | `pull_request`, `merge_group` | `just validate` with throwaway keys: resolves every shipped element graph and runs the version-invariant checks, in minutes. Read-only token. | | `boot-test-preflight` | `build.yml` | when `changes` says `image=true` | Installs the boot test's tools with the same `scripts/ci/install-qemu-ovmf.sh` as `boot-test`, then runs `scripts/ci/dogfood-preflight.sh`: every host tool the dogfood scripts `boot-test` runs must be on the `PATH`, the OVMF files present and `/dev/kvm` read-writable. Each name its tool pattern matches in those scripts must be listed there, as a host tool or as one the runner never runs, so a new tool fails this job until it is. About a minute; `build` waits for it, so a missing tool (#486: `mcopy`) fails before the build instead of after it. Read-only token. | | `build` | `build.yml` | when `changes` says `image=true` | Resolves the element graph, sets `image-version`, and runs the full BuildStream compile of the image set (OS DDI, signed UKIs, netboot ESP, k0s/KubeStellar/kubeadm/OpenZFS/NVIDIA sysext assets), which also writes and signs the combined `SHA256SUMS` inside `oci/bluefin-server-image.bst`. For releases it runs in the `release` environment and installs its `BOOT_KEYS_TARBALL` and `SYSUPDATE_SIGNING_KEY` secrets; both are required there. Other builds use no environment. Every other build uses throwaway keys and also exports two higher-versioned sets (`1..1`, `1..2`) for the update test. It uploads each set in parts by what its consumers read: `dist/diskless/` as `image-set-netboot` (OS DDI, netboot UKI and ESP), `-installer`, `-sysupdate` (usr, usr-verity, disk UKI) and `-sysexts` (`*.raw.zst`), plus the catch-all `image-set-core` that excludes exactly what the others include, so no file is ever dropped; `1..1` as `image-next-boot` (catch-all) and `image-next-update` (sysupdate sources and sysexts); `1..2` as `image-broken`; the Ignition test signatures as `ignition-sigs`. The update sets leave out the installer. `image-check`, `release` and `release-dry-run` merge every `image-set-*` part back into `dist/diskless/`; `tests/unit/test_ci_image_artifacts.py` keeps the split exhaustive. Read-only token. | +| `kernel-cache`, `kernel-cache-dev` | `cache-warm.yml` | `push/main`, `workflow_dispatch` on main | Warms the key-free kernel/Go/GCC/Brew closure in the project CAS. Separate workflow and concurrency group: never occupies the serialized release queue. Read-only token; mTLS credentials in `bst-cache` only. | | `boot-test` | `build.yml` | after `build` | Runs the Secure Boot QEMU checks on the exported sets (see Core Process step 4), with the harness checked out at the commit `build` built. A `fail-fast: false` matrix over the buckets of `scripts/ci/boot-test.sh`, one runner each, so its checks are `boot-test ()`; each bucket downloads only the `build` artifacts its scenarios read, as listed in its matrix entry. Each bucket's wall time, passed or failed, is a notice and a row of its step summary. On failure each bucket uploads its logs as `boot-test-logs-`. Read-only token. | | `boot-test-result` | `build.yml` | after `boot-test`, when `build` succeeded | The one result of every `boot-test` bucket: fails unless `boot-test` succeeded. `release` and `nightly-status` gate on it, and it is skipped like `boot-test` when nothing was built, so it is the boot test's required check. No checkout, `permissions: {}`. | | `image-check` | `build.yml` | after `build` | Runs `.github/scripts/check-image.py` on the built image set: no missing libraries, required dlopen libraries, or unit/udev programs in `/usr`, the disk UKI's initrd, or the sysexts (resolved over `/usr`); the step summary diffs `/usr` paths against the latest release. Then `scripts/ci/image-sizes.py` tables the size of every file, the disk UKI's `.linux` and `.initrd` and the unpacked initrd against the latest release's `bluefin-server_.size.json` (or its `*.usr.raw` alone), with a `::warning::` for each that grew by more than 5 % or 5 MiB (never a failure), and uploads this set's report as the `image-size` artifact that `release` and `release-dry-run` publish with the set, unsigned (see "Publishing" in `systemd-sysupdate-verification.md`). `release` needs it. Read-only token. | @@ -396,16 +397,16 @@ version) and the NVIDIA Container Toolkit (Go); the driver sysext adds about (`elements/`, `files/`, `include/`, `patches/`, `plugins/`, `scripts/`, `tests/fixtures/`, `project.conf`, `Justfile`, `build.yml`) would skip. A skipped job reports as passing, so its required check does not hold it. -- **Kernel cache in the project CAS, key-free by construction.** Two jobs, - on every push to `main` (`release=true`), run `scripts/kernel-cache.sh seed`, one per module - certificate the kernel can trust (it is part of the kernel's cache key): +- **Key-free kernel cache in the project CAS.** Two jobs in `cache-warm.yml` + run on pushes to `main` or a manual dispatch on `main`: - `kernel-cache` runs `seed release` with the committed release certificate (`files/release-keys/linux-module-cert.crt`). - `kernel-cache-dev` runs `seed dev` with the public INSECURE dev certificate (`files/dev-keys/INSECURE-dev-module-key.crt`) that `just gen-dev-keys` uses for every non-release build. - Neither job gates image building or publication. Cold runs may duplicate - compilation while warming instead of waiting on a four-hour seed timeout. + Separate `cache-warm-*` concurrency keeps a slow seed out of the release + workflow and its queue; removing only `build.needs` is insufficient. + Cold image builds may compile concurrently with warming. With no signing secrets and that one certificate staged as the only file of `files/boot-keys/modules/` (`seed` refuses anything else there: that diff --git a/tests/unit/test_build_modes.py b/tests/unit/test_build_modes.py index 0939e14c..aa24fe28 100644 --- a/tests/unit/test_build_modes.py +++ b/tests/unit/test_build_modes.py @@ -97,12 +97,6 @@ def test_signing_secrets_and_publishing_are_release_only() -> None: for step in job.get("steps", []): for key, value in (step.get("env") or {}).items(): if "secrets." in str(value) and "GITHUB_TOKEN" not in str(value): - if name in ("kernel-cache", "kernel-cache-dev"): - # The CAS push key, in a job that only runs for - # releases (test_dev_module_key.py) and holds no - # signing secret. - assert (key, value) == ("CASD_CLIENT_KEY", "${{ secrets.CASD_CLIENT_KEY }}") - continue assert name == "build", (name, key) assert str(value).startswith("${{ needs.changes.outputs.release == 'true' && secrets."), key assert "needs.changes.outputs.release == 'true'" in JOBS["release"]["if"] diff --git a/tests/unit/test_ci_runner_disk.py b/tests/unit/test_ci_runner_disk.py index 51ef9a8e..6bcac762 100644 --- a/tests/unit/test_ci_runner_disk.py +++ b/tests/unit/test_ci_runner_disk.py @@ -20,7 +20,7 @@ def test_runner_disk_setup_is_not_inlined(workflow: str) -> None: def test_every_build_job_sets_up_the_runner_disk() -> None: - for workflow, job in (("build.yml", "kernel-cache"), ("build.yml", "kernel-cache-dev"), ("build.yml", "build"), + for workflow, job in (("cache-warm.yml", "kernel-cache"), ("cache-warm.yml", "kernel-cache-dev"), ("build.yml", "build"), ("reproducibility.yml", "reproducibility")): steps = yaml.safe_load((WORKFLOWS / workflow).read_text())["jobs"][job]["steps"] assert any(s.get("run") == "bash scripts/ci-runner-disk.sh" for s in steps), f"{workflow}:{job}" diff --git a/tests/unit/test_dev_module_key.py b/tests/unit/test_dev_module_key.py index 94a99c51..90f0af6b 100644 --- a/tests/unit/test_dev_module_key.py +++ b/tests/unit/test_dev_module_key.py @@ -136,10 +136,18 @@ def test_release_builds_check_their_keys_after_staging_them() -> None: def test_kernel_seeders_are_release_only_and_have_no_signing_keys() -> None: - jobs = WORKFLOW["jobs"] + workflow = yaml.safe_load((ROOT / ".github" / "workflows" / "cache-warm.yml").read_text()) + triggers = workflow.get("on", workflow.get(True)) + assert set(triggers) == {"push", "workflow_dispatch"} + assert triggers["push"] == {"branches": ["main"]} + jobs = workflow["jobs"] for job, variant in (("kernel-cache", "release"), ("kernel-cache-dev", "dev")): - assert jobs[job]["if"] == "needs.changes.outputs.release == 'true'" + assert jobs[job]["if"] == "github.ref == 'refs/heads/main'" runs = [s.get("run", "") for s in jobs[job]["steps"]] assert f"bash scripts/kernel-cache.sh seed {variant}" in runs assert "BOOT_KEYS_TARBALL" not in str(jobs[job]) and "SYSUPDATE_SIGNING_KEY" not in str(jobs[job]) assert "gen-dev-keys" not in str(jobs[job]) + for step in jobs[job]["steps"]: + for key, value in (step.get("env") or {}).items(): + if "secrets." in str(value): + assert (key, value) == ("CASD_CLIENT_KEY", "${{ secrets.CASD_CLIENT_KEY }}") diff --git a/tests/unit/test_release_workflow.py b/tests/unit/test_release_workflow.py index 1dd11054..bfd5136a 100644 --- a/tests/unit/test_release_workflow.py +++ b/tests/unit/test_release_workflow.py @@ -12,6 +12,7 @@ ROOT = Path(__file__).resolve().parents[2] WORKFLOW = yaml.safe_load((ROOT / ".github" / "workflows" / "build.yml").read_text(encoding="utf-8")) +CACHE_JOBS = yaml.safe_load((ROOT / ".github" / "workflows" / "cache-warm.yml").read_text(encoding="utf-8"))["jobs"] JOBS = WORKFLOW["jobs"] RELEASE = JOBS["release"] DRY_RUN = JOBS["release-dry-run"] @@ -81,11 +82,12 @@ def test_signing_secrets_only_reach_main_only_environments() -> None: for secret in ("BOOT_KEYS_TARBALL", "SYSUPDATE_SIGNING_KEY"): assert install["env"][secret] == f"${{{{ needs.changes.outputs.release == 'true' && secrets.{secret} || '' }}}}" for seeder in ("kernel-cache", "kernel-cache-dev"): - assert JOBS[seeder]["environment"] == "bst-cache" - for name, job in JOBS.items(): - if name not in ("build", "kernel-cache", "kernel-cache-dev"): - assert "secrets." not in json.dumps(job), name - assert "environment" not in job, name + assert CACHE_JOBS[seeder]["environment"] == "bst-cache" + for jobs in (JOBS, CACHE_JOBS): + for name, job in jobs.items(): + if name not in ("build", "kernel-cache", "kernel-cache-dev"): + assert "secrets." not in json.dumps(job), name + assert "environment" not in job, name def test_tracker_app_key_only_reaches_the_trackers_environment() -> None: @@ -143,9 +145,7 @@ def test_boot_test_uploads_every_harness_log_directory() -> None: def test_release_publishes_only_a_built_and_boot_tested_set() -> None: - # Explicit results instead of !failure(): a failed kernel-cache must not - # block the release, and a skipped or failed build, boot-test or - # image-check must. + # A skipped or failed build, boot-test or image-check must block publication. cond = RELEASE["if"] assert "!failure()" not in cond for part in ( @@ -181,9 +181,9 @@ def test_boot_test_result_is_the_one_gate_of_every_bucket() -> None: @pytest.mark.parametrize("seeder", ["kernel-cache", "kernel-cache-dev"]) def test_a_failed_kernel_cache_seed_is_reported(seeder: str) -> None: - seed = next(s for s in JOBS[seeder]["steps"] if s.get("id") == "seed") + seed = next(s for s in CACHE_JOBS[seeder]["steps"] if s.get("id") == "seed") assert seed["continue-on-error"] is True - report = next(s for s in JOBS[seeder]["steps"] if s.get("if") == "steps.seed.outcome == 'failure'") + report = next(s for s in CACHE_JOBS[seeder]["steps"] if s.get("if") == "steps.seed.outcome == 'failure'") assert "::warning" in report["run"] and "GITHUB_STEP_SUMMARY" in report["run"] @@ -191,14 +191,6 @@ def test_release_uses_the_job_token_only() -> None: assert "secrets." not in json.dumps(RELEASE) -def test_jobs_after_build_run_when_kernel_cache_is_skipped() -> None: - # kernel-cache only runs for release builds; without an explicit check of - # build's result, a skipped kernel-cache skips every job downstream of build. - for name in ("boot-test", "boot-test-result", "release-dry-run"): - cond = JOBS[name].get("if", "") - assert "!cancelled()" in cond and "needs.build.result == 'success'" in cond, name - - def test_release_publishes_nothing_once_the_commit_cannot_be_tagged() -> None: names = [s.get("name") for s in RELEASE["steps"]] check = names.index("Check this commit can still be tagged") diff --git a/tests/unit/test_required_checks.py b/tests/unit/test_required_checks.py index 6660556d..ef4889f1 100644 --- a/tests/unit/test_required_checks.py +++ b/tests/unit/test_required_checks.py @@ -28,8 +28,6 @@ # Jobs of the gating workflows that are not required checks, and why. EXEMPT = { - ("build.yml", "kernel-cache"): "releases only; a cache, never a gate", - ("build.yml", "kernel-cache-dev"): "releases only; a cache, never a gate", ("build.yml", "boot-test"): "a matrix; boot-test-result is its one result", ("build.yml", "release"): "pushes to main only", ("build.yml", "nightly-status"): "schedule only", From fae8c9f2f554ecbae64a09d22301b0c6040f899f Mon Sep 17 00:00:00 2001 From: castrojo Date: Sat, 14 Nov 2026 17:43:57 -0500 Subject: [PATCH 4/8] fix(cache): materialize all dependencies before replicating cached targets Both first-main seed runs failed while pushing uncached build-only dependencies: the release certificate import and the bootstrap binary-seed element. A cached parent makes the default build plan skip these dependencies. Select --deps all before the matching all-dependencies push. Native pinned BuildStream reproduced the failed cached-parent push, then proved destination-only payload checkouts after upstream was stopped. Cache warming now lives outside release CI, so remove continue-on-error and redundant warning steps instead of turning failed seed jobs green. Preserve credential boundaries and update the failure-visibility contract. Remove an exact-argv snapshot; keep credential and failed-payload safety checks. Assisted-by: GPT-6.1 via GitHub Copilot Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Signed-off-by: castrojo --- .github/workflows/cache-warm.yml | 20 -------------------- docs/skills/ci-tooling.md | 12 +++++++----- scripts/kernel-cache.sh | 5 +++-- tests/unit/test_kernel_cache.py | 8 -------- tests/unit/test_release_workflow.py | 4 +--- 5 files changed, 11 insertions(+), 38 deletions(-) diff --git a/.github/workflows/cache-warm.yml b/.github/workflows/cache-warm.yml index b113ef20..36cdc115 100644 --- a/.github/workflows/cache-warm.yml +++ b/.github/workflows/cache-warm.yml @@ -39,21 +39,11 @@ jobs: - name: Build and push the kernel cache unless it exists id: seed - continue-on-error: true env: CASD_CLIENT_CERT: ${{ vars.CASD_CLIENT_CERT }} CASD_CLIENT_KEY: ${{ secrets.CASD_CLIENT_KEY }} run: bash scripts/kernel-cache.sh seed release - # continue-on-error turns the job green; say so, or a cache that never - # seeds goes unnoticed while every build compiles the kernel. - - name: Report a failed seed - if: steps.seed.outcome == 'failure' - run: | - msg="The kernel cache seed failed; this release builds the kernel itself. See the step above." - echo "::warning title=Kernel cache not seeded::${msg}" - echo "${msg}" >> "$GITHUB_STEP_SUMMARY" - kernel-cache-dev: if: github.ref == 'refs/heads/main' # CASD_CLIENT_KEY lives in this environment, which only main may use. @@ -78,18 +68,8 @@ jobs: - name: Build and push the dev kernel cache unless it exists id: seed - continue-on-error: true env: CASD_CLIENT_CERT: ${{ vars.CASD_CLIENT_CERT }} CASD_CLIENT_KEY: ${{ secrets.CASD_CLIENT_KEY }} run: bash scripts/kernel-cache.sh seed dev - # continue-on-error turns the job green; say so, or a cache that never - # seeds goes unnoticed while every build compiles the kernel. - - name: Report a failed seed - if: steps.seed.outcome == 'failure' - run: | - msg="The dev kernel cache seed failed; pull requests and the nightly build compile the kernel until a release seeds it. See the step above." - echo "::warning title=Kernel cache not seeded::${msg}" - echo "${msg}" >> "$GITHUB_STEP_SUMMARY" - diff --git a/docs/skills/ci-tooling.md b/docs/skills/ci-tooling.md index 00e63c24..f2cfbdf8 100644 --- a/docs/skills/ci-tooling.md +++ b/docs/skills/ci-tooling.md @@ -411,9 +411,11 @@ version) and the NVIDIA Container Toolkit (Go); the driver sysext adds about With no signing secrets and that one certificate staged as the only file of `files/boot-keys/modules/` (`seed` refuses anything else there: that directory's import is pushed with the kernel), each builds FSDK's kernel, - Go and `bootstrap/build/gcc-stage2.bst`, plus the Brew machine. BuildStream - pulls or rebuilds payloads, then `bst artifact push --deps all` replicates - upstream artifacts into `cache.projectbluefin.io:11002`; metadata never skips seeding. + Go and `bootstrap/build/gcc-stage2.bst`, plus the Brew machine. + `bst build --deps all` materializes their whole key-free closure; cached + targets otherwise leave build-only dependencies uncached. Then + `bst artifact push --deps all` replicates upstream artifacts into + `cache.projectbluefin.io:11002`; metadata never skips seeding. The push endpoint takes mTLS: its client certificate is the repository variable `CASD_CLIENT_CERT` and its key the `bst-cache` environment secret `CASD_CLIENT_KEY`, given to that step only and written to a gitignored `.casd.*/` directory that the script @@ -431,8 +433,8 @@ version) and the NVIDIA Container Toolkit (Go); the driver sysext adds about `bluefin-server/keys/boot-keys.bst` is anywhere in the graph it builds, and the job holds no signing secret. A content grep is no guard here: FSDK sources (Go's TLS test data and others) carry 307 PEM private keys. - The seed step is `continue-on-error`; failures are posted as a warning and - step summary, without preventing an independently verified release. + The independent warming workflow fails visibly on seed errors; its result + does not gate image building or publication. The former kernel/Go-only seed took 44 min and 15 GB on 16+ CPUs. Kernel, Go, GCC, Brew or their dependency changes reseed the affected targets. - **No other cache push.** `bluefin-server/keys/boot-keys.bst` imports diff --git a/scripts/kernel-cache.sh b/scripts/kernel-cache.sh index 371628aa..b3e5d267 100755 --- a/scripts/kernel-cache.sh +++ b/scripts/kernel-cache.sh @@ -129,8 +129,9 @@ seed() { echo "kernel-cache: cannot reach ${PUSH_URL}; refusing to build without pushing" >&2 exit 1 fi - just bst build "${ELEMENTS[@]}" - # Builds need not push dependencies pulled from upstream caches. + # Cached targets can leave build-only dependencies uncached; push --deps + # all requires those artifacts too, including the certificate import. + just bst build --deps all "${ELEMENTS[@]}" just bst artifact push --deps all "${ELEMENTS[@]}" echo "kernel-cache: ${variant}: pushed ${ELEMENTS[*]} to ${PUSH_URL}" } diff --git a/tests/unit/test_kernel_cache.py b/tests/unit/test_kernel_cache.py index 95d7d3f1..09ac9e44 100644 --- a/tests/unit/test_kernel_cache.py +++ b/tests/unit/test_kernel_cache.py @@ -187,14 +187,6 @@ def test_seed_pushes_with_the_client_certificate(checkout: Path, env: dict[str, result = run(checkout, env) assert result.returncode == 0, result.stderr log = Path(env["LOG"]) - assert (log / "built").read_text().split() == [ - "bst", - "build", - "freedesktop-sdk.bst:components/linux.bst", - "freedesktop-sdk.bst:components/go.bst", - "freedesktop-sdk.bst:bootstrap/build/gcc-stage2.bst", - "fsdk-containers.bst:oci/brew-nspawn.bst", - ] conf = (log / "buildstream.conf").read_text() for kind in ("artifacts:", "source-caches:"): section = conf.split(kind, 1)[1] diff --git a/tests/unit/test_release_workflow.py b/tests/unit/test_release_workflow.py index bfd5136a..2b2dd1cd 100644 --- a/tests/unit/test_release_workflow.py +++ b/tests/unit/test_release_workflow.py @@ -182,9 +182,7 @@ def test_boot_test_result_is_the_one_gate_of_every_bucket() -> None: @pytest.mark.parametrize("seeder", ["kernel-cache", "kernel-cache-dev"]) def test_a_failed_kernel_cache_seed_is_reported(seeder: str) -> None: seed = next(s for s in CACHE_JOBS[seeder]["steps"] if s.get("id") == "seed") - assert seed["continue-on-error"] is True - report = next(s for s in CACHE_JOBS[seeder]["steps"] if s.get("if") == "steps.seed.outcome == 'failure'") - assert "::warning" in report["run"] and "GITHUB_STEP_SUMMARY" in report["run"] + assert seed.get("continue-on-error", False) is False def test_release_uses_the_job_token_only() -> None: From c662117238a19542a083dafde127d1f80b3a6574 Mon Sep 17 00:00:00 2001 From: castrojo Date: Sat, 14 Nov 2026 17:54:37 -0500 Subject: [PATCH 5/8] test(cache): retain the publisher dependency-selection contract Parse the emitted build selection and require dependency mode all plus the four published targets. Do not pin target ordering or long-option spelling. This guards the cached-parent regression verified by the native two-CAS proof. Production code is unchanged; the focused kernel-cache suite passed all 21 cases. Assisted-by: GPT-6.1 via GitHub Copilot Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Signed-off-by: castrojo --- tests/unit/test_kernel_cache.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/tests/unit/test_kernel_cache.py b/tests/unit/test_kernel_cache.py index 09ac9e44..91992716 100644 --- a/tests/unit/test_kernel_cache.py +++ b/tests/unit/test_kernel_cache.py @@ -12,6 +12,7 @@ INSECURE dev certificate, never its private key. """ +import argparse import os import shutil import subprocess @@ -187,6 +188,17 @@ def test_seed_pushes_with_the_client_certificate(checkout: Path, env: dict[str, result = run(checkout, env) assert result.returncode == 0, result.stderr log = Path(env["LOG"]) + parser = argparse.ArgumentParser() + parser.add_argument("--deps") + parser.add_argument("elements", nargs="+") + build = parser.parse_args((log / "built").read_text().split()[2:]) + assert build.deps == "all" + assert set(build.elements) == { + "freedesktop-sdk.bst:components/linux.bst", + "freedesktop-sdk.bst:components/go.bst", + "freedesktop-sdk.bst:bootstrap/build/gcc-stage2.bst", + "fsdk-containers.bst:oci/brew-nspawn.bst", + } conf = (log / "buildstream.conf").read_text() for kind in ("artifacts:", "source-caches:"): section = conf.split(kind, 1)[1] From 3790eaac1793ed24bbac4a8a6d8f61f556dd6967 Mon Sep 17 00:00:00 2001 From: castrojo Date: Sat, 14 Nov 2026 20:00:41 -0500 Subject: [PATCH 6/8] fix: seed expensive unsigned module builds The observed warm-kernel image build still compiled OpenZFS for 15m15s and NVIDIA modules for 7m44s. Seed their key-free compiler outputs and full dependency closures; keep signing stages private. Assisted-by: GPT-6.1 via GitHub Copilot Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Signed-off-by: castrojo --- docs/skills/ci-tooling.md | 7 ++++--- scripts/kernel-cache.sh | 4 +++- tests/unit/test_kernel_cache.py | 2 ++ 3 files changed, 9 insertions(+), 4 deletions(-) diff --git a/docs/skills/ci-tooling.md b/docs/skills/ci-tooling.md index f2cfbdf8..9163cddf 100644 --- a/docs/skills/ci-tooling.md +++ b/docs/skills/ci-tooling.md @@ -397,7 +397,7 @@ version) and the NVIDIA Container Toolkit (Go); the driver sysext adds about (`elements/`, `files/`, `include/`, `patches/`, `plugins/`, `scripts/`, `tests/fixtures/`, `project.conf`, `Justfile`, `build.yml`) would skip. A skipped job reports as passing, so its required check does not hold it. -- **Key-free kernel cache in the project CAS.** Two jobs in `cache-warm.yml` +- **Key-free build cache in the project CAS.** Two jobs in `cache-warm.yml` run on pushes to `main` or a manual dispatch on `main`: - `kernel-cache` runs `seed release` with the committed release certificate (`files/release-keys/linux-module-cert.crt`). @@ -411,7 +411,8 @@ version) and the NVIDIA Container Toolkit (Go); the driver sysext adds about With no signing secrets and that one certificate staged as the only file of `files/boot-keys/modules/` (`seed` refuses anything else there: that directory's import is pushed with the kernel), each builds FSDK's kernel, - Go and `bootstrap/build/gcc-stage2.bst`, plus the Brew machine. + Go, GCC stage 2, Brew and unsigned ZFS/NVIDIA compiler outputs. Signing stages + stay excluded; rotating signing keys does not rebuild those modules. `bst build --deps all` materializes their whole key-free closure; cached targets otherwise leave build-only dependencies uncached. Then `bst artifact push --deps all` replicates upstream artifacts into @@ -436,7 +437,7 @@ version) and the NVIDIA Container Toolkit (Go); the driver sysext adds about The independent warming workflow fails visibly on seed errors; its result does not gate image building or publication. The former kernel/Go-only seed took 44 min and 15 GB on 16+ CPUs. - Kernel, Go, GCC, Brew or their dependency changes reseed the affected targets. + Changes to these targets or their dependencies reseed the affected artifacts. - **No other cache push.** `bluefin-server/keys/boot-keys.bst` imports `files/boot-keys/`, which on `main` holds the Secure Boot, module-signing and sysupdate private keys, and the image, UKIs, `kernel-modules.bst`, diff --git a/scripts/kernel-cache.sh b/scripts/kernel-cache.sh index b3e5d267..43d5495b 100755 --- a/scripts/kernel-cache.sh +++ b/scripts/kernel-cache.sh @@ -1,5 +1,5 @@ #!/usr/bin/env bash -# Key-free BuildStream cache of FSDK's kernel, Go, GCC and the Brew machine. +# Key-free BuildStream cache of the SDK, Brew and unsigned ZFS/NVIDIA builds. # # CASD_CLIENT_CERT= CASD_CLIENT_KEY= kernel-cache.sh seed release|dev # @@ -40,6 +40,8 @@ ELEMENTS=( freedesktop-sdk.bst:components/go.bst freedesktop-sdk.bst:bootstrap/build/gcc-stage2.bst fsdk-containers.bst:oci/brew-nspawn.bst + zfs/openzfs.bst + nvidia/nvidia-open-595.bst ) KEYS_ELEMENT=bluefin-server/keys/boot-keys.bst PUSH_URL=https://cache.projectbluefin.io:11002 diff --git a/tests/unit/test_kernel_cache.py b/tests/unit/test_kernel_cache.py index 91992716..2efbe847 100644 --- a/tests/unit/test_kernel_cache.py +++ b/tests/unit/test_kernel_cache.py @@ -198,6 +198,8 @@ def test_seed_pushes_with_the_client_certificate(checkout: Path, env: dict[str, "freedesktop-sdk.bst:components/go.bst", "freedesktop-sdk.bst:bootstrap/build/gcc-stage2.bst", "fsdk-containers.bst:oci/brew-nspawn.bst", + "zfs/openzfs.bst", + "nvidia/nvidia-open-595.bst", } conf = (log / "buildstream.conf").read_text() for kind in ("artifacts:", "source-caches:"): From e3163dec708ffc4a52325c62738409a1ce283a5b Mon Sep 17 00:00:00 2001 From: castrojo Date: Sat, 14 Nov 2026 20:09:05 -0500 Subject: [PATCH 7/8] fix: seed systemd outside the Brew dependency closure The native seed-graph check proved Ruby is already in the Brew closure, but systemd-base is absent. Add the measured 11m18s compiler target explicitly instead of assuming it is transitively seeded. Assisted-by: GPT-6.1 via GitHub Copilot Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Signed-off-by: castrojo --- docs/skills/ci-tooling.md | 4 ++-- scripts/kernel-cache.sh | 1 + tests/unit/test_kernel_cache.py | 1 + 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/docs/skills/ci-tooling.md b/docs/skills/ci-tooling.md index 9163cddf..c19e08ea 100644 --- a/docs/skills/ci-tooling.md +++ b/docs/skills/ci-tooling.md @@ -411,8 +411,8 @@ version) and the NVIDIA Container Toolkit (Go); the driver sysext adds about With no signing secrets and that one certificate staged as the only file of `files/boot-keys/modules/` (`seed` refuses anything else there: that directory's import is pushed with the kernel), each builds FSDK's kernel, - Go, GCC stage 2, Brew and unsigned ZFS/NVIDIA compiler outputs. Signing stages - stay excluded; rotating signing keys does not rebuild those modules. + Go, GCC stage 2, systemd-base, Brew and unsigned ZFS/NVIDIA compiler outputs. + Signing stages stay excluded; rotating signing keys does not rebuild modules. `bst build --deps all` materializes their whole key-free closure; cached targets otherwise leave build-only dependencies uncached. Then `bst artifact push --deps all` replicates upstream artifacts into diff --git a/scripts/kernel-cache.sh b/scripts/kernel-cache.sh index 43d5495b..f495c229 100755 --- a/scripts/kernel-cache.sh +++ b/scripts/kernel-cache.sh @@ -39,6 +39,7 @@ ELEMENTS=( freedesktop-sdk.bst:components/linux.bst freedesktop-sdk.bst:components/go.bst freedesktop-sdk.bst:bootstrap/build/gcc-stage2.bst + freedesktop-sdk.bst:components/systemd-base.bst fsdk-containers.bst:oci/brew-nspawn.bst zfs/openzfs.bst nvidia/nvidia-open-595.bst diff --git a/tests/unit/test_kernel_cache.py b/tests/unit/test_kernel_cache.py index 2efbe847..9da0e1e8 100644 --- a/tests/unit/test_kernel_cache.py +++ b/tests/unit/test_kernel_cache.py @@ -197,6 +197,7 @@ def test_seed_pushes_with_the_client_certificate(checkout: Path, env: dict[str, "freedesktop-sdk.bst:components/linux.bst", "freedesktop-sdk.bst:components/go.bst", "freedesktop-sdk.bst:bootstrap/build/gcc-stage2.bst", + "freedesktop-sdk.bst:components/systemd-base.bst", "fsdk-containers.bst:oci/brew-nspawn.bst", "zfs/openzfs.bst", "nvidia/nvidia-open-595.bst", From 6ca1f0c19941d166b25ecc2e2f77cb3bfcc5ba70 Mon Sep 17 00:00:00 2001 From: castrojo Date: Sat, 14 Nov 2026 20:12:49 -0500 Subject: [PATCH 8/8] fix: remove the invalid public systemd-base seed root The measured compiler is components/_private/systemd-base.bst, not components/systemd-base.bst. Restore the valid six-root selection and verify the actual compiler in its transitive graph. Assisted-by: GPT-6.1 via GitHub Copilot Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Signed-off-by: castrojo --- docs/skills/ci-tooling.md | 4 ++-- scripts/kernel-cache.sh | 1 - tests/unit/test_kernel_cache.py | 1 - 3 files changed, 2 insertions(+), 4 deletions(-) diff --git a/docs/skills/ci-tooling.md b/docs/skills/ci-tooling.md index c19e08ea..d427187d 100644 --- a/docs/skills/ci-tooling.md +++ b/docs/skills/ci-tooling.md @@ -411,8 +411,8 @@ version) and the NVIDIA Container Toolkit (Go); the driver sysext adds about With no signing secrets and that one certificate staged as the only file of `files/boot-keys/modules/` (`seed` refuses anything else there: that directory's import is pushed with the kernel), each builds FSDK's kernel, - Go, GCC stage 2, systemd-base, Brew and unsigned ZFS/NVIDIA compiler outputs. - Signing stages stay excluded; rotating signing keys does not rebuild modules. + Go, GCC stage 2, Brew and unsigned ZFS/NVIDIA outputs. Their full closure + includes Ruby and systemd's base build, but excludes module-signing stages. `bst build --deps all` materializes their whole key-free closure; cached targets otherwise leave build-only dependencies uncached. Then `bst artifact push --deps all` replicates upstream artifacts into diff --git a/scripts/kernel-cache.sh b/scripts/kernel-cache.sh index f495c229..43d5495b 100755 --- a/scripts/kernel-cache.sh +++ b/scripts/kernel-cache.sh @@ -39,7 +39,6 @@ ELEMENTS=( freedesktop-sdk.bst:components/linux.bst freedesktop-sdk.bst:components/go.bst freedesktop-sdk.bst:bootstrap/build/gcc-stage2.bst - freedesktop-sdk.bst:components/systemd-base.bst fsdk-containers.bst:oci/brew-nspawn.bst zfs/openzfs.bst nvidia/nvidia-open-595.bst diff --git a/tests/unit/test_kernel_cache.py b/tests/unit/test_kernel_cache.py index 9da0e1e8..2efbe847 100644 --- a/tests/unit/test_kernel_cache.py +++ b/tests/unit/test_kernel_cache.py @@ -197,7 +197,6 @@ def test_seed_pushes_with_the_client_certificate(checkout: Path, env: dict[str, "freedesktop-sdk.bst:components/linux.bst", "freedesktop-sdk.bst:components/go.bst", "freedesktop-sdk.bst:bootstrap/build/gcc-stage2.bst", - "freedesktop-sdk.bst:components/systemd-base.bst", "fsdk-containers.bst:oci/brew-nspawn.bst", "zfs/openzfs.bst", "nvidia/nvidia-open-595.bst",