deployments.helmfile.yaml

values:
  - statevalues/000-globals.yaml
  - statevalues/001-clusters.yaml
  - {{ requiredEnv "HELMFILE_DEPLOY_STATE_VALUES_DIR" }}/*
---
bases:
  - {{ requiredEnv "HELMFILE_DEPLOY_ENVIRONMENTS_DIR" }}/index.yaml
---
bases:
  - helmDefaults.yaml
---


releases:
  {{- /*
      ---------------------------------------------------------
      Basic values declarations
      ---------------------------------------------------------
  */ -}}
  {{- $stateVals := .Values }}
  {{- $envVals := .Environment.Values -}}
  {{- $namespace := .Namespace -}}

  {{- /*
      The target "cluster"
      Note: simpler syntax should just be: https://github.com/Masterminds/sprig/issues/151
  */ -}}
  {{- $targetCluster := (pick $stateVals.clusters $stateVals.targetCluster) | values | first }}


  {{- /*
      ---------------------------------------------------------
      These two values are fetched from the helmfile "state values"
      and are typically set via invocation:
        "--state-values-set bootstrapSecret=x,creatorId=y"
      ---------------------------------------------------------
  */ -}}
  {{ $bootstrapSecretValue := $stateVals | getOrNil "bootstrapSecret" }}
  {{ $creatorId := $stateVals | getOrNil "creatorId"  }}

  {{- /*
      ---------------------------------------------------------
      For each [helmfile-environment].environments.[environment] loaded/found
      in yaml files under environments/[helmfile-environment]/* we loop over
      each environment's context(s) declared "services", one by one
      and generate a "appdeploy" helmfile "release"

      NOTE! since the environment's context yaml file can potentially
      list the same service.version across multiple service elements
      we keep track of this as to not create duplicate releases.

      Why can a "version" be declared across multiple "services"?
      Because "services" are just named things we can route traffic
      to and the conduits.helmfile.yaml template also processes the same
      file. In this case the "version" just nets diff selectors
      on conduit services. In any case, it is a legit case and permitted
      ---------------------------------------------------------
  */ -}}

  {{- range $currEnvironmentName,$currEnvironment := $envVals.environments }}
  {{- range $currContextName,$currContext := $currEnvironment.contexts }}
  {{ $versionsReleased := list }}
  {{- range $currService := $currContext.services }}

  {{- /* version check */ -}}
  {{ if not (has $currService.version $versionsReleased) }}

  {{ $versionsReleased = append $versionsReleased $currService.version }}

  {{- /*
      Used by `tpl` variable parsing below. The caller can specify tpl parsed values i.e.
        "{{ .helmfile.[path] }}" If ".helmfile" is NOT present the "{{bracketed}}" will
      be left alone and assumed to be consumable by the chart in the release
  */ -}}
  {{- $helmfileVarsDict := dict "helmfile" (dict "clusters" $stateVals.clusters "targetCluster" $targetCluster "envVals" $envVals "stateVals" $stateVals "namespace" $namespace "service" $currService "context" $currContext "environment" $currEnvironment) }}

  {{- /*
      ---------------------------------------------------------
      "chartConfigs"
      ---------------------------------------------------------
      Here we grab the "chartConfigs" from the following possible locations in order of priority:

        1. The current "[helmfile-environment].environments.[environment].contexts.[context].services.[service]" we are iterating over
            i.e. this would be declared in environments/[helmfile-environment]/[any-env-file.yaml]

        2. The current "[helmfile-environment].environments.[environment].contexts.[context]" we are iterating over
            i.e. this would be declared in environments/[helmfile-environment]/[any-env-file.yaml]

        3. The current "[helmfile-environment].environments.[environment]" we are iterating over
            i.e. this would be declared in environments/[helmfile-environment]/[any-env-file.yaml]

        4. The top level helmfile-environment's "chartConfigs"
            i.e. this would be declared in environments/[helmfile-environment]/chartconfigs.yaml

        5. The targetCluster's "chartConfigs" (clusters.[targetCluster].chartConfigs)
            i.e. this would be declared in: statevalues/001-clusters.yaml or any other HELMFILE_DEPLOY_STATE_VALUES_DIR yaml

        6. The global state values "chartConfigs"
            i.e. this would be declared in: statevalues/000-globals.yaml or any other HELMFILE_DEPLOY_STATE_VALUES_DIR yaml

        7. Note with the sprig "merge" function: see oddities: https://github.com/Masterminds/sprig/issues/120

  */ -}}
  {{ $chartConfigs := dict }}
  {{ $chartConfigs := hasKey $stateVals "chartConfigs" | ternary (deepCopy ((hasKey $stateVals "chartConfigs") | ternary ($stateVals | getOrNil "chartConfigs") dict) | mergeOverwrite $chartConfigs) $chartConfigs }}
  {{ $chartConfigs := hasKey $targetCluster "chartConfigs" | ternary (deepCopy ((hasKey $targetCluster "chartConfigs") | ternary ($targetCluster | getOrNil "chartConfigs") dict) | mergeOverwrite $chartConfigs) $chartConfigs }}
  {{ $chartConfigs := hasKey $envVals "chartConfigs" | ternary (deepCopy ((hasKey $envVals "chartConfigs") | ternary ($envVals | getOrNil "chartConfigs") dict) | mergeOverwrite $chartConfigs) $chartConfigs }}
  {{ $chartConfigs := hasKey $currEnvironment "chartConfigs" | ternary (deepCopy ((hasKey $currEnvironment "chartConfigs") | ternary ($currEnvironment | getOrNil "chartConfigs") dict) | mergeOverwrite $chartConfigs) $chartConfigs }}
  {{ $chartConfigs := hasKey $currContext "chartConfigs" | ternary (deepCopy ((hasKey $currContext "chartConfigs") | ternary ($currContext | getOrNil "chartConfigs") dict) | mergeOverwrite $chartConfigs) $chartConfigs }}
  {{ $chartConfigs := hasKey $currService "chartConfigs" | ternary (deepCopy ((hasKey $currService "chartConfigs") | ternary ($currService | getOrNil "chartConfigs") dict) | mergeOverwrite $chartConfigs) $chartConfigs }}

  {{- /*
      ---------------------------------------------------------
      Generate a "releaseIdentifier"

      [envVals.appname]-[environment.context]-[currEnvironment.service.version]-[envVals.classifier]
      ---------------------------------------------------------
  */ -}}
  {{- $releaseIdentifier := printf "%s-%s-%s-%s" (hasKey $envVals "releaseBaseName" | ternary ($envVals | getOrNil "releaseBaseName") $envVals.appname) $currContextName ($currService.version | replace "." "-") (hasKey $envVals "classifier" | ternary ($envVals | getOrNil "classifier") "NOCLASSIFIER") }}
  {{- $releaseIdentifier := $releaseIdentifier | replace "-NOCLASSIFIER" "" -}}
  {{- $releaseIdentifier := $releaseIdentifier | replace "NOCLASSIFIER" "" -}}
  {{- $releaseIdentifier := $releaseIdentifier | replace "-%!s(<nil>)" "" }}


  {{- /*
      ---------------------------------------------------------
      Build BASE values file references -> $valuesFiles

      The "chartConfigs.appdeploy" chart configuration can declare one or more named
      "availableBaseValueSets" which define sets of supplemental "values.yaml" files.
      Here we inspect the "baseValuesSets" list of referenced "set" names to determine
      the actual list of "values.yaml" files to apply to the chart which are ultimately
      located under the configured "chartConfigs.appdeploy.chartValues.baseValuesRootDir" path

      @see statevalues/000-globals.yaml for more info
      ---------------------------------------------------------
  */ -}}
  {{ $valuesFiles := dict "files" list }}
  {{ $valueBaseParseVars := dict "appname" $envVals.appname "classifier" ($envVals | getOrNil "classifier") "environmentName" $currEnvironmentName "contextName" $currContextName "service" $currService }}

  {{- /* Get list of all named "sets" we actually want to use */ -}}
  {{ range $baseValueSetName := $chartConfigs.appdeploy.chartValues.baseValueSets }}

    {{- /* Load the actual referenced set by name from 'availableBaseValueSets' */ -}}
    {{ $baseValues := (pick $chartConfigs.appdeploy.chartValues.availableBaseValueSets $baseValueSetName) | values | first }}

    {{- /* For each one, lets add it to the list of overall values files we will reference below */ -}}
    {{ range $valueBase := $baseValues }}
      {{ $parsedValueBase := tpl $valueBase $valueBaseParseVars }}
      {{ $_ := append $valuesFiles.files (printf "%s/values/%s/values.yaml" $chartConfigs.appdeploy.chartValues.baseValuesRootDir $parsedValueBase) | set $valuesFiles "files" }}
    {{ end }}
  {{ end }}

  {{- /*
      Each "service" can declare a "hooks" object, each top-level "key" of it
      designates the name of the hook and it's values folder within the
      "chartConfigs.appdeploy.chartValues.baseValuesRootDir" location
      for supplemental values particular to that hook.
  */ -}}
  {{ if hasKey $currService "hooks"}}
    {{ range $currHookName,$currHook := $currService.hooks }}
      {{ $_ := append $valuesFiles.files (printf "%s/values/hooks/%s/values.yaml" $chartConfigs.appdeploy.chartValues.baseValuesRootDir $currHookName) | set $valuesFiles "files" }}
    {{ end }}
  {{ end }}


  {{- /*
      ---------------------------------------------------------
      Helmfile RELEASE generation:

      Generate an actual helmfile release of the "appdeploy" chart
      for the currentEnvironment.currentContext.currService
      with its desired state expressed in helm values
      ---------------------------------------------------------
  */ -}}
  - name: {{ $releaseIdentifier }}
    labels:
      app: {{ $envVals.appname }}
      context: {{ $currContextName }}
      version: {{ ($currService.version | replace "." "-") }}
      name: {{ $currService.name }}
    namespace: {{ $namespace }}
    chart: {{ $chartConfigs.appdeploy.chart }}
    {{ if hasKey $chartConfigs.appdeploy "version" }}
    version: {{ $chartConfigs.appdeploy.version }}
    {{ end }}

    {{ if $currService.installed }}
    installed: true
    {{ else }}
    installed: false
    {{ end }}

    {{- /* Permit forced override of the default helm tillerNamespace (defined in helmDefaults.yaml)
          (set this via helmfile --state-values-set forceHelmTillerNamespace=[namespace]) */ -}}
    {{ if hasKey $stateVals "forceHelmTillerNamespace" }}
    tillerNamespace: {{ $stateVals.forceHelmTillerNamespace }}
    {{ end }}

    {{- /* Permit forced override of the default helm timeout (defined in helmDefaults.yaml)
          (set this via helmfile --state-values-set forceHelmTimeout=[N seconds]) */ -}}
    {{ if hasKey $stateVals "forceHelmTimeout" }}
    timeout: {{ $stateVals.forceHelmTimeout }}
    {{ end }}

    {{- /* Permit forced override of the default helm 3.2+ create-namespace behavior (defined in helmDefaults.yaml)
          (set this via helmfile --state-values-set forceHelmCreateNamespace=[true|false]) */ -}}
    {{ if hasKey $stateVals "forceHelmCreateNamespace" }}
    createNamespace: {{ $stateVals.forceHelmCreateNamespace }}
    {{ end }}

    values:
      {{- /*
          ---------------------------------------------------------
          RENDER: BASE values file references
          note: "exec" hack can go away when
          https://github.com/roboll/helmfile/issues/766 is addressed
          ---------------------------------------------------------
      */ -}}
      {{- range $valueFile := $valuesFiles.files }}
      {{ if eq (exec "./fileexists.sh" (list $valueFile)) "true" }}
      - {{$valueFile}}
      {{ end }}
      {{ end }}

      {{/*
          ---------------------------------------------------------
          Inline custom values

          These values, combined with the "bases" above yield
          the overall set of "values" customizations passed to helm
          ---------------------------------------------------------
      */ -}}
      - app:
          name: {{ $envVals.appname }}
          context: {{ $currContextName }}
          environment: {{ $currEnvironmentName }}
          {{ if $envVals | getOrNil "classifier" }}
          classifier: {{ $envVals.classifier }}
          {{ end }}

        creatorId: {{ $creatorId }}
        replicaCount: {{ $chartConfigs.appdeploy.chartValues.values.replicaCount }}

        image:
          {{ if hasKey $chartConfigs.appdeploy.chartValues.values "image" }}
            {{ if hasKey $chartConfigs.appdeploy.chartValues.values.image "repository" }}
          repository: {{ $chartConfigs.appdeploy.chartValues.values.image.repository }}
            {{ end }}
          {{ end }}
          tag: "{{ $currService.version }}"

        {{ if hasKey $chartConfigs.appdeploy.chartValues.values "containerPorts" }}
        containerPorts:
{{ toYaml $chartConfigs.appdeploy.chartValues.values.containerPorts | indent 12 }}
        {{ end }}

        {{ if hasKey $chartConfigs.appdeploy.chartValues.values "ingress" }}
        ingress:
          {{ if hasKey $chartConfigs.appdeploy.chartValues.values.ingress "dns" }}
          dns:
            {{ toYaml $chartConfigs.appdeploy.chartValues.values.ingress.dns | indent 0 }}
          {{ end }}
          {{ if hasKey $chartConfigs.appdeploy.chartValues.values.ingress "tls" }}
          tls:
            {{ toYaml $chartConfigs.appdeploy.chartValues.values.ingress.tls | indent 0 }}
          {{ end }}
          {{ if hasKey $chartConfigs.appdeploy.chartValues.values.ingress "metadata" }}
          metadata:
            {{ if hasKey $chartConfigs.appdeploy.chartValues.values.ingress.metadata "labels" }}
            labels:
              {{ range $labelName,$labelValue := $chartConfigs.appdeploy.chartValues.values.ingress.metadata.labels }}
              "{{$labelName}}": "{{ contains ".helmfile" $labelValue | ternary (tpl $labelValue $helmfileVarsDict) $labelValue }}"
              {{ end }}
            {{ end }}
            {{ if hasKey $chartConfigs.appdeploy.chartValues.values.ingress.metadata "annotations" }}
            annotations:
              {{ range $annotationName,$annotationValue := $chartConfigs.appdeploy.chartValues.values.ingress.metadata.annotations }}
              "{{$annotationName}}": "{{ contains ".helmfile" $annotationValue | ternary (tpl $annotationValue $helmfileVarsDict) $annotationValue }}"
              {{ end }}
            {{ end }}
          {{ end }}
        {{ end }}

        {{ if hasKey $chartConfigs.appdeploy.chartValues.values "healthcheck" }}
        healthcheck:
{{ toYaml $chartConfigs.appdeploy.chartValues.values.healthcheck | indent 12 }}
        {{ end }}

        {{ if hasKey $chartConfigs.appdeploy.chartValues.values "resources" }}
        resources:
{{ toYaml $chartConfigs.appdeploy.chartValues.values.resources | indent 12 }}
        {{ end }}

        {{ if hasKey $chartConfigs.appdeploy.chartValues.values "autoscaling" }}
        autoscaling:
{{ toYaml $chartConfigs.appdeploy.chartValues.values.autoscaling | indent 12 }}
        {{ end }}

        {{ if hasKey $chartConfigs.appdeploy.chartValues.values "disruptionBudget" }}
        disruptionBudget:
{{ toYaml $chartConfigs.appdeploy.chartValues.values.disruptionBudget | indent 12 }}
        {{ end }}

        bootstrapSecret:
          k8Secret:
            secretValue: "{{ $bootstrapSecretValue }}"

        {{- if $chartConfigs.appdeploy.chartValues.values | getOrNil "env" }}
        env:
          {{- range $key,$val := $chartConfigs.appdeploy.chartValues.values.env }}
            {{- if and (hasKey $val "value") $val.value }}
          {{ $key }}:
              {{ if contains ".helmfile" $val.value }}
            value: {{ tpl $val.value $helmfileVarsDict }}
              {{ else }}
            value: {{ $val.value }}
              {{ end }}
            {{ else }}
          {{ $key }}:
            value: ""
            {{ end }}
          {{ end }}
        {{ end }}

        {{ if hasKey $chartConfigs.appdeploy.chartValues.values "hooks" }}
        hooks:

          {{- /*
              DEFAULT hooks (hooks.default.[n])

              Dump out all non-custom appdeploy "hooks.default" defined in "chartConfigs" blocks
          */ -}}
          {{ if hasKey $chartConfigs.appdeploy.chartValues.values.hooks "default" }}
{{ toYaml $chartConfigs.appdeploy.chartValues.values.hooks.default | indent 12 }}
          {{ end }}

          {{- /*
            CUSTOM Hooks: (hooks.custom.[n])

            Here we manually rewrite it all as w support variable
            tpl parsing. This is not entirely complete as it does
            not cover re-rendering all possible vars as the use
            case at this point is pretty limited whereby the majority
            of 'custom' entries only configure the options below
            while the majority of other configuration for them is
            sourced from baseValues valuesFiles above. Below we
            only support enabled, variables and the bootstrapSecret
          */ -}}

          {{ if hasKey $chartConfigs.appdeploy.chartValues.values.hooks "custom" }}
          custom:
            {{ range $currHookName,$currHook := $chartConfigs.appdeploy.chartValues.values.hooks.custom }}

            {{ $currHookName }}:

              {{ if not (empty $currHook) }}
              {{ if hasKey $currHook "values" }}

              {{ if hasKey $currHook.values "enabled" }}
              enabled: {{ $currHook.values.enabled }}
              {{ end }}

              {{ if hasKey $currHook.values "variables" }}
              variables:
                {{ range $name,$value := $currHook.values.variables }}
                  {{ if contains ".helmfile" $value }}
                {{ $name }}: {{ tpl $value $helmfileVarsDict }}
                {{ else }}
                {{ $name }}: {{ $value }}
                  {{ end }}
                {{ end }}
              {{ end }}

              {{ end }} {{- /* END: if not (empty $currHook) */ -}}
              {{ end }} {{- /* END: if hasKey $currHook "values" */ -}}

              {{- /*
                  ---------------------------------------------------------
                  Each custom hook's optional "bootstrapSecret" value
                  can be specified on helmfile invocation like:
                    "--state-values-set hooks.custom.[hookname].bootstrapSecret=x"
                  Note that "x" will be passed for 'tpl' parsing so it can
                  reference another variable in the $helmfileVarsDict
                  ---------------------------------------------------------
              */}}
              bootstrapSecret:
                k8Secret:
                  {{- if ($stateVals | getOrNil "hooks.custom") }}
                    {{- $stateValsCurrHook := $stateVals.hooks.custom | getOrNil $currHookName }}
                    {{ if $stateValsCurrHook }}
                      {{ if contains ".helmfile" $stateValsCurrHook.bootstrapSecret }}
                  secretValue: {{ tpl $stateValsCurrHook.bootstrapSecret $helmfileVarsDict }}
                      {{ else }}
                  secretValue: {{ $stateValsCurrHook.bootstrapSecret }}
                      {{ end }}
                    {{ else }}
                  secretValue: "NO_SECRET_VALUE1"
                    {{ end }}
                  {{ else }}
                  secretValue: "NO_SECRET_VALUE2"
                  {{ end }}

            {{ end }} {{- /* END: range $currHookName,$currHook := ..... */ -}}
          {{ end }} {{- /* END: if hasKey $chartConfigs.appdeploy.chartValues.values.hooks "custom"... */ -}}
        {{ end }} {{- /* END: if hasKey $chartConfigs.appdeploy.chartValues.values "hooks" */ -}}

  {{ end }}   {{- /* END: range $currService := $currContext.services */ -}}
  {{ end }}   {{- /* END: if not has $currService.version $versionsReleased */ -}}
  {{ end }}   {{- /* END: range $currContextName,$currContext := $currEnvironment.contexts */ -}}
  {{ end }}   {{- /* END: range $currEnvironmentName,$currEnvironment := $envVals.environments */ -}}