Files

sneak 223c520110

check / check (push) Successful in 56s

Details

Cache-bust the make check layer via CHECK_EPOCH (closes #23 )

script/cibuild was a bare `docker build .`, and the Dockerfile did
`COPY . .` then `RUN make check`. COPY is keyed on content, so on an
unchanged tree Docker served the check layer from cache: the checks
never executed, no Hugo or prettier output appeared, and the build still
exited 0. A gate that reports success without running is worse than no
gate, because it is trusted -- three separate reviewers in this repo
have been fooled by it.

The Dockerfile now declares `ARG CHECK_EPOCH` immediately below
`COPY . .`, guards it, and expands it into the check command:

    ARG CHECK_EPOCH
    RUN [ -n "$CHECK_EPOCH" ] || exit 1
    RUN echo "check epoch: ${CHECK_EPOCH}" && make check

script/cibuild and script/docker both generate the value identically and
pass it. Every element is load-bearing:

- No default value. A default is a constant, and a constant is a stable
  cache key -- the defect unchanged.
- Placed below `COPY . .`. Everything above keeps caching, so the
  script/bootstrap layer, which compiles Hugo from source, is not
  rebuilt. Whole-build `--no-cache` would have discarded it and blown
  the five-minute budget for no benefit.
- The guard. An unset ARG is the empty string, which is also a stable
  cache key, so without it a bare `docker build .` still collects the
  false green. Failed steps are never cached, so it fails on every such
  invocation rather than only the first. This is why script/docker had
  to be updated too: the guard makes passing the argument mandatory for
  every entrypoint that builds the image.
- The value expanded into the RUN. Hardening rather than the fix: the
  bare unreferenced-ARG form does work, but expansion makes the cache
  miss contractual rather than dependent on BuildKit's handling of an
  unreferenced ARG, and puts the epoch in the build log. The guard also
  references the value, so there are two independent invalidation
  points, not one.
- `epoch="$(date +%s%N)$$"` on its own line rather than inlined into the
  argument list. A command substitution that fails inside an argument
  does not trip `set -e`, so the inline form would quietly pass an empty
  string and restore the cached false green. `%N` keeps concurrent
  invocations distinct; `$$` covers busybox date, which drops `%N`
  silently and still exits 0.

ARG is stage-scoped and must be redeclared in every stage that runs
checks. This image is single-stage, so one declaration is complete.

This is the shape settled upstream in the prompts repo, where it has not
merged to main yet, so it may need re-syncing later.

Verified: two consecutive script/cibuild runs on an unchanged tree both
executed the checks (two Hugo builds and the prettier line in each,
15s then 6s) with `RUN script/bootstrap` and `COPY . .` both CACHED in
the second -- the validity control that rules out a cache eviction
between them. A constant-epoch counterfactual restored the cached false
green, confirming the varying value is what does the work. A bare
`docker build .` now fails on the guard, and fails again on immediate
repeat. A planted prettier failure failed the build with exit 1. `make
docker` and `make check` both pass.

2026-08-09 15:51:09 +00:00

2.5 KiB

Raw Blame History

lora.vegas

Las Vegas Meshtastic and LoRa community website.

About

This site provides information about the Las Vegas mesh networking community, including:

Mesh channel configurations
Community coordination (Discord, Signal)
Meetup information
Local resources

Contributing

To contribute to this site, contact sneak@sneak.berlin for git repository access.

Technical Details

This is a static site built with Hugo. The site is deployed automatically via GitHub Actions.

Local Development

hugo server

Visit http://localhost:1313 to preview.

Build

hugo

Output will be in the public/ directory.

Entrypoints

This repository adheres to the Scripts to Rule Them All standard: normalized scripts in script/ are the entrypoints for the development workflow, and the Makefile targets are thin shims that call them. We provide:

script/bootstrap — install all build dependencies (git, make, go, hugo, node/npm) idempotently. Hugo is pinned to an exact version and installed with go install, which verifies it against sum.golang.org; the version is the HUGO_VERSION constant at the top of the script
script/setup — prepare a fresh clone: run script/bootstrap and install the git pre-commit hook
script/test — the correctness check: a clean hugo --minify production build
script/lint — a clean build that surfaces broken links and path collisions
script/fmt — format the repo's own top-level markdown docs with prettier
script/fmt-check — check that formatting (read-only)
script/check — run script/test, script/lint, then script/fmt-check; modifies no tracked files
script/docker — build the Docker image tagged with the project name
script/cibuild — the CI build; the Dockerfile runs make check
script/install-precommit — install the git pre-commit hook that runs script/check

Build the image through script/cibuild or script/docker only. Both pass a per-invocation CHECK_EPOCH build argument that the Dockerfile requires, so the make check layer can never be served from cache — without it Docker returns a green it did not earn. A bare docker build . fails closed on the Dockerfile's CHECK_EPOCH guard rather than caching its way to a false success.

A convenience make serve target runs hugo server for local preview.

License

Content is provided as-is for community use.

2.5 KiB Raw Blame History