Files
archie/.github/workflows/deploy.yml
T
sam 64aeb6c84a fix(build): pin gofumpt and golangci-lint as one matched pair
`task fmt` formats with the standalone gofumpt and `task lint` re-checks that
formatting with the gofumpt golangci-lint vendors. `task check` runs `fmt`
then `lint` without diffing the tree, so `lint` is the only hard failure for
formatting -- and when the two versions differ, any construct they disagree on
makes the gate unsatisfiable: the standalone formatter rewrites a file one way
and lint rejects it, with nothing a contributor can run to satisfy both.

The surfaces had drifted onto three different pairs. This machine ran gofumpt
v0.7.0 against golangci-lint 2.13.2 (vendors v0.11.0), the image pinned
golangci-lint 2.12.2 (vendors v0.9.2) next to gofumpt v0.11.0, and CI
installed gofumpt@latest. `any((Trees)(nil))` in changes_test.go is the
construct that surfaced it: gofumpt <= v0.9.2 keeps the redundant parens,
>= v0.10.0 removes them.

- Dockerfile: golangci-lint 2.13.2, whose vendored gofumpt v0.11.0 now equals
  the pinned GOFUMPT_VERSION, so the image's two formatters agree.
- Dockerfile: fail the build if the pins ever diverge, rather than ship an
  image whose gate cannot pass.
- deploy.yml: gofumpt@v0.11.0 instead of @latest, which drifts ahead of
  whatever golangci-lint vendors.
- Record the invariant where an agent will meet it: AGENTS.md (CLAUDE.md) and
  the build-and-env skill, whose snapshots now name the pinned pair instead of
  calling both unpinned.
2026-09-19 18:52:10 +10:00

321 lines
13 KiB
YAML

