Taskfile.yaml

---
version: 3
includes:
  git:
    taskfile: https://raw.githubusercontent.com/stuttgart-things/platform-engineering-showcase/refs/heads/main/taskfiles/git.yaml

vars:
  PROJECT:
    sh: echo ${PROJECT}
  BRANCH:
    sh: if [ $(git rev-parse --abbrev-ref HEAD) != "main" ]; then echo $(git rev-parse --abbrev-ref HEAD); else echo main ; fi
  CROSSPLANE_PACKAGE_REGISTRY: ghcr.io
  DAGGER_CROSSPLANE_MODULE: github.com/stuttgart-things/dagger/crossplane
  DAGGER_CROSSPLANE_MODULE_VERSION: v0.0.2
  TEST_RELEASE_TEMPLATES: tests/releases.yaml
  TEST_DIR: /tmp
  TEST_DEFAULTS: tests/defaults.yaml
  CLUSTER_NAME: helm-test
  PATH_KUBE_CONFIG: /home/sthings/.kube/kind-{{ .CLUSTER_NAME }}
  PATH_CLUSTER_TEMPLATE: tests/cluster.yaml
  DEV_CLUSTER_DIR: /tmp/helmfiles/cluster
  KIND_CONFIG_PATH: tests/cluster.yaml
  CLUSTER_INFRA_HELMFILE: /tmp/kind-infra.yaml
  TEST_FILES: tests/releases.yaml
  POST_CONFIG_FILES: tests/post-release.yaml
  DATE:
    sh: date +"%Y.%m%d.%H%M"

