# 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*", "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 (each job pushes its image tags), 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*' --list 'v*' | sed -e 's|^archied/v||' -e 's|^v||' | sort -V | tail -1)" echo "archied_version=$version" >> "$GITHUB_OUTPUT" if [ -n "$version" ]; then echo "archied release at HEAD: $version" else echo "no release 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" - name: Install quality tools run: | go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.13.2 go install mvdan.cc/gofumpt@v0.11.0 go install github.com/go-task/task/v3/cmd/task@v3.48.0 - name: Install protobuf tools run: bash tools/proto.sh install # The backup/restore tests shell out to pg_dump/pg_restore against a # postgres:18 testcontainer; the runner's stock client is older and # refuses the server version. - name: Install PostgreSQL 18 client run: | sudo install -d /usr/share/postgresql-common/pgdg sudo curl --fail --silent --show-error --location \ https://www.postgresql.org/media/keys/ACCC4CF8.asc \ --output /usr/share/postgresql-common/pgdg/apt.postgresql.org.asc . /etc/os-release echo "deb [signed-by=/usr/share/postgresql-common/pgdg/apt.postgresql.org.asc] https://apt.postgresql.org/pub/repos/apt ${VERSION_CODENAME}-pgdg main" \ | sudo tee /etc/apt/sources.list.d/pgdg.list sudo apt-get update sudo apt-get install -y --no-install-recommends postgresql-client-18 echo "/usr/lib/postgresql/18/bin" >> $GITHUB_PATH - 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: | # The formatter sequence has one owner: task fmt, which drives go fix # to a fixpoint and then the configured lint formatters. This step # used to inline its own single `go fix ./...`, which leaves the # redundant loop-variable copy that copyloopvar rejects -- the hazard # of archie-core-wwho, surfacing here as a spurious git-diff failure # (archie-core-6kda). task fmt git diff --exit-code bash tools/proto.sh lint bash tools/proto.sh check go vet ./... golangci-lint run ./... 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 v*) ver="${tag#v}" echo " release tag $tag -> looking for [$ver] in CHANGELOG.md" grep -q "^## \\[$ver\\]" CHANGELOG.md || { echo " FAIL: CHANGELOG.md has no [$ver] section" fail=1 } ;; archied/v* | archie/v*) # Legacy per-component tags. History is not re-tagged, and the # merged CHANGELOG.md carries every component's versions, so the # section is found there rather than in a component file. ver="${tag#*/v}" echo " legacy tag $tag -> looking for [$ver] in CHANGELOG.md" grep -q "^## \\[$ver\\]" CHANGELOG.md || { echo " FAIL: CHANGELOG.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=" echo "edit the generated notes, then: task release VERSION=" exit 1 fi if ! git tag --points-at HEAD | grep -qE '^(v[0-9]|archied/v|archie/v)' ; then echo "This commit is not a release, so the images are published as :edge and sha-; :latest keeps naming the newest release." fi build-and-push: outputs: agent_digest: ${{ steps.agent.outputs.digest }} needs: gate runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v4 with: fetch-depth: 0 # Deliberately NOT `github.sha`. On a tag push that is the ref's OBJECT id, # and every release tag in this repo is annotated — measured, 80 of 80 # `archied/v*` and `archie/v*` tags are tag objects — so it names something # that cannot be checked out. `archied/v1.36.0` is an instance: it points at # 6720bc42 (a tag object) and dereferences to commit c25f8d39. The producer # is right to create annotated tags; the consumer stops guessing. - name: Resolve the commit this ref points at id: commit run: | sha="$(git rev-parse "${GITHUB_REF}^{commit}")" echo "sha=$sha" >> "$GITHUB_OUTPUT" echo "short=${sha:0:12}" >> "$GITHUB_OUTPUT" - 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)" # One release stream: a `v*` tag covers the whole release, so it names # both components' versions. Legacy per-component tags still win where # they exist, because history is not re-tagged. RELEASE_TAG="$(git tag --points-at HEAD --list 'v*' | sort -V | tail -1)" GATEWAY_VERSION="${GATEWAY_TAG#archied/}" RUNTIME_VERSION="${RUNTIME_TAG#archie/}" [ -n "$GATEWAY_VERSION" ] || GATEWAY_VERSION="${RELEASE_TAG#v}" [ -n "$RUNTIME_VERSION" ] || RUNTIME_VERSION="${RELEASE_TAG#v}" # `dev+` is what a build that is NOT a release reports, and it is # honest now that such a build no longer publishes :latest: the version # names the commit it came from, and the sha- tag makes it # restorable. Before, this same string reached :latest minutes after a # release and made the release's own stamping read as dev # (archie-core-i5nb). (On an untagged push GITHUB_SHA IS the commit — # the tag case is handled by the dereference above.) [ -n "$GATEWAY_VERSION" ] || GATEWAY_VERSION="dev+${GITHUB_SHA:0:12}" [ -n "$RUNTIME_VERSION" ] || RUNTIME_VERSION="dev+${GITHUB_SHA:0:12}" # Keep the raw tag presence separate from the version fallback: a # LEGACY gateway-only release (archied/v* and no archie/v*) must not # rebuild the runtime image as dev. A one-stream `v*` release is not # gateway-only -- one version covers the runtime too -- so it does # rebuild it, and release_tag is what tells the two apart. echo "gateway_tag=$GATEWAY_TAG" >> "$GITHUB_OUTPUT" echo "runtime_tag=$RUNTIME_TAG" >> "$GITHUB_OUTPUT" echo "release_tag=$RELEASE_TAG" >> "$GITHUB_OUTPUT" echo "gateway=$GATEWAY_VERSION" >> "$GITHUB_OUTPUT" echo "runtime=$RUNTIME_VERSION" >> "$GITHUB_OUTPUT" # :latest names the newest RELEASE, so only a commit that IS one # publishes it. A push to main publishes :edge (mutable, newest main) # and sha- (immutable) instead. That is what stops a release's # :latest stamping from being overwritten minutes later by the next # ordinary commit, which left a host reporting dev and made the update # path unable to tell current from stale (archie-core-i5nb). # # `if` blocks rather than `[ -n "$X" ] && echo`: the latter returns # non-zero when the test fails, and these steps run under `set -e`. { echo "archied_tags<> "$GITHUB_OUTPUT" - name: Build and push archied uses: docker/build-push-action@v6 with: context: . file: Dockerfile.archied push: true tags: ${{ steps.versions.outputs.archied_tags }} 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 id: agent if: steps.versions.outputs.runtime_tag != '' || steps.versions.outputs.release_tag != '' uses: docker/build-push-action@v6 with: context: . file: Dockerfile push: true tags: | ghcr.io/samcharles93/archie-agent:latest ghcr.io/samcharles93/archie-agent:sha-${{ steps.commit.outputs.sha }} 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 every host-run binary (archied, archie-gateway, # archie-state-store, archie-ui, archie-messaging) 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, build-and-push] # 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. # # That claim is load-bearing and this list is the whole of it: the # v1.30.0 messaging extraction moved Telegram/email/webhook out of # archied and nothing added archie-messaging here, so a host install # ran on with a dead Telegram bot and no error anywhere # (archie-core-1c01). TestDistZipShipsEveryHostCommand fails if this # list and the copy list below stop matching the commands in cmd/. ldflags="-X github.com/samcharles93/archie-core/internal/installtype.buildType=binary -X github.com/samcharles93/archie-core/internal/buildinfo.Version=${{ steps.version.outputs.version }} -X github.com/samcharles93/archie-core/internal/buildinfo.Runtime=${{ steps.version.outputs.version }}" mkdir -p dist for cmd in $(jq -r '.required_topology.units[]' release.json); 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" for cmd in $(jq -r '.required_topology.units[]' release.json); do cp "dist/$cmd" "$name/" done cp deployments/INSTRUCTIONS.md CHANGELOG.md "$name/" cp scripts/archie-update-* "$name/" digest='${{ needs.build-and-push.outputs.agent_digest }}' test -n "$digest" jq --arg image "ghcr.io/samcharles93/archie-agent@$digest" '. + {agent_image: $image}' release.json > "$name/release.json" # 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" sha256sum "$name.zip" > SHA256SUMS 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 SHA256SUMS 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="v${{ steps.version.outputs.version }}" if ! git ls-remote --exit-code --tags origin "refs/tags/$tag" >/dev/null; then tag="archied/v${{ steps.version.outputs.version }}" fi 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.md > "$notes" if ! [ -s "$notes" ]; then echo "no [$version] section extracted from CHANGELOG.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" SHA256SUMS --clobber else gh release create "$tag" \ --title "archied v$version" \ --notes-file "$notes" \ "${{ steps.zip.outputs.name }}.zip" SHA256SUMS fi echo "published $tag with ${{ steps.zip.outputs.name }}.zip"