Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
13 changes: 13 additions & 0 deletions .github/workflows/ci.yaml
Original file line number Diff line number Diff line change
Expand Up @@ -54,6 +54,10 @@ jobs:
# only way to know it still builds is to build it on every change.
container:
runs-on: ubuntu-latest
permissions:
contents: read
# Only to publish the environment below, and only on main.
packages: write
steps:
- name: checkout code
uses: actions/checkout@v7
Expand All @@ -64,6 +68,15 @@ jobs:
- name: make docker_test
run: make docker_test

# Published only after the suite has passed in it, and only from main:
# an image nobody has run is not one to hand to anybody, and a pull
# request's image is a proposal rather than the environment.
- name: publish the image
if: github.event_name == 'push' && github.ref == 'refs/heads/main'
run: make push_image
env:
GHCR_TOKEN: ${{ secrets.GITHUB_TOKEN }}

# Formatting and linting are properties of the repository, not of any one
# Go version, so they run once on the newest.
checks:
Expand Down
19 changes: 19 additions & 0 deletions Makefile
Original file line number Diff line number Diff line change
@@ -1,5 +1,7 @@
GCI_VERSION := v0.14.0
IMAGE ?= prescript-env:dev
PUBLISHED_IMAGE ?= ghcr.io/rjnienaber/prescript-env
PUBLISHED_REF ?= $(PUBLISHED_IMAGE):latest
VINTBAS_RELEASE := vintbas-1.0.3-1
VINTBAS_ASSET := vintbas-$(shell uname -s | tr '[:upper:]' '[:lower:]')-$(shell uname -m)
VINTBAS_URL := https://github.com/rjnienaber/prescript/releases/download/$(VINTBAS_RELEASE)/$(VINTBAS_ASSET)
Expand Down Expand Up @@ -40,6 +42,23 @@ tape:
image:
docker build --platform linux/amd64 -t $(IMAGE) docker

# Publishing is what turns "the same Dockerfile" into "the same bytes": a
# rebuild pins the same toolchains but produces its own layers, and only a
# digest is a name a bug report can carry. CI pushes on main; this is here so
# the same thing can be done by hand.
.PHONY: push_image
push_image:
./docker/publish.sh $(IMAGE) $(PUBLISHED_IMAGE)

# Pulls the published environment and gives it the local name, so `make
# docker_test` and docker/run.sh use it without knowing where it came from.
# PUBLISHED_REF takes a digest as readily as a tag, and a digest is what to use
# when reproducing someone else's run.
.PHONY: pull_image
pull_image:
docker pull --platform linux/amd64 $(PUBLISHED_REF)
docker tag $(PUBLISHED_REF) $(IMAGE)

# The same checks CI runs, run in the same image CI runs them in.
.PHONY: docker_test
docker_test:
Expand Down
8 changes: 5 additions & 3 deletions README.md
Original file line number Diff line number Diff line change
Expand Up @@ -268,7 +268,8 @@ pty takes anything the program started with it.
make dependencies # build tooling, plus the vintbas interpreter the examples run against
make prepush # format, lint, test, build, examples

