* ci(bazel): add advisory Bazel workflow and setup-bazel action Add .github/workflows/bazel.yml, a side-by-side lane that runs `bazel test //... --config=ci` (PR Core parity) on pull_request, merge_group, push to main and workflow_dispatch. It is advisory: not in ci-gate's CI_GATE_REQUIRED. .github/actions/setup-bazel installs a sha256-pinned Bazelisk (Bazel from .bazelversion), restores the runner cache (--disk_cache and --repository_cache only), and writes a CI bazelrc outside the workspace and outside the cached directory. Remote execution is enabled only when BAZEL_REMOTE_EXECUTOR, RBE_TLS_CERT and RBE_TLS_KEY are all set (base64 PEM cert/key; optional RBE_TLS_CA, RBE_INSTANCE); none set (fork PRs, or workflow_dispatch rbe=off) runs locally; a partial set fails. The endpoint and its bare host are masked. The rc logic lives in write-bazelrc.sh so it is testable offline. The runner cache is saved only by push-to-main runs under a run-unique key and restored by prefix, so it never freezes at its first save and PRs do not churn the quota. The job also reports the tier (T1/T2/local) and wall time in the step summary, runs tools/bazel/critpath.py against the profile, and checks BUILD drift with make bazel-sync-check plus make bazel-sync and a clean git status. tools/bazel/critpath.py reports the critical path as the sum of the chained "critical path component" events rather than the longest one (a cold race build: 395s over 75 components, where the single-component version printed 69s and a false scheduling gap), lists the longest members and Bazel's processes: cache line, and checks a report-only budget (warning annotation, exit 0) unless --enforce is given. scripts/ci_workflow_test.go covers the new lane: not wired into any gate, every action SHA-pinned to the repo's released SHAs, no monolithic actions/cache, no unbounded apt-get, the cache topology, secrets only reaching setup-bazel, --profile after `test`, and the rc writer's none/partial/full/invalid-PEM/secret-dir-in-workspace behaviour. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> * ci(bazel): check go test / Bazel test equivalence in the Bazel lane tools/bazel/equivalence.py compares the Go tests `bazel test //... --config=ci` ran with the ones pr.yml's go test lanes run, so a tag filter, a stray manual tag, a package without a go_test target, or a shard that runs zero tests cannot shrink the Bazel lane while it stays green: - package set: every package `go list -race -tags gms_pure_go` reports with test files has a go_test target (bazel query); - test-name set: every top-level TestXxx in the files go list selects (minus ^TestEmbedded, as PR Core skips) appears as a testcase in the test.xml of a go_test target this invocation tested (from the BEP); runtime skips count as run. Tests Bazel ran that go test would not are divergences too. Expected differences go in tools/bazel/equivalence_allowlist.txt, one justified line each (empty today); unused entries are reported. Results go to the step summary; the full listing with --details. .bazelrc test:ci now sets GO_TEST_WRAP_TESTV=1 (rules_go lists passing tests in test.xml only under -test.v) and downloads test.xml despite --remote_download_minimal. The Bazel workflow runs the check after the critical-path report, and nightly.yml calls the workflow (suite "bazel", and on schedule) with the full listing. Verified locally against a remote --config=ci run: 103 packages and 8843 tests on both sides. Tagging //internal/gitignore:gitignore_test manual keeps `bazel test` green but fails the check, listing its two tests. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> * test(fs): run RepoContextAndRole from its own git repo The test relied on its working directory being inside a git checkout to make BEADS_DIR external to the CWD repo. Under Bazel the working directory is the runfiles tree, not a git repository, so RepoContext failed with "not a git repository" and the test skipped itself. Create a second temporary repo and chdir into it instead; go test keeps passing and Bazel now runs the assertions. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> * fix(bazel): fail equivalence on tests Bazel skips but go test passes The equivalence docstring claimed runtime skips count as run because go test skips them the same way. It does not: against PR Core's go test -json on the same commit, 11 tests passed under go test and skipped under Bazel while the check printed ok with an empty allowlist. - equivalence.py --go-test-json compares per-test status with the Bazel test.xml: passed under go test and skipped under Bazel is a divergence; other status differences are listed, not failed. The in-job (PR) run cannot see skip divergences and says so. - The allowlist gains a `skip` kind (`<pkg> <test> skip # why`, the justification still mandatory) and lists the 10 intentional skips: cmd/bd TestGOMODCACHENotUnderTestHome and TestZZStdioNotLeaked, and the scripts policy tests that walk the source checkout. The eleventh, fs TestContextRepository_RepoContextAndRole, is fixed in the test. - scripts/ci/pr-core.sh writes `go test -json` to BEADS_PR_CORE_GO_TEST_JSON when set (same flags otherwise). - nightly.yml runs that in a new job, uploads the JSON, and calls bazel.yml with go-test-json-artifact, which downloads it and passes --go-test-json to the equivalence step. Verified on a remote `bazel test //... --config=ci` run: ok with the allowlist; a TEST_SRCDIR-only t.Skip injected into internal/gitignore TestAppendLines fails the check (and passes the name-only in-job check, as documented). Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> * ci(bazel): freeze the runner cache per lock, mask key material, tighten policy Runner cache: every push to main saved ~2.3 GB (repository cache, disk cache, Bazelisk) under a run-unique key, on a repo already over its Actions cache quota. The cache now holds only the repository cache and Bazelisk, whose content is fixed by .bazelversion and MODULE.bazel.lock: exact key bazel-repo-v2-<os>-<hash>, restore falls back to the previous lock's entry, and only a push to main that missed the key saves. No --disk_cache in either mode (remote runs have the remote cache; local runs never used it). About 2 GB per lock change. Credentials: - write-bazelrc.sh masks every non-armor line of each decoded PEM (cert, key, CA). GitHub only masks the base64 value as stored. The CA used to be decoded inside the rc redirect, so its mask commands would have gone into the rc; it is decoded first now. - The CI rc sets build:remote-exec --noremote_upload_local_results, so CI never writes locally executed (PR-code) results into the shared action cache. Developer rcs keep Bazel's default. - RBE_INSTANCE stays optional; an empty one is a ::warning. - bazel.yml's header states the accepted risk: same-repo PR code runs with the RBE client certificate (as in gascity); forks never get it; what is in place and what is pending a human decision. Policy tests (each proved with a scratch mutation that now fails): triggers must be exactly pull_request, merge_group, push, workflow_dispatch and workflow_call (no pull_request_target); secrets may appear only in the setup-bazel step's env, not in workflow or job env, run, with or if; no continue-on-error anywhere in bazel.yml or setup-bazel; the cache-save if is matched exactly; the critical-path and equivalence steps must end with the bare script call and the test step with exit "$rc", with no exit 0, || true, || :, ; true, set +e or trap. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> * docs(ci): record the same-repo RBE decision in bazel.yml Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> * fix(ci): bazel wrapper version check; keep go-test prose out of the build-tag scan The wrapper prepends --bazelrc, so 'bazel --version' reached the server as an unknown startup option; ask bazelisk directly. check-build-tags matched 'go test' in workflow prose and step names. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> * fix(ci): run the RBE lane on Blacksmith runners; mask the executor's IPs GitHub-hosted runners are refused by the remote-execution edge; the Blacksmith pool (as in gascity) is admitted and does not count against GitHub's concurrent-job cap. Forks and rbe=off keep ubuntu-latest. Bazel prints the resolved executor address in connection errors, so mask every address the endpoint host resolves to. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> * ci(bazel): target rbe-west (instance oss) behind RBE_WEST_WORKERS The original edge does not admit CI runners. Mirror gascity: remote execution uses secrets.RBE_WEST_EXECUTOR and instance oss when the repo variable RBE_WEST_WORKERS is true; same-repo runs are skipped until then instead of failing, while forks and rbe=off still run locally. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
44 lines
1.8 KiB
Bash
Executable file
44 lines
1.8 KiB
Bash
Executable file
#!/usr/bin/env bash
|
|
# Required fast PR Go test contract.
|
|
|
|
set -euo pipefail
|
|
|
|
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
|
REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
|
|
|
|
# shellcheck source=../.buildflags
|
|
source "$REPO_ROOT/.buildflags"
|
|
# shellcheck source=lib/timing.sh
|
|
source "$REPO_ROOT/scripts/ci/lib/timing.sh"
|
|
# shellcheck source=lib/test-env.sh
|
|
source "$REPO_ROOT/scripts/ci/lib/test-env.sh"
|
|
|
|
cd "$REPO_ROOT"
|
|
|
|
beads_test_env_enter
|
|
|
|
GO_TEST_PKG_PARALLEL="${GO_TEST_PKG_PARALLEL:-4}"
|
|
GO_TEST_PARALLEL="${GO_TEST_PARALLEL:-4}"
|
|
|
|
# Without an explicit -timeout every package gets Go's 10m default, and ./cmd/bd
|
|
# has outgrown it: measured through this wrapper it takes 572s, which leaves 28s
|
|
# — under 5% — of margin. Runner variance eats that, and the package then dies on
|
|
# the alarm at 600.3s/600.7s (two consecutive runs on #6090; #6038 squeaked in
|
|
# just under). No single test is at fault, so the panic names whichever one was
|
|
# in flight and reads like a hang when it is really the whole package running out
|
|
# of clock. 30m is what every other -race lane here already gives this same code:
|
|
# main.yml's integration package and cmd/bd shards, ci-measurements.yml,
|
|
# nightly.yml. Splitting or de-slowing cmd/bd is the real fix and belongs on main
|
|
# — this only stops the clock from being the thing that fails.
|
|
# BEADS_PR_CORE_GO_TEST_JSON=<file>: same run, `go test -json` output to <file>
|
|
# (nightly.yml feeds it to tools/bazel/equivalence.py --go-test-json).
|
|
go_test() {
|
|
if [[ -n "${BEADS_PR_CORE_GO_TEST_JSON:-}" ]]; then
|
|
go test -json "$@" >"$BEADS_PR_CORE_GO_TEST_JSON"
|
|
else
|
|
go test "$@"
|
|
fi
|
|
}
|
|
|
|
ci_time "pr-core go test" -- \
|
|
go_test -p "$GO_TEST_PKG_PARALLEL" -parallel "$GO_TEST_PARALLEL" -race -short -timeout=30m -skip '^TestEmbedded' ./...
|