# Builds and pushes the archied and archie-agent images to GHCR on every
# merge to main. Mirrors .gitea/workflows/deploy.yml, which remains the
# production build path against git.catlow.cloud until that's cut over.
name: deploy
on:
push:
branches: [main]
tags: ["archied/v*", "archie/v*"]
# Rapid successive pushes to main (a release commit right after its
# preceding fix, say) previously queued a full gate+build for each one,
# several minutes apiece, with no caching -- so a burst of pushes left
# three deploys racing in parallel for the same runner capacity. Only the
# last one's images matter (both jobs push :latest), so cancel a
# superseded run rather than let it fight for resources it can't use.
#
# Keyed on the commit, not github.ref: `git push --follow-tags` pushes
# main plus both archied/v* and archie/v* tags in one go, and all three
# refs point at the same commit -- on.push matches branches and tags
# both, so a single release push otherwise fires three redundant builds
# of identical content that a ref-keyed group can't see as the same work.
concurrency:
group: deploy-${{ github.sha }}
cancel-in-progress: true
permissions:
contents: read
packages: write
jobs:
gate:
runs-on: ubuntu-latest
outputs:
archied_version: ${{ steps.release_tag.outputs.archied_version }}
steps:
- name: Checkout
uses: actions/checkout@v4
with:
fetch-depth: 0
# Read the release from the commit, not from github.ref. One release
# push carries main and both tags at the same SHA, and only one of
# those refs survives the concurrency group, so a ref-derived version
# is whatever won the race. The tag at HEAD is the same either way.
- name: Resolve archied tag at HEAD
id: release_tag
run: |
version="$(git tag --points-at HEAD --list 'archied/v*' | sed 's|^archied/v||' | sort -V | tail -1)"
echo "archied_version=$version" >> "$GITHUB_OUTPUT"
if [ -n "$version" ]; then
echo "archied release at HEAD: $version"
else
echo "no archied tag at HEAD; distribution zip will be skipped"
fi
- name: Set up Go
uses: actions/setup-go@v5
with:
go-version-file: go.mod
- name: Set up Node
uses: actions/setup-node@v4
with:
node-version: "22"
# Pinned, not @latest: this gate rewrites formatting with the standalone
# gofumpt, and the agent image that gates PRs re-checks it with the
# gofumpt bundled in its golangci-lint. Those two versions must agree
# (see Dockerfile), or a PR passes here and fails there unfixably.
- name: Install gofumpt
run: go install mvdan.cc/gofumpt@v0.11.0
- name: Install protobuf tools
run: bash tools/proto.sh install
- name: Ensure contract baseline ref
run: |
if ! git show-ref --verify --quiet refs/heads/main; then
git branch main origin/main
fi
- name: Install ripgrep
run: sudo apt-get update && sudo apt-get install -y --no-install-recommends ripgrep
- name: Quality gate
run: |
gofumpt -w .
go fix ./...
bash tools/proto.sh lint
bash tools/proto.sh check
go vet ./...
go build ./...
go test ./... -count=1
- name: Vulnerability scan
run: |
go install golang.org/x/vuln/cmd/govulncheck@latest
govulncheck ./...
# The dashboard suite runs in CI too, or it only ever runs when
# someone remembers to; the Go steps above never touch it.
- name: Dashboard tests
run: |
npm ci --prefix ui || npm install --prefix ui
npm test --prefix ui
- name: Release tags must match changelogs
run: |
set -e
fail=0
for tag in $(git tag --points-at HEAD); do
case "$tag" in
archied/v*)
# Strip the "v" too: tags are archied/vX.Y.Z, changelog
# sections are "## [X.Y.Z]" (see tools/release.sh).
ver="${tag#archied/v}"
echo " archied tag $tag -> looking for [$ver] in CHANGELOG.archied.md"
grep -q "^## \\[$ver\\]" CHANGELOG.archied.md || {
echo " FAIL: CHANGELOG.archied.md has no [$ver] section"
fail=1
}
;;
archie/v*)
ver="${tag#archie/v}"
echo " archie tag $tag -> looking for [$ver] in CHANGELOG.archie.md"
grep -q "^## \\[$ver\\]" CHANGELOG.archie.md || {
echo " FAIL: CHANGELOG.archie.md has no [$ver] section"
fail=1
}
;;
esac
done
if [ $fail -ne 0 ]; then
echo
echo "A release tag points at this commit but its changelog does not"
echo "describe that version. Run: task release:prepare VERSION=<ver>"
echo "edit the generated notes, then: task release VERSION=<ver>"
exit 1
fi
if ! git tag --points-at HEAD | grep -qE 'archie' ; then
echo "::warning ::No release tags at HEAD -- images will be stamped 'dev'"
fi
build-and-push:
needs: gate
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v3
- name: Log in to GHCR
run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u "${{ github.actor }}" --password-stdin
- name: Resolve component versions
id: versions
run: |
GATEWAY_TAG="$(git tag --points-at HEAD --list 'archied/v*' | sort -V | tail -1)"
RUNTIME_TAG="$(git tag --points-at HEAD --list 'archie/v*' | sort -V | tail -1)"
GATEWAY_VERSION="${GATEWAY_TAG#archied/}"
RUNTIME_VERSION="${RUNTIME_TAG#archie/}"
[ -n "$GATEWAY_VERSION" ] || GATEWAY_VERSION=dev
[ -n "$RUNTIME_VERSION" ] || RUNTIME_VERSION=dev
# Keep the raw tag presence separate from the version fallback:
# gateway-only releases must not rebuild the runtime image as dev.
echo "gateway_tag=$GATEWAY_TAG" >> "$GITHUB_OUTPUT"
echo "runtime_tag=$RUNTIME_TAG" >> "$GITHUB_OUTPUT"
echo "gateway=$GATEWAY_VERSION" >> "$GITHUB_OUTPUT"
echo "runtime=$RUNTIME_VERSION" >> "$GITHUB_OUTPUT"
- name: Build and push archied
uses: docker/build-push-action@v6
with:
context: .
file: Dockerfile.archied
push: true
tags: ghcr.io/samcharles93/archied:latest
build-args: |
GATEWAY_VERSION=${{ steps.versions.outputs.gateway }}
RUNTIME_VERSION=${{ steps.versions.outputs.runtime }}
cache-from: type=gha,scope=archied
cache-to: type=gha,mode=max,scope=archied
- name: Build and push archie-agent
if: steps.versions.outputs.runtime_tag != ''
uses: docker/build-push-action@v6
with:
context: .
file: Dockerfile
push: true
tags: ghcr.io/samcharles93/archie-agent:latest
build-args: |
RUNTIME_VERSION=${{ steps.versions.outputs.runtime }}
cache-from: type=gha,scope=archie-agent
cache-to: type=gha,mode=max,scope=archie-agent
# Packages the host-run binaries (archied, archie-gateway,
# archie-state-store, archie-playbooks) as a linux/amd64 zip for a
# non-Docker install. Independent of build-and-push: it never touches the
# archied/archie-agent image jobs, and a gateway-only release (no
# archie/v* tag) still produces this zip -- it's keyed to the archied tag
# alone. archie-agent is deliberately excluded: it only ever runs inside
# the Docker image build-and-push already publishes, never as a host
# binary (archie-core-8cda.4.7.1).
dist-zip:
needs: gate
# Not gated on github.ref. A release is pushed as main plus both tags at
# one SHA, the concurrency group below collapses those into a single run,
# and the survivor is whichever ref happened to start last -- for
# v1.23.0 that was refs/heads/main, so this job was skipped and no zip
# was ever produced. Resolve the tag from the commit instead of trusting
# the ref that won the race, and skip only when there is genuinely no
# archied tag at HEAD.
if: needs.gate.outputs.archied_version != ''
runs-on: ubuntu-latest
# Least privilege: the workflow default is contents:read, and only this
# job needs to write, to create the Release and attach the zip to it.
permissions:
contents: write
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Set up Go
uses: actions/setup-go@v5
with:
go-version-file: go.mod
- name: Resolve archied version
id: version
run: echo "version=${{ needs.gate.outputs.archied_version }}" >> "$GITHUB_OUTPUT"
- name: Build linux/amd64 binaries
env:
GOOS: linux
GOARCH: amd64
CGO_ENABLED: "0"
run: |
set -e
# Every process in the documented deployment ships in the zip, and
# every one of them carries the archied version it was cut from:
# they are one release, and an operator matching binaries by eye
# needs each to say so.
ldflags="-X github.com/samcharles93/archie-core/internal/app/archied.gatewayVersion=${{ steps.version.outputs.version }} -X github.com/samcharles93/archie-core/internal/installtype.buildType=binary"
mkdir -p dist
for cmd in archied archie-gateway archie-state-store archie-ui archie-playbooks; do
go build -ldflags "$ldflags" -o "dist/$cmd" "./cmd/$cmd"
done
- name: Assemble distribution zip
id: zip
run: |
set -e
name="archie-core-archied-v${{ steps.version.outputs.version }}-linux-amd64"
mkdir -p "$name"
cp dist/archied dist/archie-gateway dist/archie-state-store dist/archie-ui dist/archie-playbooks "$name/"
cp deployments/INSTRUCTIONS.md CHANGELOG.md CHANGELOG.archied.md CHANGELOG.archie.md "$name/"
# README.md doesn't exist yet in this repo; include it once it does
# rather than fail the release on its absence.
[ -f README.md ] && cp README.md "$name/"
zip -r "$name.zip" "$name"
echo "name=$name" >> "$GITHUB_OUTPUT"
- name: Upload distribution zip
uses: actions/upload-artifact@v4
with:
name: ${{ steps.zip.outputs.name }}
path: ${{ steps.zip.outputs.name }}.zip
retention-days: 90
# A Release is what an operator can actually download from; the
# artifact above is reachable only from the run's page, behind an
# Actions login, and expires after 90 days. Until this step existed the
# zip was produced and then stranded -- the only Release on this repo
# (archied/v1.22.0) was created by hand and carries no asset at all.
#
# Attached to the *archied* tag because the zip is named and versioned
# for archied, and `--follow-tags` pushes both tags at one commit.
# --generate-notes is deliberately not used: the changelog section is
# the release's own reviewed prose, and the tag/changelog gate above
# already guarantees it describes this version.
- name: Publish GitHub Release with the distribution zip
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
set -e
tag="archied/v${{ steps.version.outputs.version }}"
version="${{ steps.version.outputs.version }}"
# The release body is this version's changelog section, not the whole
# file: from its "## [x.y.z]" heading to the next "## [" heading.
# Extracting rather than inlining keeps the changelog the single
# source of truth, and the tag/changelog gate above has already
# proven that section exists.
notes="$(mktemp)"
awk -v hdr="## [$version]" '
index($0, hdr) == 1 { printing = 1 }
printing && /^## \[/ && index($0, hdr) != 1 { exit }
printing { print }
' CHANGELOG.archied.md > "$notes"
if ! [ -s "$notes" ]; then
echo "no [$version] section extracted from CHANGELOG.archied.md" >&2
exit 1
fi
# Idempotent: --clobber replaces the asset and leaves the notes
# alone, so a re-run of this job (a retried or superseded deploy)
# cannot fail on an existing Release or duplicate the zip.
if gh release view "$tag" >/dev/null 2>&1; then
gh release upload "$tag" "${{ steps.zip.outputs.name }}.zip" --clobber
else
gh release create "$tag" \
--title "archied v$version" \
--notes-file "$notes" \
"${{ steps.zip.outputs.name }}.zip"
fi
echo "published $tag with ${{ steps.zip.outputs.name }}.zip"