mkDeployment

-- Prelude
   let Prelude = ../../Prelude.dhall
in let map  = Prelude.`List`.map
in let kv   = Prelude.JSON.keyText

-- Kubernetes types and defaults
in let Types   = ./RawTypes
in let default = ./RawDefaults

-- Types for dynamic records
in let KV     = { mapKey : Text, mapValue : Text }
in let ListKV = List KV


in let mkProbe : ./Probe → Optional Types.Probe =

  λ(probe : ./Probe) →

  Some
    (default.probe //
      { initialDelaySeconds = Some probe.initial
      , periodSeconds = Some probe.period
      , httpGet = Some
        (default.httpGet
            { port = default.Int probe.port } //
            { path = Some probe.path
            })
      })


in let mkEnvVar : KV → Types.EnvVar =

  λ(var : KV) →

  default.envVar
    { name  = var.mapKey } //
    { value = Some var.mapValue }


in let mkEmptyVolume : { name : Text } → Types.Volume =

  λ(vol : { name : Text }) →

  default.volume
    { name = vol.name } //
    { emptyDir = Some default.emptyVolume }


in let mkSecretVolume : { name : Text } → Types.Volume =

  λ(vol : { name : Text }) →

  default.volume
    { name = vol.name } //
    { secret = Some
        (default.secretVolume // { secretName = Some vol.name } )
    }


in let mkPathVolume : { name : Text, path : Text } → Types.Volume =

  λ(vol : { name : Text, path : Text }) →

  default.volume
    { name = vol.name } //
    { hostPath = Some
        (default.pathVolume { path = vol.path })
    }


in let mkMount : ./Mount → Types.Mount =

  λ(mount : ./Mount) →

  default.mount
    { mountPath = mount.mountPath
    , name = mount.name
    } //
    { readOnly = mount.readOnly }


in let mkContainer : ./Container → Types.Container =

  λ(container : ./Container) →

  default.container
    { name = container.name } //
    { image = Some "${container.imageName}:${container.imageTag}"
    , imagePullPolicy = Some container.imagePullPolicy
    , ports = Optional/fold
        Natural
        container.port
        (Optional (List Types.ContainerPort))
        (λ(port : Natural) → Some
          [(default.containerPort { containerPort = port })])
        (None (List Types.ContainerPort))
    , resources = Some
      { limits   = Some [kv "cpu" "${Natural/show container.maxCPU}m"]
      , requests = Some [kv "cpu" "${Natural/show container.minCPU}m"]
      }
    , command = container.command
    , volumeMounts = Some
        (map ./Mount Types.Mount mkMount container.mounts)
    -- Poll the container to see if the it's alive or we should restart it
    , livenessProbe = Optional/fold
        ./Probe
        container.livenessProbe
        (Optional Types.Probe)
        mkProbe
        (None Types.Probe)
    -- Poll the container to see that it's ready for requests
    , readinessProbe = Optional/fold
        ./Probe
        container.readinessProbe
        (Optional Types.Probe)
        mkProbe
        (None Types.Probe)
    , env = Some
        (map { mapKey : Text , mapValue : Text } Types.EnvVar mkEnvVar container.envVars)
    }


in let mkDeployment : ./Deployment → Types.Deployment =

  λ(deployment : ./Deployment) →

     let selector = Some [kv "app" deployment.name]

  in let emptyVolumes = map { name : Text } Types.Volume mkEmptyVolume deployment.emptyVolumes
  in let secretVolumes = map { name : Text } Types.Volume mkSecretVolume deployment.secretVolumes
  in let pathVolumes = map { name : Text, path : Text } Types.Volume mkPathVolume deployment.pathVolumes
  in let volumes = Some (emptyVolumes # secretVolumes # pathVolumes)

  in let spec = default.spec
  { selector = default.selector // { matchLabels = selector }
  , template = default.template
    { metadata = default.meta
      { name = deployment.name } // { labels = selector }
    } //
    { spec = Some (default.podSpec
      { containers = map ./Container Types.Container mkContainer deployment.containers
      } //
      { volumes = volumes
      })
    }
  } //
  { replicas = Some deployment.replicas
  -- Don't keep all the ReplicaSets
  , revisionHistoryLimit = Some deployment.revisionHistoryLimit
  , strategy = Some
    -- Control the RollingUpdate so the app is always available. For more info see:
    -- https://kubernetes.io/docs/concepts/workloads/controllers/deployment/
    { type = Some "RollingUpdate"
    , rollingUpdate = Some
      { maxSurge       = Some (default.Int deployment.maxSurge)
      , maxUnavailable = Some (default.Int deployment.maxUnavailable)
      }
    }
  }

  in default.deployment
  { metadata = default.meta { name = deployment.name }
  } //
  { spec = Some spec
  }


in mkDeployment