tasks:
  helmfile-action:
    desc: Get app name
    cmds:
      - task: "{{ .OPERATION }}"
        vars:
          HELMFILE_PATH: $(dirname "{{ .APP }}")
          HELMFILE: $(basename "{{ .APP }}")
    vars:
      OPERATION:
        sh: gum choose "render" "deploy"
      FOLDER:
        sh: gum choose "database" "monitoring" "cicd" "infra"
      APP:
        sh: |
          find "{{ .FOLDER }}" -maxdepth 1 -type f -name "*.yaml.gotmpl" | gum choose

  create-kind-cluster:
    desc: Create, Start & Configure kind cluster
    env:
      KUBECONFIG: "{{ .PATH_KUBE_CONFIG }}"
    cmds:
      - task: destroy-kind-cluster
      - |
        kind create cluster \
        --config {{ .KIND_CONFIG_PATH }} \
        --name {{ .CLUSTER_NAME }} \
        --kubeconfig {{ .PATH_KUBE_CONFIG }}

        kubectl get nodes --kubeconfig {{ .PATH_KUBE_CONFIG }}
      # - task: execute-base-cluster-setup
      # - task: output-ingress-nipio

  # create-vcluster-cluster:

  generate-helmfile:
    desc: Generate Helmfile configuration + values
    cmds:
      - |
        k2n gen \
        --examples-dirs "{{ .EXAMPLE_DIRS }}" \
        --ruleset-env-dir {{ .RULESET_ENV_DIR }} \
        --usecase {{ .USECASE }} \
        --example-file-ext ".yaml,.tf,.gotmpl,.md" \
        --verbose=true \
        --prompt-to-ai={{ .PROMPT }} \
        --instruction "Give me a helmfile + values for {{ .CHART }}. I deployed like this w/ helm cli: {{ .HELM_CLI_INSTALL_CMD }} .See examples for schema. Do not invent values - just use the information from the helm install command" \
        --destination "" # stdout
    vars:
      USECASE: helmfile
      EXAMPLE_DIRS: .k2n/helmfile-examples
      RULESET_ENV_DIR: .k2n/env-ruleset
      CHART:
        sh: gum input --placeholder "Enter helm chart name"
      HELM_CLI_INSTALL_CMD:
        sh: gum input --placeholder "Enter helm cli install command"
      PROMPT:
        sh: gum choose "true" "false" --header="Prompt to ai?"

  generate-helmfile-include:
    desc: Generate Helmfile include config for dev cluster
    cmds:
      - |
        k2n gen \
        --examples-dirs "{{ .EXAMPLE_DIRS }},./{{ .KIND }}" \
        --ruleset-env-dir {{ .RULESET_ENV_DIR }} \
        --usecase {{ .USECASE }} \
        --example-file-ext ".yaml,.tf,.gotmpl,.md" \
        --verbose=true \
        --prompt-to-ai={{ .PROMPT }} \
        --instruction "give me a {{ .USECASE }}-config for {{ .APP }} w/ {{ .INCLUDE }} include for cluster {{ .CLUSTER_NAME }}. {{ .USER_WORKING_DIR }}/{{ .KIND }}/{{ .APP }}.yaml.gotmpl is local path no description. see examples for schema" \
        --destination "" # stdout
    vars:
      USECASE: helmfile
      EXAMPLE_DIRS: .k2n/include-examples
      RULESET_ENV_DIR: .k2n/env-ruleset
      RULESET_USECASE_DIR: .k2n/rulesets/terraformvm
      PROMPT:
        sh: gum choose "true" "false" --header="Prompt to ai?"
      APP:
        sh: gum input --placeholder "Enter app name"
      KIND:
        sh: gum choose "infra" "database" "monitoring" "apps" "cicd"
      INCLUDE:
        sh: gum choose "local" "git" --header="Local or git include?"
      CLUSTER_NAME:
        sh: gum choose "dev"

  branch:
    desc: Create branch from main
    cmds:
      - git checkout main
      - git branch
      - git pull
      - |
        echo "Enter to be created (remote) branch:"
        read BRANCH_NAME;
        git checkout -b ${BRANCH_NAME}
        git push origin ${BRANCH_NAME}
      - git branch
      - git branch --set-upstream-to=origin/main ${BRANCH_NAME}

  release:
    deps:
      - check
    desc: push new version
    cmds:
      - task: pr
      - npx semantic-release --dry-run
      - npx semantic-release --debug --no-ci
      - echo released version $(git describe --tags --abbrev=0)

  install-release:
    desc: Test a release
    cmds:
      - rm -rf {{ .TEST_DIR }}/* && mkdir {{ .TEST_DIR }} || true
      - |
        release=$(yq '.template | keys | .[]' {{ .TEST_RELEASE_TEMPLATES }} | gum choose)
        folder=$(find {{ .SEARCH_FOLDERS }} -type f -name "${release}.yaml" -exec dirname {} \; | sort -u)
        domain=$(kubectl get nodes -o json | jq -r '.items[] | select(.metadata.labels."ingress-ready" == "true") | .status.addresses[] | select(.type == "InternalIP") | .address').nip.io
        clusterIssuer=$(kubectl get clusterissuer -o jsonpath='{.items[0].metadata.name}')
        storageClass=standard

        machineshop render \
        --source local \
        --template {{ .TEST_RELEASE_TEMPLATES }} \
        --output file \
        --kind multikey \
        --key ${release} \
        --destination {{ .TEST_DIR }}/${release}.yaml \
        --values "source={{ .USER_WORKING_DIR }}/${folder}/${release}.yaml, domain=${domain}, clusterIssuer=${clusterIssuer}, storageClass=${storageClass}"

        helmfile template -f {{ .TEST_DIR }}/${release}.yaml

        SELECTED_KUBECONFIG=$(gum choose {{ .ALL_KUBECONFIGS }})
        echo SWITCHING TO ${SELECTED_KUBECONFIG//\"/}
        printf "\n\nexport KUBECONFIG={{ .KUBECONFIG_FOLDER }}/${SELECTED_KUBECONFIG//\"/}\n\n"

        export KUBECONFIG={{ .KUBECONFIG_FOLDER }}/${SELECTED_KUBECONFIG//\"/}
        kubectl get nodes

        code {{ .TEST_DIR }}/${release}.yaml

        gum confirm "Do you want to apply ${release}?" || exit 0

        echo "Apply: helmfile apply -f {{ .TEST_DIR }}/${release}.yaml"
        helmfile apply -f {{ .TEST_DIR }}/${release}.yaml

        for i in {1..20}; do
          gum spin --spinner dot --title "Waiting for all pods to be running..." -- sleep 5
          kubectl get po -A | grep -v "kube-system" | grep -v "Completed"
          kubectl get ingress -A

          choice=$(gum choose "SKIP WAITING" "CONTINUE WAITING")
          if [[ "$choice" == "SKIP WAITING" ]]; then
            echo "Skipping loop."
            break
          fi
        done

        # POST CONFIG
        #if $(yq e ".template.${release}" {{ .POST_CONFIG_FILES }}) != "null"; then
        #  echo Key ${release} found
        #fi

        gum confirm "Do you want to destroy ${release}?" || exit 0
        helmfile destroy -f {{ .TEST_DIR }}/${release}.yaml
    vars:
      KUBECONFIG_FOLDER: ~/.kube
      SEARCH_FOLDERS: "infra apps database cicd"
      ALL_KUBECONFIGS:
        sh: ls {{ .KUBECONFIG_FOLDER }} | grep -v "^cache$" | xargs -n1 printf '"%s" '

  uninstall-release:
    desc: Uninstall a release
    cmds:
      - |
        SELECTED_KUBECONFIG=$(gum choose {{ .ALL_KUBECONFIGS }})
        echo SWITCHING TO ${SELECTED_KUBECONFIG//\"/}
        printf "\n\nexport KUBECONFIG={{ .KUBECONFIG_FOLDER }}/${SELECTED_KUBECONFIG//\"/}\n\n"

        export KUBECONFIG={{ .KUBECONFIG_FOLDER }}/${SELECTED_KUBECONFIG//\"/}
        kubectl get nodes

        ALL_HELM_RELEASES=$(helm ls -A | awk 'NR>1 {print $1 ":" $2}')
        echo ${ALL_HELM_RELEASES}

        SELECTED_RELEASE=$(echo "$ALL_HELM_RELEASES" | gum choose)

        # Extract release name and namespace
        RELEASE_NAME=$(echo "$SELECTED_RELEASE" | cut -d':' -f1)
        NAMESPACE=$(echo "$SELECTED_RELEASE" | cut -d':' -f2)

        # Uninstall the Helm release
        helm uninstall "$RELEASE_NAME" -n "$NAMESPACE"
    vars:
      KUBECONFIG_FOLDER: ~/.kube
      ALL_KUBECONFIGS:
        sh: ls {{ .KUBECONFIG_FOLDER }} | grep -v "^cache$" | xargs -n1 printf '"%s" '

  render:
    desc: Render helmfile
    vars:
      DAGGER_MODULE: github.com/stuttgart-things/dagger/helm
      DAGGER_MODULE_VERSION: v0.25.0
    cmds:
      - |
        echo HELMFILE_PATH: {{ .HELMFILE_PATH }}
        echo HELMFILE: {{ .HELMFILE }}
      - |
        dagger call -m {{ .DAGGER_MODULE }}@{{ .DAGGER_MODULE_VERSION }} \
        render-helmfile \
        --src {{ .HELMFILE_PATH }} \
        --helmfileName {{ .HELMFILE }} \
        --registry-secret file://~/.docker/config.json \
        -vv --progress plain

  execute-base-cluster-setup:
    desc: Execute base setup on kind cluster
    vars:
      RANDOM:
        sh: |
          echo $RANDOM % 5555 + 1 | bc
    env:
      HELMFILE_CACHE_HOME: /tmp/helmfile/cache/{{ .DATE }}/{{ .RANDOM }}
      KUBECONFIG: "{{ .PATH_KUBE_CONFIG }}"
    cmds:
      - |
        gum confirm "Do you want to execute base cluster setup on {{ .CLUSTER_NAME }}?" || exit 0

        machineshop render \
        --source local \
        --template {{ .PATH_CLUSTER_TEMPLATE }} \
        --output file \
        --kind multikey \
        --key kind-infra \
        --destination {{ .CLUSTER_INFRA_HELMFILE }} \
        --values "source={{ .USER_WORKING_DIR }},clusterName={{ .CLUSTER_NAME }}"

        START_TIME=$(date +%s)
        TIMEOUT=180 # seconds

        helmfile init

        while true; do

          echo "RUNNING HELMFILE APPLY..."
          helmfile apply -f {{ .CLUSTER_INFRA_HELMFILE }} --kubeconfig {{ .PATH_KUBE_CONFIG }} && \
          echo "RUNNING HELMFILE SYNC..." && \
          helmfile sync -f {{ .CLUSTER_INFRA_HELMFILE }} --kubeconfig {{ .PATH_KUBE_CONFIG }} && \
          { echo "Commands succeeded. Exiting loop."; break; }

          CURRENT_TIME=$(date +%s)
          ELAPSED=$(( CURRENT_TIME - START_TIME ))

          if [ $ELAPSED -ge ${TIMEOUT} ]; then
            echo "COMMANDS ARE STILL FAILING AFTER ONE MINUTE. EXITING WITH ERROR."
            exit 1
          fi

          echo "RETRYING IN 5 SECONDS..."
          sleep 5

        done

        kubectl get po -A --kubeconfig {{ .PATH_KUBE_CONFIG }}

  destroy-kind-cluster:
    desc: Destroy kind cluster
    env:
      KUBECONFIG: "{{ .PATH_KUBE_CONFIG }}"
    cmds:
      - |
        if kind get clusters | grep -wq "{{ .CLUSTER_NAME }}"; then

          kubectl get nodes -o wide --kubeconfig {{ .PATH_KUBE_CONFIG }}

          # DELETE EXISTING CLUSTER
          gum confirm "Do you want to destroy existing cluster {{ .CLUSTER_NAME }}?" || exit 0
          echo "Cluster '{{ .CLUSTER_NAME }}' exists (already). Deleting it..."
          kind delete clusters "{{ .CLUSTER_NAME }}"

        fi

  output-ingress-nipio:
    desc: Output ingress domain
    env:
      KUBECONFIG: "{{ .PATH_KUBE_CONFIG }}"
    cmds:
      - |
        echo *.$(kubectl get nodes -o json | jq -r '.items[] | select(.metadata.labels."ingress-ready" == "true") | .status.addresses[] | select(.type == "InternalIP") | .address').nip.io

  tests-create-includes:
    desc: Create test files
    cmds:
      - rm -rf {{ .TEST_DIR }}/* && mkdir {{ .TEST_DIR }} || true
      - |
        mkdir -p {{ .RENDER_DIR }}

        for release in $(yq '.template | keys | .[]' {{ .TEST_FILES }}); do

          echo "Creating: ${release} include"

            folder=$(find {{ .SEARCH_FOLDERS }} -type f -name "${release}.yaml" -exec dirname {} \; | sort -u)
            clusterIssuer=$(kubectl get clusterissuer -o jsonpath='{.items[0].metadata.name}')
            storageClass=standard

            machineshop render \
            --source local \
            --template {{ .TEST_RELEASE_TEMPLATES }} \
            --output file \
            --kind multikey \
            --key ${release} \
            --destination {{ .RENDER_DIR }}/${release}.yaml \
            --defaults {{ .TEST_DEFAULTS }} \
            --values "source={{ .USER_WORKING_DIR }}/${folder}/${release}.yaml"

            helmfile template -f {{ .RENDER_DIR }}/${release}.yaml

        done
    vars:
      RENDER_DIR: "/tmp/{{ .DATE }}"

  tests-render-includes:
    desc: Test render includes
    cmds:
      - task: tests-create-includes
      - |
        for release in $(yq '.template | keys | .[]' {{ .TEST_FILES }}); do

          echo "Rendering: ${release}"
          export HELMFILE_CACHE_HOME={{ .TEST_DIR }}/cache
          helmfile deps -f {{ .TEST_DIR }}/${release}.yaml
          helmfile template -f {{ .TEST_DIR }}/${release}.yaml

        done

  run-pre-commit-hook:
    deps:
      - check
    desc: "Run the pre-commit hook script to replace .example.com with .example.com"
    cmds:
      - |
        # Find all YAML files in the repository recursively, excluding Taskfile.yaml
        files=$(find . -type f \( -name "*.yaml" -o -name "*.yml" -o -name "*.yml" -o -name "*.md" \) ! -name "Taskfile.yaml")

        # Loop through each file
        for file in $files; do
          # Skip binary files
          if file "$file" | grep -q "text"; then
            # Replace the string and update the file
            sed -i 's/\.sva\.de/\.example\.com/g' "$file"
          fi
        done

        # Add all modified YAML files back to staging
        git add $(git ls-files --modified | grep -E '\.ya?ml$')

        exit 0
    silent: false

  do:
    desc: Select a task to run
    cmds:
      - |
        # Extract task names (keep internal colons, remove only trailing colon)
        task_name=$(task -l | awk '/^\*/ {print $2}' | sed 's/:$//' | gum choose)

        # Run the selected task
        [ -n "$task_name" ] && task "$task_name"

  render-helmfile-local:
    desc: Render helmfile locally using dagger helm module
    cmds:
      - |
        set -e

        # Find helmfiles in specific directories
        HELMFILES=$(find apps cicd database infra monitoring -maxdepth 1 -type f \( -name "*.yaml.gotmpl" -o -name "*.yaml" \) 2>/dev/null | sort)

        if [ -z "$HELMFILES" ]; then
          echo "❌ No helmfiles found in apps, cicd, database, infra, or monitoring directories"
          exit 1
        fi

        # Let user choose helmfile
        HELMFILE=$(echo "$HELMFILES" | gum choose --header "Select helmfile to render:")

        if [ -z "$HELMFILE" ]; then
          echo "❌ No helmfile selected"
          exit 1
        fi

        # Extract directory and filename
        HELMFILE_DIR=$(dirname "$HELMFILE")
        HELMFILE_NAME=$(basename "$HELMFILE")

        # Normalize path (remove ./ prefix)
        SRC="${HELMFILE_DIR#./}"
        [ "$SRC" = "." ] && SRC="."

        echo ""
        echo "📋 Rendering helmfile:"
        echo "  Source  : $SRC"
        echo "  File    : $HELMFILE_NAME"
        echo ""

        # Render using dagger
        dagger call -m github.com/stuttgart-things/dagger/helm@v0.57.0 \
          helmfile-operation \
          --operation template \
          --src "$SRC" \
          --helmfile-ref "$HELMFILE_NAME" \
          --progress plain -vv