Taskfile.yml

---
version: '3'

silent: true
run: once
failfast: true

dotenv: ['.env']

vars:
  STANDARDLOOP_TASKFILES_VERSION: "v0.0.5"
  CLUSTERS_FOLDER: kind
  CLUSTERS:
    sh: find ./{{.CLUSTERS_FOLDER}} -maxdepth 1 -type f
  API_TAG: 0.0.7
  HELM_RELEASE_TIMEOUT: "180s"
  SUPPORTED_DOCKER_ENGINES: [colima, rancher]
  SUPPORTED_K8S_ENGINES: [kind]

includes:
  color: https://raw.githubusercontent.com/standardloop/taskfiles/refs/tags/{{.STANDARDLOOP_TASKFILES_VERSION}}/color.yml
  rancher: https://raw.githubusercontent.com/standardloop/taskfiles/refs/tags/{{.STANDARDLOOP_TASKFILES_VERSION}}/rancher.yml
  colima: https://raw.githubusercontent.com/standardloop/taskfiles/refs/tags/{{.STANDARDLOOP_TASKFILES_VERSION}}/colima.yml

tasks:
  default:
    aliases: [all, playground]
    silent: true
    prompt: "This will lanuch a cluster with infrastructure and deploy an app, are you ready for this?"
    cmds:
      - task: app

  pre-commit:
    cmds:
      - pre-commit run --all

  clean:
    aliases: [delete]
    ignore_error: true
    silent: true
    cmds:
      - task: tilt:clean
      - task: kind:clean
      # - task: compose:clean
      - task: docker-engine:clean

  print:
    cmds:
      - env
      - task: color:test

  # DOCKER ENGINE START
  docker-engine:test:
    requires:
      vars:
        - name: DOCKER_ENGINE
    preconditions:
      - sh: |
          {{range .SUPPORTED_DOCKER_ENGINES -}}
          if [ "{{.}}" = "{{$.DOCKER_ENGINE}}" ]; then exit 0; fi
          {{end -}}
          exit 1
        msg: |
          Invalid engine "{{.DOCKER_ENGINE}}".
          Supported engines are: {{join ", " .SUPPORTED_DOCKER_ENGINES}}
    cmds:
      - echo {{.DOCKER_ENGINE}}

  docker-engine:start:
    aliases: [docker-engine:run]
    requires:
      vars:
        - name: DOCKER_ENGINE
    preconditions:
      - sh: |
          {{range .SUPPORTED_DOCKER_ENGINES -}}
          if [ "{{.}}" = "{{$.DOCKER_ENGINE}}" ]; then exit 0; fi
          {{end -}}
          exit 1
        msg: |
          Invalid engine "{{.DOCKER_ENGINE}}".
          Supported engines are: {{join ", " .SUPPORTED_DOCKER_ENGINES}}
    cmds:
      - if: '{{eq .DOCKER_ENGINE "colima"}}'
        task: colima:start
        vars:
          FLAGS: "--network-address --cpu {{.DOCKER_ENGINE_CPUS}} --memory {{.DOCKER_ENGINE_MEMORY}}"
      - if: '{{eq .DOCKER_ENGINE "rancher"}}'
        task: rancher:start
        vars:
          FLAGS: "--virtual-machine.number-cpus {{.DOCKER_ENGINE_CPUS}} --virtual-machine.memory-in-gb {{.DOCKER_ENGINE_MEMORY}}"
    status:
      - '{{if eq .DOCKER_ENGINE "colima"}} colima status > /dev/null 2>&1 {{else}} true {{end}}'
      - '{{if eq .DOCKER_ENGINE "rancher"}} rdctl list-settings > /dev/null 2>&1 {{else}} true {{end}}'
      - docker info > /dev/null 2>&1

  docker-engine:clean:
    runs: once
    requires:
      vars:
        - name: DOCKER_ENGINE
    preconditions:
      - sh: |
          {{range .SUPPORTED_DOCKER_ENGINES -}}
          if [ "{{.}}" = "{{$.DOCKER_ENGINE}}" ]; then exit 0; fi
          {{end -}}
          exit 1
        msg: |
          Invalid engine "{{.DOCKER_ENGINE}}".
          Supported engines are: {{join ", " .SUPPORTED_DOCKER_ENGINES}}
    cmds:
      - if: '{{eq .DOCKER_ENGINE "colima"}}'
        task: colima:clean
        vars:
          FLAGS: "-f"
      - if: '{{eq .DOCKER_ENGINE "rancher"}}'
        task: rancher:clean
  # DOCKER ENGINE END

  # # COMPOSE START
  # compose:start:
  #   silent: true
  #   preconditions:
  #     - docker info > /dev/null 2>&1
  #   deps:
  #     - docker-engine:start
  #   cmds:
  #     - docker compose up -d

  # compose:clean:
  #   silent: true
  #   cmds:
  #     - |
  #       if docker info > /dev/null 2>&1; then
  #         docker compose down
  #       else
  #         echo "{{.TEXT_GRAY}}docker is not running so no compose to clean right now{{.TEXT_RESET}}"
  #       fi
  # # COMPOSE END

  # HELPER START
  wait-for-crd:
    internal: true
    silent: true
    run: always
    cmds:
      - |
        attempts=30
        while ! kubectl wait --for condition=established --timeout=60s crd {{.CRD}} > /dev/null 2>&1
        do
          echo "{{.TEXT_YELLOW}}Waiting for {{.CRD}} to be ready....{{.TEXT_RESET}}"
          sleep 5
          let attempts=$attempts-1
          if [ $attempts -eq 0 ]
          then
            echo "{{.TEXT_RED}}{{.CRD}} never got ready!{{.TEXT_RESET}}"
            exit 1
          fi
        done
        echo "{{.TEXT_GREEN}}{{.CRD}} came up!{{.TEXT_RESET}}"
    status:
      - kubectl wait --for condition=established --timeout=60s crd {{.CRD}} > /dev/null 2>&1

  # HELPER END

  # KIND START
  kind:
    silent: true
    aliases: ["cluster"]
    deps:
      - docker-engine:start
    cmds:
      - task: kind:cloud-provider:run

  # kind:print:
  #   silent: true
  #   cmds:
  #     - |
  #       {{range .CLUSTERS | splitArgs}}
  #         # echo "{{.}}"
  #         cat "{{.}}" | yq .name
  #       {{end}}

  kind:create:
    silent: true
    deps:
      - docker-engine:start
    cmds:
      - ./kind/local-registry-setup.sh
      - kind create cluster --config=kind/slke-1.yaml
      - ./kind/local-registry-finish.sh
    status:
      - kubectl cluster-info --context kind-slke-1

  # kind:create:
  #   silent: true
  #   deps:
  #     - docker-engine:start
  #   cmds:
  #     - |
  #       {{range .CLUSTERS | splitArgs}}
  #         cluster_name=$(yq '.name' {{.}})
  #         if ! kubectl cluster-info --context kind-${cluster_name} > /dev/null 2>&1
  #         then
  #           kind create cluster --config={{.}}
  #         else
  #           echo "$cluster_name already created"
  #         fi
  #       {{end}}
  #   status:
  #     - |
  #       {{range .CLUSTERS | splitArgs}}
  #         cluster_name=$(yq '.name' {{.}})
  #         kubectl cluster-info --context kind-${cluster_name}
  #       {{end}}

  kind:clean:
    silent: true
    deps:
      - kind:cloud-provider:clean
    cmds:
      - |
        if docker info > /dev/null 2>&1; then
          kind delete clusters --all
        else
          echo "{{.TEXT_GRAY}}docker is not running so no clusters to clean right now{{.TEXT_RESET}}"
        fi

  kind:cloud-provider:run:
    silent: true
    deps:
      - kind:create
    interactive: true
    cmds:
      - echo "{{.TEXT_YELLOW}}sudo needed for cloud-provider-kind{{.TEXT_RESET}}"
      - sudo -v
      - bash -c 'nohup sudo cloud-provider-kind --gateway-channel standard >/dev/null 2>&1 &'
      - echo "{{.TEXT_GREEN}}main pid -> $(pgrep sudo cloud-provider-kind){{.TEXT_RESET}}"
      - task: kind:cloud-provider:run:check-complete
    status:
      - pgrep sudo cloud-provider-kind

  kind:cloud-provider:run:check-complete:
    internal: true
    parallel: true
    deps:
      - task: wait-for-crd
        vars: { CRD: "httproutes.gateway.networking.k8s.io" }
      - task: wait-for-crd
        vars: { CRD: "gateways.gateway.networking.k8s.io" }
      - task: wait-for-crd
        vars: { CRD: "gatewayclasses.gateway.networking.k8s.io" }

  kind:cloud-provider:clean:
    silent: true
    interactive: true
    cmds:
      - |
        if pgrep sudo cloud-provider-kind > /dev/null 2>&1; then
          echo "{{.TEXT_YELLOW}}sudo needed for cloud-provider-kind{{.TEXT_RESET}}"
          sudo -v
          sudo pkill cloud-provider-kind
          echo "{{.TEXT_GREEN}}killed cloud-provider-kind{{.TEXT_RESET}}"
        else
          echo "{{.TEXT_GRAY}}cloud-provider-kind is not running{{.TEXT_RESET}}"
        fi

  kind:cloud-provider:restart:
    interactive: true
    cmds:
      - task: kind:cloud-provider:clean
      - task: kind:cloud-provider:run
  # KIND END

  # INFRA START
  infra:
    aliases: [infrastructure]
    deps:
      - infra:istio:install
      - infra:metrics-server:install
      - infra:kube-prom-stack:install
      # - infra:headlamp:install
      - infra:homer:install
      # - infra:grafana:install
      - infra:argo-rollouts:install
      # - infra:kiali:install

  infra:clean:
    deps:
      - task: infra:metrics-server:clean
      - task: infra:istio:clean
      - task: infra:kube-prom-stack:clean
      - task: infra:argo-rollouts:clean
      - task: infra:headlamp:clean
      - task: infra:homer:clean
      - task: infra:grafana:clean
      - task: infra:kiali:clean

  ## FLUX START
  infra:flux:install:
    deps:
      - kind
    cmds:
      - flux install --components=source-controller,helm-controller
    status:
      - |
        flux check --components=source-controller,helm-controller

  infra:flux:clean:
    aliases: [infra:flux:uninstall, infra:flux:delete]
    interactive: true
    cmds:
      - flux uninstall
  ## FLUX END

  ## SOURCES START
  infra:sources:install:
    deps:
      - infra:flux:install
    cmds:
      - kubectl apply -k deploy/infrastructure/sources
    status:
      - kubectl diff -k deploy/infrastructure/sources
   ## SOURCES END

  ## METRICS_SERVER START
  infra:metrics-server:install:
    deps:
      - infra:flux:install
      - infra:sources:install
    cmds:
      - kubectl apply -k deploy/infrastructure/metrics-server
    status:
      - kubectl diff -k deploy/infrastructure/metrics-server

  infra:metrics-server:clean:
    cmds:
      - kubectl delete -k deploy/infrastructure/metrics-server
  ## METRICS_SERVER END

  ## ISTIO START
  infra:istio:install:
    deps:
      - infra:sources:install
    cmds:
      - task: infra:istio:base:install
      - task: infra:istio:gateway:install
      # - task: infra:istio:update-etc-hosts

  infra:istio:base:install:
    deps:
      - infra:flux:install
      - infra:sources:install
    cmds:
      - kubectl apply -k deploy/infrastructure/istio/base
      - kubectl wait helmrelease/istio-base --for=condition=Ready --timeout={{.HELM_RELEASE_TIMEOUT}} -n istio-system
      - kubectl wait helmrelease/istiod --for=condition=Ready --timeout={{.HELM_RELEASE_TIMEOUT}}  -n istio-system
    status:
      - kubectl diff -k deploy/infrastructure/istio/base

  infra:istio:gateway:install:
    deps:
      - infra:flux:install
      - infra:sources:install
      - infra:istio:base:install
      - task: wait-for-crd
        vars: { CRD: "gateways.gateway.networking.k8s.io" }
      - task: wait-for-crd
        vars: { CRD: "gatewayclasses.gateway.networking.k8s.io" }
      - task: wait-for-crd
        vars: { CRD: "httproutes.gateway.networking.k8s.io" }
      - task: wait-for-crd
        vars: { CRD: "gateways.networking.istio.io" }
      - task: wait-for-crd
        vars: { CRD: "envoyfilters.networking.istio.io" }
      - task: wait-for-crd
        vars: { CRD: "virtualservices.networking.istio.io" }
    cmds:
      - kubectl apply -k deploy/infrastructure/istio/gateway
      - kubectl wait helmrelease/istio-gateway --for=condition=Ready --timeout={{.HELM_RELEASE_TIMEOUT}}  -n istio-gateway
    status:
      - kubectl diff -k deploy/infrastructure/istio/gateway

  infra:istio:update-etc-hosts:
    prompt: Do you want to update /etc/hosts ?
    silent: true
    deps:
      - infra:istio:install
    cmds:
      - |
        if [[ -n "{{.LOAD_BALANCER_IP}}" ]]; then
          echo {{.LOAD_BALANCER_IP}}
          sudo -v
          echo "{{.LOAD_BALANCER_IP}}      playground.local" | sudo tee -a /etc/hosts
        else
          echo "{{.TEXT_RED}}Couldn't find IP address{{.TEXT_RESET}}"
        fi
    status:
      - cat /etc/hosts | grep {{.LOAD_BALANCER_IP}}
    vars:
      LOAD_BALANCER_IP:
        sh: kubectl get gateway/playground-local-gateway -n istio-gateway | awk '{print $3}' | awk NR==2  # yamllint disable-line rule:line-length

  ## ISTIO END

  ## KIALI START
  infra:kiali:install:
    deps:
      - infra:flux:install
      - infra:sources:install
    cmds:
      - task: infra:kiali:operator:install
      - task: infra:kiali:instance:install

  infra:kiali:operator:install:
    deps:
      - infra:flux:install
      - infra:sources:install
    cmds:
      - kubectl apply -k deploy/infrastructure/kiali/operator
    status:
      - kubectl diff -k deploy/infrastructure/kiali/operator

  infra:kiali:operator:clean:
    cmds:
      - kubectl delete -k deploy/infrastructure/kiali/operator

  infra:kiali:instance:install:
    deps:
      - infra:flux:install
      - infra:sources:install
      - infra:kiali:operator:install
      - task: wait-for-crd
        vars: { CRD: "kialis.kiali.io" }
    cmds:
      - kubectl apply -k deploy/infrastructure/kiali/instance
    status:
      - kubectl diff -k deploy/infrastructure/kiali/instance

  infra:kiali:instance:clean:
    cmds:
      - kubectl delete -k deploy/infrastructure/kiali/instance

  infra:kiali:clean:
    cmds:
      - task: infra:kiali:instance:clean
      - task: infra:kiali:operator:clean


  ## KIALI END

  ## KUBE_PROM_STACK START
  infra:kube-prom-stack:install:
    deps:
      - infra:flux:install
      - infra:sources:install
    cmds:
      - task: infra:kube-prom-stack:chart:install
      - task: infra:kube-prom-stack:scrapers:install

  infra:kube-prom-stack:chart:install:
    deps:
      - infra:flux:install
      - infra:sources:install
    cmds:
      - kubectl apply -k deploy/infrastructure/kube-prom-stack
    status:
      - kubectl diff -k deploy/infrastructure/kube-prom-stack

  infra:kube-prom-stack:scrapers:install:
    deps:
      - infra:flux:install
      - infra:sources:install
      - infra:kube-prom-stack:chart:install
      - task: wait-for-crd
        vars: { CRD: "podmonitors.monitoring.coreos.com" }
      - task: wait-for-crd
        vars: { CRD: "servicemonitors.monitoring.coreos.com" }
    cmds:
      - kubectl apply -k deploy/infrastructure/kube-prom-stack/scrapers
    status:
      - kubectl diff -k deploy/infrastructure/kube-prom-stack/scrapers

  infra:kube-prom-stack:clean:
    cmds:
      - kubectl delete -k deploy/infrastructure/kube-prom-stack/scrapers
      - kubectl delete -k deploy/infrastructure/kube-prom-stack
  ## KUBE_PROM_STACK END

  ## ARGO_ROLLOUTS START
  infra:argo-rollouts:install:
    deps:
      - infra:flux:install
      - infra:sources:install
    cmds:
      - kubectl apply -k deploy/infrastructure/argo-rollouts
    status:
      - kubectl diff -k deploy/infrastructure/argo-rollouts

  infra:argo-rollouts:clean:
    cmds:
      - kubectl delete -k deploy/infrastructure/argo-rollouts
  ## ARGO_ROLLOUTS END

  ## HEADLAMP START
  infra:headlamp:install:
    deps:
      - infra:flux:install
      - infra:sources:install
    cmds:
      - kubectl apply -k deploy/infrastructure/headlamp
      # - kubectl -n kube-system create serviceaccount headlamp-admin  # wip
    status:
      - kubectl diff -k deploy/infrastructure/headlamp

  infra:headlamp:token:
    deps:
      - infra:headlamp:install
    cmds:
      - kubectl create clusterrolebinding headlamp-playground-admin --serviceaccount=kube-system:headlamp-admin --clusterrole=cluster-admin
      - kubectl create token headlamp-admin -n kube-system | pbcopy

  infra:headlamp:clean:
    cmds:
      - kubectl delete -k deploy/infrastructure/headlamp
  ## HEADLAMP END

  ## GRAFANA START
  infra:grafana:install:
    cmds:
      - task: infra:grafana:operator:install
      - task: infra:grafana:instance:install
      - task: infra:grafana:dashboards:install

  infra:grafana:clean:
    cmds:
      - task: infra:grafana:dashboards:clean
      - task: infra:grafana:instance:clean
      - task: infra:grafana:operator:clean

  ### GRAFANA OPERATOR START
  infra:grafana:operator:install:
    deps:
      - infra:flux:install
      - infra:sources:install
    cmds:
      - kubectl apply -k deploy/infrastructure/grafana/operator
    status:
      - kubectl diff -k deploy/infrastructure/grafana/operator

  infra:grafana:operator:clean:
    cmds:
      - kubectl delete -k deploy/infrastructure/grafana/operator
  ### GRAFANA INSTANCE START
  infra:grafana:instance:install:
    deps:
      - infra:flux:install
      - infra:sources:install
      - infra:grafana:operator:install
      - task: wait-for-crd
        vars: { CRD: "grafanas.grafana.integreatly.org" }
      - task: wait-for-crd
        vars: { CRD: "grafanadatasources.grafana.integreatly.org" }
    cmds:
      - kubectl apply -k deploy/infrastructure/grafana/instance
    status:
      - kubectl diff -k deploy/infrastructure/grafana/instance

  infra:grafana:instance:clean:
    cmds:
      - kubectl delete -k deploy/infrastructure/grafana/instance
  ### GRAFANA INSTANCE END
  ### GRAFANA DASHBOARDS START
  infra:grafana:dashboards:install:
    deps:
      - infra:flux:install
      - infra:sources:install
      - infra:grafana:operator:install
      - task: wait-for-crd
        vars: { CRD: "grafanadashboards.grafana.integreatly.org" }
    vars:
      NAMESPACE: grafana
    cmds:
      - |
        helm upgrade --install grafana-dashboards deploy/infrastructure/grafana/dashboards \
          -f deploy/infrastructure/grafana/dashboards/values.yaml \
          -f deploy/infrastructure/grafana/dashboards/env/playground.values.yaml \
          --namespace {{.NAMESPACE}}
    status:
      - |
        helm template deploy/infrastructure/grafana/dashboards --name-template=grafana-dashboards \
          --namespace {{.NAMESPACE}} \
          --is-upgrade \
          --no-hooks \
          -f deploy/infrastructure/grafana/dashboards/values.yaml \
          -f deploy/infrastructure/grafana/dashboards/env/playground.values.yaml | kubectl diff -f - -n {{.NAMESPACE}}

  infra:grafana:dashboards:clean:
    cmds:
      - helm delete grafana-dashboards -n grafana
  ### GRAFANA DASHBOARDS END
  ## GRAFANA END

  ## HOMER START
  infra:homer:install:
    deps:
      - infra:flux:install
      - infra:sources:install
    cmds:
      - kubectl apply -k deploy/infrastructure/homer
      - open "http://home.playground.local"
    status:
      - kubectl diff -k deploy/infrastructure/homer

  infra:homer:clean:
    cmds:
      - kubectl delete -k deploy/infrastructure/homer
  ## HOMER END

  # INFRA END

  # APP START
  tilt:
    aliases: ["app"]
    deps:
      - infra
    preconditions:
      - tilt verify-install
    cmds:
      - task: wait-for-crd
        vars: { CRD: "servicemonitors.monitoring.coreos.com" }
      - task: wait-for-crd
        vars: { CRD: "envoyfilters.networking.istio.io" }
      - task: wait-for-crd
        vars: { CRD: "virtualservices.networking.istio.io" }
      - tilt ci

  tilt:clean:
    cmds:
      - tilt down
  # APP END