make image # the pinned environment
make pull_image # the pinned environment, as published
make image # or build it locally
make docker_test # the suite, inside it
```

Expand All @@ -288,8 +289,9 @@ Randomness is not the only thing that moves. Interpreter versions, locale,
timezone, terminal size, hash seeds and address layout change what a program
prints without changing what it does, and a difference between two ports means
nothing if the two ran in different worlds. `docker/` holds a pinned
environment that fixes all of them, used by CI and available locally; see
[docs/container.md](docs/container.md).
environment that fixes all of them, published to
`ghcr.io/rjnienaber/prescript-env` so CI and a developer run the same bytes
rather than the same recipe; see [docs/container.md](docs/container.md).

### Get in touch
* Slack: Find me as @rjnienaber on https://gophers.slack.com/
Expand Down
67 changes: 67 additions & 0 deletions docker/publish.sh
Original file line number Diff line number Diff line change
@@ -0,0 +1,67 @@
#!/usr/bin/env bash
#
# Publishes the pinned environment so everyone runs the same bytes rather than
# their own build of the same Dockerfile.
#
# Everything in the Dockerfile is pinned, but a rebuild still produces its own
# layers: apt indexes move, timestamps differ, and the two images agree on
# every version without being the same image. That is enough for the toolchains
# to match and not enough to name in a bug report, which is what a digest is
# for.
#
# docker/publish.sh [local image] [remote repository]
#
# Set GHCR_TOKEN to log in first; without it the daemon's existing credentials
# are used, which is what a developer pushing by hand already has.
set -euo pipefail

LOCAL_IMAGE="${1:-prescript-env:dev}"
REMOTE_IMAGE="${2:-ghcr.io/rjnienaber/prescript-env}"

if ! docker image inspect "$LOCAL_IMAGE" > /dev/null 2>&1; then
echo "$LOCAL_IMAGE has not been built; run 'make image' first" >&2
exit 1
fi

if [ -n "${GHCR_TOKEN:-}" ]; then
echo "$GHCR_TOKEN" |
docker login ghcr.io --username "${GHCR_USER:-${GITHUB_ACTOR:-x}}" --password-stdin
fi

# A commit tag as well as latest, because latest answers "what is current" and
# nothing else: a run that has to be reproduced needs a name that still means
# the same image next month.
COMMIT="${GITHUB_SHA:-$(git rev-parse HEAD)}"
COMMIT_TAG="git-${COMMIT:0:12}"

for TAG in latest "$COMMIT_TAG"; do
echo "==> pushing $REMOTE_IMAGE:$TAG"
docker tag "$LOCAL_IMAGE" "$REMOTE_IMAGE:$TAG"
docker push "$REMOTE_IMAGE:$TAG" > /dev/null
done

# The digest only exists once the registry has the image, so it is read back
# rather than computed. A push that succeeded is not worth failing over if the
# daemon declines to report one, so the tag stands in.
DIGEST="$(docker image inspect \
--format '{{range .RepoDigests}}{{println .}}{{end}}' "$REMOTE_IMAGE:$COMMIT_TAG" |
grep "^$REMOTE_IMAGE@" | head -n 1 || true)"
if [ -z "$DIGEST" ]; then
DIGEST="$REMOTE_IMAGE:$COMMIT_TAG"
fi
echo "==> published $DIGEST"

# The digest is the only part of this worth keeping, so it goes somewhere the
# run that produced it can be read from afterwards rather than only into logs
# that age out.
if [ -n "${GITHUB_STEP_SUMMARY:-}" ]; then
{
echo "### Pinned environment published"
echo
echo '```'
echo "$DIGEST"
echo '```'
echo
echo "Pull it with \`make pull_image PUBLISHED_REF=$DIGEST\`."
} >> "$GITHUB_STEP_SUMMARY"
fi
32 changes: 26 additions & 6 deletions docs/container.md
Original file line number Diff line number Diff line change
Expand Up @@ -8,7 +8,8 @@ locale, timezone, terminal size, hash seeds and address layout all change what
a program prints without changing what it does.

```
make image # build it
make pull_image # get the published one
make image # or build it yourself
make docker_test # run the suite inside it
make docker_shell # look around
```
Expand Down Expand Up @@ -80,12 +81,31 @@ timezone=UTC

Issue #18 folds both into the repro block of a generated bug report.

## What it does not do
## Where it lives

`ghcr.io/rjnienaber/prescript-env`, pushed by CI from `main` after the suite
has passed inside it. Building from the same pinned Dockerfile makes two
images agree on every version without making them the same image — apt
indexes move, timestamps differ, and the layers come out different. Pulling
removes that last gap, and gives the run a digest to be named by.

```
make pull_image # :latest
make pull_image PUBLISHED_REF=ghcr.io/rjnienaber/prescript-env@sha256:...
```

Both give the image the local name the rest of the tooling uses, so
`make docker_test` and `docker/run.sh` do not need to know which one was used.
A tag says which build; a digest says which bytes, and a digest is what to use
when reproducing someone else's run — the publishing step prints the one it
pushed, and `$PRESCRIPT_IMAGE` reports the one a run is actually inside.

The image is not published anywhere yet, so CI and a developer each build it
from the same pinned Dockerfile rather than pulling the same bytes. That is
enough to make the toolchains agree and not enough to make the image layers
byte-identical; publishing it is the obvious follow-up.
The package is public. Public packages on GitHub Packages carry no storage or
bandwidth charge; a private one would bill against the account's quota, and
this image is around a gigabyte. If a first publish ever creates it private,
the fix is one setting on the package, not a change here.

## What it does not do

Address-space randomisation is left on by default. Docker's default seccomp
profile permits `personality()` with a handful of arguments and
Expand Down