Taskfile.yaml

version: '3'

vars:
  LOCALBIN:
    sh: echo "$(pwd)/bin"
  GOBIN:
    sh: |
      gobin=$(go env GOBIN)
      [ -n "$gobin" ] && echo "$gobin" || echo "$(go env GOPATH)/bin"
  GOLANGCI_LINT: '{{.LOCALBIN}}/golangci-lint'
  YAMLFMT: '{{.LOCALBIN}}/yamlfmt'
  GO_LICENSES: '{{.LOCALBIN}}/go-licenses'
  GOLANGCI_LINT_VERSION: v2.12.2
  YAMLFMT_VERSION: v0.21.0
  GO_LICENSES_VERSION: v1.6.0
  PROMETHEUS_VERSION: v3.15.0

tasks:
  default:
    silent: true
    cmds:
      - task --list

  ##
  ## Development
  ##

  fmt:
    desc: Format code
    run: once
    cmds:
      - go fmt ./...

  vet:
    desc: Vet code
    run: once
    cmds:
      - GOOS=linux go vet ./...

  ci:
    desc: Run the full CI pipeline
    cmds:
      - task: lint
      - task: build
      - task: test:unit
      - task: test:e2e

  test:
    desc: Run all tests
    cmds:
      - task: test:unit
      - task: test:e2e

  lint:
    desc: Lint
    deps: [golangci-lint, yamlfmt, yaml-ext, build:ebpf]
    cmds:
      - '{{.GOLANGCI_LINT}} run'
      - '{{.YAMLFMT}} -lint'

  lint-fix:
    desc: Lint and apply fixes
    deps: [golangci-lint, yamlfmt, build:ebpf]
    cmds:
      - '{{.GOLANGCI_LINT}} run --fix'
      - '{{.YAMLFMT}}'

  notice:
    desc: Regenerate NOTICE file
    deps: [go-licenses]
    cmds:
      - '{{.GO_LICENSES}} report ./... --ignore go.datum.net/galactic --template scripts/licenses/notice.tmpl > NOTICE'

  ##
  ## Build
  ##

  build:
    desc: Build binaries
    cmds:
      # build:ebpf must run before fmt/vet, not just before build:binaries:
      # internal/plumbing/ebpf/prog's usid_bpfel.o/usid_bpfeb.o (go:embed'd)
      # aren't committed (see .gitignore), so `go vet ./...` -- and anything
      # else that type-checks the whole module -- fails to compile that
      # package on a fresh checkout until this has generated them.
      - task: build:ebpf
      - task: fmt
      - task: vet
      - task: build:binaries

  generate:proto:
    desc: Regenerate api/**/*.pb.go from the .proto files (requires buf, protoc-gen-go, protoc-gen-go-grpc)
    dir: api
    cmds:
      - buf lint
      - buf generate

  generate:crd:
    desc: Regenerate the FabricQuery deepcopy code and CRD (requires controller-gen)
    cmds:
      - controller-gen object:headerFile=hack/boilerplate.go.txt paths=./internal/fabric/api/...
      - controller-gen crd paths=./internal/fabric/api/... output:crd:artifacts:config=config/fabric-api/crd

  build:ebpf:
    desc: Regenerate the eBPF uSID, edge gateway DSR, NAT egress, and XDP dispatcher datapaths (requires clang)
    run: once
    deps: [require-clang]
    cmds:
      - go generate ./internal/plumbing/ebpf/prog/...
      - go generate ./internal/plumbing/ebpf/edgeprog/...
      - go generate ./internal/plumbing/ebpf/natprog/...
      - go generate ./internal/plumbing/ebpf/xdpdispatch/...

  require-clang:
    internal: true
    run: once
    cmds:
      - |
        if ! command -v "${BPF2GO_CC:-clang}" >/dev/null 2>&1; then
          echo "ERROR: ${BPF2GO_CC:-clang} not found on PATH." >&2
          echo "internal/plumbing/ebpf/prog/usid_bpfel.o/usid_bpfeb.o are" >&2
          echo "generated from usid.c via bpf2go, not committed to git (see" >&2
          echo "internal/plumbing/ebpf/prog/doc.go) -- clang is required to" >&2
          echo "build or test this module at all. Install, e.g.:" >&2
          echo "  Fedora/RHEL: sudo dnf install clang llvm" >&2
          echo "  Debian/Ubuntu: sudo apt install clang llvm" >&2
          exit 1
        fi

  build:binaries:
    internal: true
    vars:
      VERSION:
        sh: git describe --tags --always --dirty 2>/dev/null || echo "dev"
      GIT_COMMIT:
        sh: git rev-parse --short HEAD
      GIT_TREE_STATE:
        sh: git diff --quiet && echo "clean" || echo "dirty"
      BUILD_DATE:
        sh: date -u +%Y-%m-%dT%H:%M:%SZ
      SPDX_LICENSE: AGPL-3.0-or-later
      GIT_URL: https://github.com/datum-cloud/galactic
      LDFLAGS: >-
        -s -w
        -X go.datum.net/galactic/internal/metadata.Version={{.VERSION}}
        -X go.datum.net/galactic/internal/metadata.GitCommit={{.GIT_COMMIT}}
        -X go.datum.net/galactic/internal/metadata.GitTreeState={{.GIT_TREE_STATE}}
        -X go.datum.net/galactic/internal/metadata.BuildDate={{.BUILD_DATE}}
        -X go.datum.net/galactic/internal/metadata.SPDXLicense={{.SPDX_LICENSE}}
        -X go.datum.net/galactic/internal/metadata.GitURL={{.GIT_URL}}
    cmds:
      - go build -ldflags "{{.LDFLAGS}}" -o bin/galactic-cni ./cmd/galactic-cni
      - go build -ldflags "{{.LDFLAGS}}" -o bin/galactic-veth ./cmd/galactic-veth
      - go build -ldflags "{{.LDFLAGS}}" -o bin/galactic-tap ./cmd/galactic-tap
      - go build -ldflags "{{.LDFLAGS}}" -o bin/galactic-ipam ./cmd/galactic-ipam
      - go build -ldflags "{{.LDFLAGS}}" -o bin/galactic-bgp ./cmd/galactic-bgp
      - go build -ldflags "{{.LDFLAGS}}" -o bin/galactic-route ./cmd/galactic-route
      - go build -ldflags "{{.LDFLAGS}}" -o bin/galactic-router ./cmd/galactic-router
      - go build -ldflags "{{.LDFLAGS}}" -o bin/galactic-gateway ./cmd/galactic-gateway
      - go build -ldflags "{{.LDFLAGS}}" -o bin/galactic-nat ./cmd/galactic-nat
      - go build -ldflags "{{.LDFLAGS}}" -o bin/galactic-vrf ./cmd/galactic-vrf
      - go build -ldflags "{{.LDFLAGS}}" -o bin/fabric-config-agent ./cmd/fabric-config-agent
      - go build -ldflags "{{.LDFLAGS}}" -o bin/fabric-api ./cmd/fabric-api
      - go build -ldflags "{{.LDFLAGS}}" -o bin/galactic-usid ./cmd/galactic-usid
      - GOBIN={{.LOCALBIN}} go install github.com/containernetworking/plugins/plugins/main/host-device@v1.9.1

  ##
  ## CI
  ##

  test:unit:
    desc: Unit tests with race detection and coverage
    deps: [build:ebpf]
    cmds:
      - bash scripts/ci.sh unittest

  test:unit-root:
    desc: Re-run just the requireRoot(t)-gated unit tests, as root
    deps: [build:ebpf]
    cmds:
      - bash scripts/ci.sh unittest-root

  test:fabric-api-load:
    desc: Measure fabric-api queries against FRR with full Internet tables (MRT=<rib files, comma-separated>, needs Docker)
    # The release gate for enabling AS-path and community searches: bgpd
    # CPU and memory, session stability and convergence under query load.
    # MRT is an uncompressed TABLE_DUMP_V2 RIB, e.g. a RouteViews
    # rib.YYYYMMDD.HHMM; gobgpd/gobgp are built at the module's own version.
    requires:
      vars: [MRT]
    vars:
      GOBGP_BIN: '{{.LOCALBIN}}/gobgp-tools'
    cmds:
      - mkdir -p {{.GOBGP_BIN}}
      - CGO_ENABLED=0 GOBIN={{.GOBGP_BIN}} go install github.com/osrg/gobgp/v4/cmd/gobgpd@v4.10.0 github.com/osrg/gobgp/v4/cmd/gobgp@v4.10.0
      - go run ./hack/fabric-api-loadtest --mrt {{.MRT}} --gobgp-bin {{.GOBGP_BIN}} {{.CLI_ARGS}}

  test:alerts:
    desc: Unit-test the alert rules in config/monitoring/ with promtool
    # promtool reads plain rule files, so the PrometheusRule's spec is
    # extracted first. Both tools run from their images, so nothing needs
    # installing; not part of ci, which has no Docker-image dependency of its own.
    vars:
      ALERTS_DIR: '{{.LOCALBIN}}/alerts-test'
    cmds:
      - mkdir -p {{.ALERTS_DIR}}
      - docker run --rm -i mikefarah/yq:4 '.spec' < config/monitoring/prometheusrule.yaml > {{.ALERTS_DIR}}/rules.yaml
      - cp config/monitoring/tests/rules-test.yaml {{.ALERTS_DIR}}/
      - docker run --rm -v {{.ALERTS_DIR}}:/t -w /t --entrypoint promtool prom/prometheus:{{.PROMETHEUS_VERSION}} check rules rules.yaml
      - docker run --rm -v {{.ALERTS_DIR}}:/t -w /t --entrypoint promtool prom/prometheus:{{.PROMETHEUS_VERSION}} test rules rules-test.yaml

  test:e2e:
    desc: E2E tests (Kind cluster, build+load image, lifecycle)
    # build:ebpf here is only for the host-side `go test ./tests/e2e/...`
    # compile in scripts/ci.sh -- the galactic-cni image built inside
    # ci.sh's docker build regenerates its own copy via the Dockerfile.
    deps: [build:ebpf]
    cmds:
      - bash scripts/ci.sh e2etest

  ##
  ## Cleanup
  ##

  clean:
    desc: Remove build artifacts
    cmds:
      - rm -rf bin/
      - rm -rf dist/
      - rm -f cover.out

  ##
  ## Dependencies
  ##

  golangci-lint:
    desc: Download golangci-lint if needed
    run: once
    cmds:
      - task: install-tool
        vars:
          TARGET: '{{.GOLANGCI_LINT}}'
          PACKAGE: github.com/golangci/golangci-lint/v2/cmd/golangci-lint
          VERSION: '{{.GOLANGCI_LINT_VERSION}}'

  yamlfmt:
    desc: Download yamlfmt if needed
    run: once
    cmds:
      - task: install-tool
        vars:
          TARGET: '{{.YAMLFMT}}'
          PACKAGE: github.com/google/yamlfmt/cmd/yamlfmt
          VERSION: '{{.YAMLFMT_VERSION}}'

  yaml-ext:
    desc: Enforce .yaml extension (no .yml)
    run: once
    cmds:
      - |
        if find . -name "*.yml" -not -path "./.git/*" -not -path "./deploy/containerlab/clab-gvpc/*" | grep -q .; then
          find . -name "*.yml" -not -path "./.git/*" -not -path "./deploy/containerlab/clab-gvpc/*"
          echo "ERROR: .yml files found; rename to .yaml"
          exit 1
        fi

  go-licenses:
    internal: true
    run: once
    cmds:
      - task: install-tool
        vars:
          TARGET: '{{.GO_LICENSES}}'
          PACKAGE: github.com/google/go-licenses
          VERSION: '{{.GO_LICENSES_VERSION}}'

  install-tool:
    internal: true
    cmds:
      - mkdir -p {{.LOCALBIN}}
      - |
        if [ ! -f "{{.TARGET}}-{{.VERSION}}" ]; then
          echo "Downloading {{.PACKAGE}}@{{.VERSION}}"
          rm -f "{{.TARGET}}" || true
          GOBIN={{.LOCALBIN}} go install {{.PACKAGE}}@{{.VERSION}}
          mv "{{.TARGET}}" "{{.TARGET}}-{{.VERSION}}"
        fi
        ln -sf "{{.TARGET}}-{{.VERSION}}" "{{.TARGET}}"