Repository navigation
chore(deps): bump the go-modules group with 3 updates #167
Workflow file for this run
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| name: Go | |
| on: | |
| push: | |
| branches: [ "main" ] | |
| tags: [ "v*" ] | |
| pull_request: | |
| branches: [ "main" ] | |
| jobs: | |
| # Two legs: "minimum" proves the go.mod floor (1.26.0) still builds and | |
| # passes; "stable" is the toolchain releases are built with, and is where | |
| # lint and govulncheck run (#38). | |
| build: | |
| runs-on: ubuntu-latest | |
| permissions: | |
| contents: read | |
| strategy: | |
| fail-fast: false | |
| matrix: | |
| go: [ minimum, stable ] | |
| steps: | |
| - uses: actions/checkout@v7 | |
| with: | |
| fetch-depth: 0 | |
| - name: Set up Go (go.mod minimum) | |
| if: matrix.go == 'minimum' | |
| uses: actions/setup-go@v7 | |
| with: | |
| go-version-file: 'go.mod' | |
| cache: false | |
| - name: Set up Go (latest stable) | |
| if: matrix.go == 'stable' | |
| uses: actions/setup-go@v7 | |
| with: | |
| go-version: stable | |
| check-latest: true | |
| cache: false | |
| - name: Cache Go build artifacts | |
| uses: actions/cache@v6 | |
| with: | |
| path: | | |
| ~/.cache/go-build | |
| ~/go/pkg/mod | |
| key: ${{ runner.os }}-go-${{ matrix.go }}-${{ hashFiles('**/go.sum') }} | |
| restore-keys: | | |
| ${{ runner.os }}-go-${{ matrix.go }}- | |
| - name: Verify dependencies | |
| run: go mod verify | |
| - name: Check go directive | |
| shell: bash | |
| run: | | |
| want='go 1.26.0' | |
| got=$(grep -m1 '^go ' go.mod) | |
| if [ "$got" != "$want" ]; then | |
| echo "go.mod directive drifted: got '$got', want '$want'. Run 'make tidy'." | |
| exit 1 | |
| fi | |
| - name: Build | |
| run: go build -v -buildvcs=false -ldflags "-X main.Version=$(git describe --tags --dirty)" ./... | |
| - name: Test | |
| run: go test -v -race ./... | |
| # Lint on the stable leg: golangci-lint must be built with a Go at least as | |
| # new as the toolchain it analyses (v2.12 could not type-check Go 1.27). | |
| - name: Run golangci-lint | |
| if: matrix.go == 'stable' | |
| uses: golangci/golangci-lint-action@v9 | |
| with: | |
| version: v2.14.0 | |
| # Fails on vulnerabilities reachable from this code, in dependencies or in | |
| # the Go standard library of the toolchain releases are built with. | |
| - name: Run govulncheck | |
| if: matrix.go == 'stable' | |
| run: go run golang.org/x/vuln/cmd/govulncheck@latest ./... | |
| # Builds the Dockerfile for both published platforms without pushing, so a | |
| # broken image is caught on the PR rather than during a release. | |
| docker: | |
| runs-on: ubuntu-latest | |
| permissions: | |
| contents: read | |
| steps: | |
| - uses: actions/checkout@v7 | |
| - name: Set up Docker Buildx | |
| uses: docker/setup-buildx-action@v4 | |
| - name: Build image (no push) | |
| uses: docker/build-push-action@v7 | |
| with: | |
| context: . | |
| platforms: linux/amd64,linux/arm64 | |
| push: false | |
| build-args: VERSION=ci | |
| # Single job that owns release creation. It runs once (not a matrix), so | |
| # exactly one job ever creates the release for the tag. The upload-assets | |
| # matrix below then only adds files to this already-existing release and can | |
| # never race to create it (the race that made action-gh-release v3 fail with | |
| # "already_exists (tag_name)"). | |
| # | |
| # The release is created as a draft so it is not publicly visible while the | |
| # upload matrix is still attaching assets. The publish-release job flips it to | |
| # published only after all assets are present, so the public never sees a | |
| # partial or empty release. | |
| create-release: | |
| needs: [ build, docker ] | |
| if: startsWith(github.ref, 'refs/tags/v') | |
| runs-on: ubuntu-latest | |
| permissions: | |
| contents: write | |
| steps: | |
| - name: Create draft release for tag | |
| uses: softprops/action-gh-release@v3 | |
| with: | |
| draft: true | |
| generate_release_notes: true | |
| env: | |
| GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} | |
| upload-assets: | |
| needs: create-release | |
| if: startsWith(github.ref, 'refs/tags/v') | |
| permissions: | |
| contents: write | |
| id-token: write | |
| attestations: write | |
| strategy: | |
| matrix: | |
| include: | |
| - os: ubuntu-latest | |
| goos: linux | |
| goarch: amd64 | |
| artifact_name: subenum | |
| asset_name: subenum-linux-amd64 | |
| - os: windows-latest | |
| goos: windows | |
| goarch: amd64 | |
| artifact_name: subenum.exe | |
| asset_name: subenum-windows-amd64.exe | |
| - os: macos-latest | |
| goos: darwin | |
| goarch: arm64 | |
| artifact_name: subenum | |
| asset_name: subenum-macos-arm64 | |
| - os: ubuntu-latest | |
| goos: darwin | |
| goarch: amd64 | |
| artifact_name: subenum | |
| asset_name: subenum-macos-amd64 | |
| - os: ubuntu-latest | |
| goos: linux | |
| goarch: arm64 | |
| artifact_name: subenum | |
| asset_name: subenum-linux-arm64 | |
| runs-on: ${{ matrix.os }} | |
| steps: | |
| - uses: actions/checkout@v7 | |
| with: | |
| fetch-depth: 0 | |
| # Release binaries use the latest stable Go so they ship a patched | |
| # standard library; go.mod's 1.24.2 is only the minimum (#38). No build | |
| # cache here, so release artifacts are always built from scratch. | |
| - name: Set up Go | |
| uses: actions/setup-go@v7 | |
| with: | |
| go-version: stable | |
| check-latest: true | |
| cache: false | |
| # CGO_ENABLED=0 on every leg: a native linux/amd64 build otherwise links | |
| # the cgo resolver against glibc and the "single static binary" stops | |
| # being true (#46). -trimpath and -s -w keep the binary reproducible and | |
| # small; VCS stamping stays on so `go version -m` shows provenance. | |
| - name: Build | |
| env: | |
| GOOS: ${{ matrix.goos }} | |
| GOARCH: ${{ matrix.goarch }} | |
| CGO_ENABLED: "0" | |
| shell: bash | |
| run: go build -v -trimpath -ldflags "-s -w -X main.Version=$(git describe --tags --dirty)" -o ${{ matrix.artifact_name }} | |
| - name: Assert static linking | |
| if: matrix.goos == 'linux' | |
| shell: bash | |
| run: | | |
| file ${{ matrix.artifact_name }} | |
| file ${{ matrix.artifact_name }} | grep -q 'statically linked' | |
| - name: Rename for release | |
| shell: bash | |
| run: | | |
| if [ "${{ matrix.artifact_name }}" != "${{ matrix.asset_name }}" ]; then | |
| cp ${{ matrix.artifact_name }} ${{ matrix.asset_name }} | |
| fi | |
| - name: Generate checksum | |
| shell: bash | |
| run: sha256sum ${{ matrix.asset_name }} > ${{ matrix.asset_name }}.sha256 | |
| - name: Attest build provenance | |
| uses: actions/attest-build-provenance@v4 | |
| with: | |
| subject-path: ${{ matrix.asset_name }} | |
| # The release already exists (created by create-release), so each matrix leg | |
| # only adds its binary and checksum. No matrix job creates the release, which | |
| # avoids the concurrent-create race entirely. draft: true is set explicitly | |
| # so these update calls keep the release in draft (the action's draft input | |
| # defaults to false and would otherwise publish it early). | |
| - name: Upload assets to draft release | |
| uses: softprops/action-gh-release@v3 | |
| with: | |
| draft: true | |
| files: | | |
| ${{ matrix.asset_name }} | |
| ${{ matrix.asset_name }}.sha256 | |
| env: | |
| GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} | |
| # Single job that publishes the release once, only after the full asset set is | |
| # attached. Flipping draft to false here is the moment the release becomes | |
| # public, so there is no window where a partial or empty release is visible. | |
| publish-release: | |
| needs: upload-assets | |
| if: startsWith(github.ref, 'refs/tags/v') | |
| runs-on: ubuntu-latest | |
| permissions: | |
| contents: write | |
| steps: | |
| - name: Publish release | |
| uses: softprops/action-gh-release@v3 | |
| with: | |
| draft: false | |
| env: | |
| GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} | |
| # Publishes a multi-arch image to GHCR once the release itself is public | |
| # (#40). The Dockerfile cross-compiles in a build-platform builder stage, so | |
| # arm64 needs no QEMU. `latest` only moves for non-prerelease tags. | |
| publish-image: | |
| needs: publish-release | |
| if: startsWith(github.ref, 'refs/tags/v') | |
| runs-on: ubuntu-latest | |
| permissions: | |
| contents: read | |
| packages: write | |
| id-token: write | |
| attestations: write | |
| steps: | |
| - uses: actions/checkout@v7 | |
| # GHCR requires lowercase repository names; the owner is mixed case. | |
| - name: Compute image name | |
| id: image | |
| shell: bash | |
| env: | |
| OWNER: ${{ github.repository_owner }} | |
| run: echo "name=ghcr.io/${OWNER,,}/subenum" >> "$GITHUB_OUTPUT" | |
| - name: Set up Docker Buildx | |
| uses: docker/setup-buildx-action@v4 | |
| - name: Log in to GHCR | |
| uses: docker/login-action@v4 | |
| with: | |
| registry: ghcr.io | |
| username: ${{ github.actor }} | |
| password: ${{ secrets.GITHUB_TOKEN }} | |
| - name: Image metadata | |
| id: meta | |
| uses: docker/metadata-action@v6 | |
| with: | |
| images: ${{ steps.image.outputs.name }} | |
| tags: | | |
| type=semver,pattern={{version}} | |
| type=semver,pattern={{major}}.{{minor}} | |
| type=raw,value=latest,enable=${{ !contains(github.ref_name, '-') }} | |
| - name: Build and push | |
| id: push | |
| uses: docker/build-push-action@v7 | |
| with: | |
| context: . | |
| platforms: linux/amd64,linux/arm64 | |
| push: true | |
| tags: ${{ steps.meta.outputs.tags }} | |
| labels: ${{ steps.meta.outputs.labels }} | |
| build-args: VERSION=${{ github.ref_name }} | |
| - name: Attest image provenance | |
| uses: actions/attest-build-provenance@v4 | |
| with: | |
| subject-name: ${{ steps.image.outputs.name }} | |
| subject-digest: ${{ steps.push.outputs.digest }} | |
| push-to-registry: true | |
| # Failure-path cleanup. If the upload matrix fails partway, publish-release is | |
| # skipped and the draft release created above would otherwise linger | |
| # invisibly until someone removes it by hand. This job runs only when a | |
| # tag-triggered release run failed. It deletes the draft release for this tag | |
| # and the tag ref so a partial release leaves nothing behind. It only ever | |
| # deletes a draft (never a published release) and is a no-op when there is | |
| # nothing to clean, so it is safe and idempotent. | |
| cleanup-failed-release: | |
| needs: [create-release, upload-assets, publish-release] | |
| if: ${{ failure() && startsWith(github.ref, 'refs/tags/v') }} | |
| runs-on: ubuntu-latest | |
| permissions: | |
| contents: write | |
| steps: | |
| - name: Remove draft release and tag for failed run | |
| env: | |
| GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} | |
| TAG: ${{ github.ref_name }} | |
| REPO: ${{ github.repository }} | |
| shell: bash | |
| run: | | |
| set -euo pipefail | |
| rel=$(gh api "repos/${REPO}/releases" --jq "([.[] | select(.tag_name==\"${TAG}\")][0]) // empty") | |
| if [ -z "${rel}" ]; then | |
| echo "No release found for ${TAG}; nothing to clean." | |
| exit 0 | |
| fi | |
| id=$(printf '%s' "${rel}" | jq -r '.id') | |
| draft=$(printf '%s' "${rel}" | jq -r '.draft') | |
| if [ "${draft}" != "true" ]; then | |
| echo "Release ${id} for ${TAG} is published (draft=${draft}); leaving it intact." | |
| exit 0 | |
| fi | |
| echo "Deleting draft release ${id} for ${TAG}." | |
| gh api -X DELETE "repos/${REPO}/releases/${id}" | |
| echo "Deleting tag ref ${TAG}." | |
| gh api -X DELETE "repos/${REPO}/git/refs/tags/${TAG}" || echo "Tag ref already removed." | |
| echo "Cleanup complete for ${TAG}." |