Taskfile.yaml

version: '3'

vars:
  TOOL_DIR: "{{.USER_WORKING_DIR}}/bin"
  INVENTORY_IMAGE_NAME: "ghcr.io/milo-os/inventory"
  INVENTORY_IMAGE_TAG: "dev"
  TEST_INFRA_CLUSTER_NAME: "test-infra"
  TEST_INFRA_REPO_REF: 'v0.6.4'
  CONTROLLER_TOOLS_VERSION: "v0.16.4"
  DEFAULTER_GEN_VERSION: "v0.32.3"
  GOLANGCI_LINT_VERSION: "v2.1.5"
  # chainsaw is the e2e test runner only. Keep it on a release that compiles
  # with the repo's Go toolchain — pre-0.2.15 versions fail under Go 1.26
  # because their test runner predates testing.testDeps.ModulePath (see #36).
  CHAINSAW_VERSION: "v0.2.15"
  CRDOC_VERSION: "v0.6.4"
  SETUP_ENVTEST_VERSION: "latest"
  # ENVTEST_K8S_VERSION controls which Kubernetes binaries (kube-apiserver,
  # etcd, kubectl) setup-envtest downloads for envtest-backed unit tests.
  # It should be compatible with the k8s.io/api version pulled in via
  # controller-runtime.
  ENVTEST_K8S_VERSION: "1.34.1"

includes:
  # Must set TASK_X_REMOTE_TASKFILES=1 to use this feature.
  test-infra:
    taskfile: https://raw.githubusercontent.com/datum-cloud/test-infra/{{.TEST_INFRA_REPO_REF}}/Taskfile.yml
    vars:
      REPO_REF: "{{.TEST_INFRA_REPO_REF}}"

