Pipelines in Go,
not YAML

name: Release
on:
  push:
    branches: [main]
  workflow_dispatch:

concurrency:
  group: release-${{ github.ref }}
  cancel-in-progress: false

permissions:
  id-token: write
  contents: read
  packages: write

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: '1.26'
      - name: Cache Go modules
        uses: actions/cache@v4
        with:
          path: |
            ~/.cache/go-build
            ~/go/pkg/mod
          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
          restore-keys: ${{ runner.os }}-go-
      - name: Download deps
        run: go mod download
      - name: Run tests
        run: go test -race -coverprofile=coverage.out ./...
      - name: Upload coverage
        uses: codecov/codecov-action@v4
        with:
          file: coverage.out
          token: ${{ secrets.CODECOV_TOKEN }}

  build:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: ${{ vars.CI_ROLE }}
          aws-region: us-west-2
      - uses: aws-actions/amazon-ecr-login@v2
      - uses: docker/setup-buildx-action@v3
      - name: Cache buildx layers
        uses: actions/cache@v4
        with:
          path: /tmp/.buildx-cache
          key: ${{ runner.os }}-buildx-${{ github.sha }}
          restore-keys: ${{ runner.os }}-buildx-
      - name: Build + push
        run: |
          TAG=$(git rev-parse --short HEAD)
          docker buildx build \
            --platform linux/arm64,linux/amd64 \
            --cache-from type=local,src=/tmp/.buildx-cache \
            --cache-to type=local,dest=/tmp/.buildx-cache-new \
            --tag $ECR/myapp:$TAG --push .
          mv /tmp/.buildx-cache-new /tmp/.buildx-cache

  deploy:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Bump gitops manifest
        env:
          GH_TOKEN: ${{ secrets.GITOPS_TOKEN }}
        run: |
          git clone https://x-access-token:$GH_TOKEN@github.com/org/gitops.git
          cd gitops
          sed -i "s|myapp:.*|myapp:$TAG|" envs/prod/values.yaml
          git -c user.email=ci@x -c user.name=ci \
              commit -am "bump myapp $TAG" && git push
      - name: Sync ArgoCD
        env:
          ARGO_TOKEN: ${{ secrets.ARGOCD_TOKEN }}
        run: |
          argocd login argocd.example.com --grpc-web --auth-token $ARGO_TOKEN
          argocd app sync myapp --grpc-web
          argocd app wait myapp --health --grpc-web

  notify:
    needs: deploy
    if: always()
    runs-on: ubuntu-latest
    steps:
      - name: Notify Slack
        uses: slackapi/slack-github-action@v1
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK }}
        with:
          payload: |
            {"text":"Release ${{ needs.deploy.result }}: ${{ github.sha }}"}

import (
    sw "github.com/sparkwing-dev/sparkwing/sparkwing"
    "github.com/sparkwing-dev/sparks-core/cache"
    "github.com/sparkwing-dev/sparks-core/deploy"
    "github.com/sparkwing-dev/sparks-core/docker"
    "github.com/sparkwing-dev/sparks-core/gotest"
    "github.com/sparkwing-dev/sparks-core/notify"
)

type Release struct{ sw.Base }

func (Release) Plan(ctx context.Context, plan *sw.Plan, _ sw.NoInputs, rc sw.RunContext) error {
    ecr := "123.dkr.ecr.us-west-2.amazonaws.com"

    test := sw.Job(plan, "test", &gotest.Run{
        Race:  true,
        Cover: true,
    }).Cache(cache.GoModules())

    build := sw.Job(plan, "build", &docker.BuildAndPush{
        Image:      "myapp",
        Dockerfile: "Dockerfile",
        Registries: docker.DetectRegistries("prod", ecr),
        Platform:   "linux/arm64,linux/amd64",
    }).Cache(cache.BuildxLayers()).Needs(test)

    deployed := sw.Job(plan, "deploy", &deploy.GitopsArgoCD{
        GitopsRepo: "git@github.com:org/gitops.git",
        GitopsPath: "envs/prod",
        ECR:        ecr,
        Images:     []string{"myapp"},
        AppName:    "myapp",
    }).Needs(build)

    sw.Job(plan, "notify", &notify.Slack{
        Channel: "#deploys",
        Message: "Release {{.Status}}: {{.GitSHA}}",
    }).Needs(deployed).AlwaysRun()

    return nil
}