tasks:
  default:
    desc: List all available tasks
    cmds:
      - task --list
    silent: true

  # Code generation
  generate:
    desc: Run code generation (deepcopy)
    cmds:
      - |
        set -e
        echo "Running code generation..."
        {{.TOOL_DIR}}/controller-gen object:headerFile="hack/boilerplate.go.txt" paths="./..."
        echo "Code generation complete!"
    deps:
      - install:controller-gen
    silent: true

  manifests:
    desc: Generate CRD, RBAC, and webhook manifests
    cmds:
      - |
        set -e
        echo "Generating manifests..."
        {{.TOOL_DIR}}/controller-gen rbac:roleName=inventory \
          crd:generateEmbeddedObjectMeta=true,allowDangerousTypes=true \
          webhook \
          paths="./..." \
          output:crd:artifacts:config=config/base/crd/bases \
          output:rbac:artifacts:config=config/components/controller_rbac \
          output:webhook:artifacts:config=config/base/webhook
        echo "Manifests generated!"
    deps:
      - install:controller-gen
    silent: true

  api-docs:
    desc: Generate the API reference (docs/api/inventory.md) from the CRDs
    cmds:
      - |
        set -e
        echo "Generating API docs..."
        mkdir -p docs/api
        {{.TOOL_DIR}}/crdoc --resources config/base/crd/bases --output docs/api/inventory.md
        echo "API docs generated!"
    deps:
      - install:crdoc
    silent: true

  build:
    desc: Build the inventory binary
    cmds:
      - |
        set -e
        echo "Building inventory..."
        mkdir -p {{.TOOL_DIR}}

        GIT_COMMIT=$(git rev-parse HEAD 2>/dev/null || echo "unknown")
        VERSION="v0.0.0-dev+${GIT_COMMIT:0:7}"
        GIT_TREE_STATE="clean"
        if [ -n "$(git status --porcelain 2>/dev/null)" ]; then
          GIT_TREE_STATE="dirty"
        fi
        BUILD_DATE=$(date -u '+%Y-%m-%dT%H:%M:%SZ' 2>/dev/null || echo "unknown")

        echo "Version: ${VERSION}, Commit: ${GIT_COMMIT:0:7}, Tree: ${GIT_TREE_STATE}"

        go build \
          -ldflags="-X 'main.version=${VERSION}' \
                    -X 'main.gitCommit=${GIT_COMMIT}' \
                    -X 'main.gitTreeState=${GIT_TREE_STATE}' \
                    -X 'main.buildDate=${BUILD_DATE}'" \
          -o {{.TOOL_DIR}}/inventory ./cmd/inventory
        echo "Binary built: {{.TOOL_DIR}}/inventory"
    silent: true

  test:
    desc: Run Go tests
    deps:
      - install:setup-envtest
    cmds:
      - |
        set -e
        ENVTEST_ASSETS=$({{.TOOL_DIR}}/setup-envtest use {{.ENVTEST_K8S_VERSION}} --bin-dir {{.TOOL_DIR}}/k8s -p path)
        KUBEBUILDER_ASSETS="${ENVTEST_ASSETS}" go test -timeout 5m ./... -count=1
    silent: false

  lint:
    desc: Run golangci-lint
    cmds:
      - "{{.TOOL_DIR}}/golangci-lint run ./..."
    deps:
      - install:golangci-lint
    silent: false

  # Tool installation
  #
  # Each tool installs independently with its own status guard, so a task only
  # pulls in the tools it actually needs — e.g. `generate` depends on
  # controller-gen, not chainsaw. This keeps a single tool's install failure
  # (e.g. an e2e runner that won't compile under the current Go) from blocking
  # unrelated codegen, lint, and unit-test tasks. See #36.
  install-tools:
    desc: Install all development tools
    deps:
      - install:controller-gen
      - install:defaulter-gen
      - install:golangci-lint
      - install:chainsaw
      - install:crdoc
      - install:setup-envtest

  install:controller-gen:
    desc: Install controller-gen (CRD/RBAC/webhook + deepcopy codegen)
    silent: true
    status:
      - test -f {{.TOOL_DIR}}/controller-gen-{{.CONTROLLER_TOOLS_VERSION}}
    cmds:
      - |
        set -e
        mkdir -p {{.TOOL_DIR}}
        echo "Installing controller-gen {{.CONTROLLER_TOOLS_VERSION}}..."
        GOBIN={{.TOOL_DIR}} go install sigs.k8s.io/controller-tools/cmd/controller-gen@{{.CONTROLLER_TOOLS_VERSION}}
        mv {{.TOOL_DIR}}/controller-gen {{.TOOL_DIR}}/controller-gen-{{.CONTROLLER_TOOLS_VERSION}}
        ln -sf {{.TOOL_DIR}}/controller-gen-{{.CONTROLLER_TOOLS_VERSION}} {{.TOOL_DIR}}/controller-gen

  install:defaulter-gen:
    desc: Install defaulter-gen
    silent: true
    status:
      - test -f {{.TOOL_DIR}}/defaulter-gen-{{.DEFAULTER_GEN_VERSION}}
    cmds:
      - |
        set -e
        mkdir -p {{.TOOL_DIR}}
        echo "Installing defaulter-gen {{.DEFAULTER_GEN_VERSION}}..."
        GOBIN={{.TOOL_DIR}} go install k8s.io/code-generator/cmd/defaulter-gen@{{.DEFAULTER_GEN_VERSION}}
        mv {{.TOOL_DIR}}/defaulter-gen {{.TOOL_DIR}}/defaulter-gen-{{.DEFAULTER_GEN_VERSION}}
        ln -sf {{.TOOL_DIR}}/defaulter-gen-{{.DEFAULTER_GEN_VERSION}} {{.TOOL_DIR}}/defaulter-gen

  install:golangci-lint:
    desc: Install golangci-lint
    silent: true
    status:
      - test -f {{.TOOL_DIR}}/golangci-lint-{{.GOLANGCI_LINT_VERSION}}
    cmds:
      - |
        set -e
        mkdir -p {{.TOOL_DIR}}
        echo "Installing golangci-lint {{.GOLANGCI_LINT_VERSION}}..."
        GOBIN={{.TOOL_DIR}} go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@{{.GOLANGCI_LINT_VERSION}}
        mv {{.TOOL_DIR}}/golangci-lint {{.TOOL_DIR}}/golangci-lint-{{.GOLANGCI_LINT_VERSION}}
        ln -sf {{.TOOL_DIR}}/golangci-lint-{{.GOLANGCI_LINT_VERSION}} {{.TOOL_DIR}}/golangci-lint

  install:chainsaw:
    desc: Install chainsaw (e2e test runner)
    silent: true
    status:
      - test -f {{.TOOL_DIR}}/chainsaw-{{.CHAINSAW_VERSION}}
    cmds:
      - |
        set -e
        mkdir -p {{.TOOL_DIR}}
        echo "Installing chainsaw {{.CHAINSAW_VERSION}}..."
        GOBIN={{.TOOL_DIR}} go install github.com/kyverno/chainsaw@{{.CHAINSAW_VERSION}}
        mv {{.TOOL_DIR}}/chainsaw {{.TOOL_DIR}}/chainsaw-{{.CHAINSAW_VERSION}}
        ln -sf {{.TOOL_DIR}}/chainsaw-{{.CHAINSAW_VERSION}} {{.TOOL_DIR}}/chainsaw

  install:crdoc:
    desc: Install crdoc (renders CRDs into the API reference)
    silent: true
    status:
      - test -f {{.TOOL_DIR}}/crdoc-{{.CRDOC_VERSION}}
    cmds:
      - |
        set -e
        mkdir -p {{.TOOL_DIR}}
        echo "Installing crdoc {{.CRDOC_VERSION}}..."
        GOBIN={{.TOOL_DIR}} go install fybrik.io/crdoc@{{.CRDOC_VERSION}}
        mv {{.TOOL_DIR}}/crdoc {{.TOOL_DIR}}/crdoc-{{.CRDOC_VERSION}}
        ln -sf {{.TOOL_DIR}}/crdoc-{{.CRDOC_VERSION}} {{.TOOL_DIR}}/crdoc

  install:setup-envtest:
    desc: Install setup-envtest (downloads kube-apiserver/etcd for envtest)
    silent: true
    status:
      - test -f {{.TOOL_DIR}}/setup-envtest
    cmds:
      - |
        set -e
        mkdir -p {{.TOOL_DIR}}
        # setup-envtest is versioned loosely against controller-runtime, so we
        # pin to "latest" rather than a semver.
        echo "Installing setup-envtest {{.SETUP_ENVTEST_VERSION}}..."
        GOBIN={{.TOOL_DIR}} go install sigs.k8s.io/controller-runtime/tools/setup-envtest@{{.SETUP_ENVTEST_VERSION}}

  # Development tasks
  dev:build:
    desc: Build the inventory container image for development
    silent: true
    cmds:
      - |
        set -e
        echo "Building inventory container image: {{.INVENTORY_IMAGE_NAME}}:{{.INVENTORY_IMAGE_TAG}}"

        GIT_COMMIT=$(git rev-parse HEAD 2>/dev/null || echo "unknown")
        VERSION="v0.0.0-dev+${GIT_COMMIT:0:7}"
        GIT_TREE_STATE="clean"
        if [ -n "$(git status --porcelain 2>/dev/null)" ]; then
          GIT_TREE_STATE="dirty"
        fi
        BUILD_DATE=$(date -u '+%Y-%m-%dT%H:%M:%SZ' 2>/dev/null || echo "unknown")

        docker build \
          --build-arg VERSION="${VERSION}" \
          --build-arg GIT_COMMIT="${GIT_COMMIT}" \
          --build-arg GIT_TREE_STATE="${GIT_TREE_STATE}" \
          --build-arg BUILD_DATE="${BUILD_DATE}" \
          -t "{{.INVENTORY_IMAGE_NAME}}:{{.INVENTORY_IMAGE_TAG}}" .
        echo "Successfully built {{.INVENTORY_IMAGE_NAME}}:{{.INVENTORY_IMAGE_TAG}}"

  dev:load:
    desc: Load the inventory container image into the kind cluster
    silent: true
    cmds:
      - |
        set -e
        echo "Loading image {{.INVENTORY_IMAGE_NAME}}:{{.INVENTORY_IMAGE_TAG}} into kind cluster '{{.TEST_INFRA_CLUSTER_NAME}}'..."
        kind load docker-image "{{.INVENTORY_IMAGE_NAME}}:{{.INVENTORY_IMAGE_TAG}}" --name "{{.TEST_INFRA_CLUSTER_NAME}}"
        echo "Successfully loaded image into kind cluster"

  dev:setup:
    desc: Setup lightweight dev environment
    silent: true
    cmds:
      - task: test-infra:cluster-up
      - task: dev:build
      - task: dev:load
      - task: dev:deploy

  dev:deploy:
    desc: Deploy inventory using dev overlay
    silent: true
    cmds:
      - |
        set -e
        echo "Deploying inventory (dev overlay)..."
        task test-infra:kubectl -- apply -k config/overlays/dev

        echo "Waiting for inventory controller..."
        task test-infra:kubectl -- wait --for=condition=ready pod -l control-plane=inventory -n inventory-system --timeout=120s || echo "Inventory pods not ready yet"

        echo ""
        echo "Inventory deployed (dev overlay)!"

  dev:redeploy:
    desc: Quick rebuild and redeploy for dev environment
    deps:
      - dev:build
      - dev:load
    cmds:
      - |
        set -e
        echo "Redeploying inventory (dev)..."
        task test-infra:kubectl -- rollout restart -n inventory-system deployment/inventory-controller-manager || echo "Deployment not found, run 'task dev:deploy' first"

        echo "Waiting for rollout..."
        task test-infra:kubectl -- rollout status -n inventory-system deployment/inventory-controller-manager --timeout=120s || true
        echo "Redeployment complete!"
    silent: true

  # E2E Testing
  e2e:
    desc: Run chainsaw e2e tests
    deps:
      - install:chainsaw
    cmds:
      - "{{.TOOL_DIR}}/chainsaw test test/e2e/"
    silent: false