#!/bin/bash

# Copyright 2014 The Kubernetes Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# TODO(jbeda): Provide a way to override project
# gcloud multiplexing for shared GCE/GKE tests.
setglobal KUBE_ROOT = "$[dirname $(BASH_SOURCE)]/../.."
source "$(KUBE_ROOT)/cluster/gce/config-common.sh"

# Specifying KUBE_GCE_API_ENDPOINT will override the default GCE Compute API endpoint (https://www.googleapis.com/compute/v1/).
# This endpoint has to be pointing to v1 api. For example, https://www.googleapis.com/compute/staging_v1/
setglobal GCE_API_ENDPOINT = $(KUBE_GCE_API_ENDPOINT:-)
setglobal GCLOUD = 'gcloud'
setglobal ZONE = $(KUBE_GCE_ZONE:-us-central1-b)
setglobal REGION = $(ZONE%-*)
setglobal RELEASE_REGION_FALLBACK = $(RELEASE_REGION_FALLBACK:-false)
setglobal REGIONAL_KUBE_ADDONS = $(REGIONAL_KUBE_ADDONS:-true)
setglobal NODE_SIZE = $(NODE_SIZE:-n1-standard-2)
setglobal NUM_NODES = $(NUM_NODES:-3)
setglobal MASTER_SIZE = $(MASTER_SIZE:-n1-standard-$(get-master-size))
setglobal MASTER_DISK_TYPE = 'pd-ssd'
setglobal MASTER_DISK_SIZE = $(MASTER_DISK_SIZE:-$(get-master-disk-size))
setglobal MASTER_ROOT_DISK_SIZE = $(MASTER_ROOT_DISK_SIZE:-$(get-master-root-disk-size))
setglobal NODE_DISK_TYPE = $(NODE_DISK_TYPE:-pd-standard)
setglobal NODE_DISK_SIZE = $(NODE_DISK_SIZE:-100GB)
setglobal NODE_LOCAL_SSDS = $(NODE_LOCAL_SSDS:-0)
setglobal NODE_ACCELERATORS = $(NODE_ACCELERATORS:-"")
setglobal REGISTER_MASTER_KUBELET = $(REGISTER_MASTER:-true)
setglobal KUBE_APISERVER_REQUEST_TIMEOUT = '300'
setglobal PREEMPTIBLE_NODE = $(PREEMPTIBLE_NODE:-false)
setglobal PREEMPTIBLE_MASTER = $(PREEMPTIBLE_MASTER:-false)
setglobal KUBE_DELETE_NODES = $(KUBE_DELETE_NODES:-true)
setglobal KUBE_DELETE_NETWORK = $(KUBE_DELETE_NETWORK:-true)
setglobal CREATE_CUSTOM_NETWORK = $(CREATE_CUSTOM_NETWORK:-false)

setglobal MASTER_OS_DISTRIBUTION = $(KUBE_MASTER_OS_DISTRIBUTION:-${KUBE_OS_DISTRIBUTION:-gci})
setglobal NODE_OS_DISTRIBUTION = $(KUBE_NODE_OS_DISTRIBUTION:-${KUBE_OS_DISTRIBUTION:-gci})
if [[ "${MASTER_OS_DISTRIBUTION}" == "coreos" ]] {
    setglobal MASTER_OS_DISTRIBUTION = '"container-linux'"
}
if [[ "${NODE_OS_DISTRIBUTION}" == "coreos" ]] {
    setglobal NODE_OS_DISTRIBUTION = '"container-linux'"
}

if [[ "${MASTER_OS_DISTRIBUTION}" == "cos" ]] {
    setglobal MASTER_OS_DISTRIBUTION = '"gci'"
}

if [[ "${NODE_OS_DISTRIBUTION}" == "cos" ]] {
    setglobal NODE_OS_DISTRIBUTION = '"gci'"
}

# GPUs supported in GCE do not have compatible drivers in Debian 7.
if [[ "${NODE_OS_DISTRIBUTION}" == "debian" ]] {
    setglobal NODE_ACCELERATORS = ''""
}

# By default a cluster will be started with the master and nodes
# on Container-optimized OS (cos, previously known as gci). If
# you are updating the os image versions, update this variable.
# Also please update corresponding image for node e2e at:
# https://github.com/kubernetes/kubernetes/blob/master/test/e2e_node/jenkins/image-config.yaml
setglobal CVM_VERSION = $(CVM_VERSION:-container-vm-v20170627)
setglobal GCI_VERSION = $(KUBE_GCI_VERSION:-cos-stable-60-9592-90-0)
setglobal MASTER_IMAGE = $(KUBE_GCE_MASTER_IMAGE:-)
setglobal MASTER_IMAGE_PROJECT = $(KUBE_GCE_MASTER_PROJECT:-cos-cloud)
setglobal NODE_IMAGE = $(KUBE_GCE_NODE_IMAGE:-${GCI_VERSION})
setglobal NODE_IMAGE_PROJECT = $(KUBE_GCE_NODE_PROJECT:-cos-cloud)
setglobal CONTAINER_RUNTIME = $(KUBE_CONTAINER_RUNTIME:-docker)
setglobal GCI_DOCKER_VERSION = $(KUBE_GCI_DOCKER_VERSION:-)
setglobal RKT_VERSION = $(KUBE_RKT_VERSION:-1.23.0)
setglobal RKT_STAGE1_IMAGE = $(KUBE_RKT_STAGE1_IMAGE:-coreos.com/rkt/stage1-coreos)

setglobal NETWORK = $(KUBE_GCE_NETWORK:-e2e-test-${USER})
if [[ "${CREATE_CUSTOM_NETWORK}" == true ]] {
  setglobal SUBNETWORK = $(SUBNETWORK:-${NETWORK}-custom-subnet)
}
setglobal INSTANCE_PREFIX = $(KUBE_GCE_INSTANCE_PREFIX:-e2e-test-${USER})
setglobal CLUSTER_NAME = $(CLUSTER_NAME:-${INSTANCE_PREFIX})
setglobal MASTER_NAME = ""$(INSTANCE_PREFIX)-master""
setglobal AGGREGATOR_MASTER_NAME = ""$(INSTANCE_PREFIX)-aggregator""
setglobal INITIAL_ETCD_CLUSTER = $(MASTER_NAME)
setglobal ETCD_QUORUM_READ = $(ENABLE_ETCD_QUORUM_READ:-false)
setglobal MASTER_TAG = ""$(INSTANCE_PREFIX)-master""
setglobal NODE_TAG = ""$(INSTANCE_PREFIX)-minion""

setglobal CLUSTER_IP_RANGE = $(CLUSTER_IP_RANGE:-$(get-cluster-ip-range))
setglobal MASTER_IP_RANGE = $(MASTER_IP_RANGE:-10.246.0.0/24)
# NODE_IP_RANGE is used when ENABLE_IP_ALIASES=true or CREATE_CUSTOM_NETWORK=true.
# It is the primary range in the subnet and is the range used for node instance IPs.
setglobal NODE_IP_RANGE = $[get-node-ip-range]

setglobal RUNTIME_CONFIG = $(KUBE_RUNTIME_CONFIG:-)

# Optional: set feature gates
setglobal FEATURE_GATES = $(KUBE_FEATURE_GATES:-ExperimentalCriticalPodAnnotation=true)

if [[ ! -z "${NODE_ACCELERATORS}" ]] {
    setglobal FEATURE_GATES = ""$(FEATURE_GATES),Accelerators=true""
}

setglobal TERMINATED_POD_GC_THRESHOLD = $(TERMINATED_POD_GC_THRESHOLD:-100)

# Extra docker options for nodes.
setglobal EXTRA_DOCKER_OPTS = $(EXTRA_DOCKER_OPTS:-)

# Enable the docker debug mode.
setglobal EXTRA_DOCKER_OPTS = ""$(EXTRA_DOCKER_OPTS) --debug""

setglobal SERVICE_CLUSTER_IP_RANGE = '"10.0.0.0/16'"  # formerly PORTAL_NET

# When set to true, Docker Cache is enabled by default as part of the cluster bring up.
setglobal ENABLE_DOCKER_REGISTRY_CACHE = 'true'

# Optional: Deploy a L7 loadbalancer controller to fulfill Ingress requests:
#   glbc           - CE L7 Load Balancer Controller
setglobal ENABLE_L7_LOADBALANCING = $(KUBE_ENABLE_L7_LOADBALANCING:-glbc)

# Optional: Cluster monitoring to setup as part of the cluster bring up:
#   none           - No cluster monitoring setup
#   influxdb       - Heapster, InfluxDB, and Grafana
#   google         - Heapster, Google Cloud Monitoring, and Google Cloud Logging
#   stackdriver    - Heapster, Google Cloud Monitoring (schema container), and Google Cloud Logging
#   googleinfluxdb - Enable influxdb and google (except GCM)
#   standalone     - Heapster only. Metrics available via Heapster REST API.
setglobal ENABLE_CLUSTER_MONITORING = $(KUBE_ENABLE_CLUSTER_MONITORING:-influxdb)

# Optional: Enable Metrics Server. Metrics Server should be enable everywhere,
# since it's a critical component, but in the first release we need a way to disable
# this in case of stability issues.
# TODO(piosz) remove this option once Metrics Server became a stable thing.
setglobal ENABLE_METRICS_SERVER = $(KUBE_ENABLE_METRICS_SERVER:-true)

# One special node out of NUM_NODES would be created of this type if specified.
# Useful for scheduling heapster in large clusters with nodes of small size.
setglobal HEAPSTER_MACHINE_TYPE = $(HEAPSTER_MACHINE_TYPE:-)

# Set etcd image (e.g. gcr.io/google_containers/etcd) and version (e.g. 3.1.10) if you need
# non-default version.
setglobal ETCD_IMAGE = $(TEST_ETCD_IMAGE:-)
setglobal ETCD_DOCKER_REPOSITORY = $(TEST_ETCD_DOCKER_REPOSITORY:-)
setglobal ETCD_VERSION = $(TEST_ETCD_VERSION:-)

# Default Log level for all components in test clusters and variables to override it in specific components.
setglobal TEST_CLUSTER_LOG_LEVEL = $(TEST_CLUSTER_LOG_LEVEL:---v=4)
setglobal KUBELET_TEST_LOG_LEVEL = $(KUBELET_TEST_LOG_LEVEL:-$TEST_CLUSTER_LOG_LEVEL)
setglobal DOCKER_TEST_LOG_LEVEL = $(DOCKER_TEST_LOG_LEVEL:---log-level=info)
setglobal API_SERVER_TEST_LOG_LEVEL = $(API_SERVER_TEST_LOG_LEVEL:-$TEST_CLUSTER_LOG_LEVEL)
setglobal CONTROLLER_MANAGER_TEST_LOG_LEVEL = $(CONTROLLER_MANAGER_TEST_LOG_LEVEL:-$TEST_CLUSTER_LOG_LEVEL)
setglobal SCHEDULER_TEST_LOG_LEVEL = $(SCHEDULER_TEST_LOG_LEVEL:-$TEST_CLUSTER_LOG_LEVEL)
setglobal KUBEPROXY_TEST_LOG_LEVEL = $(KUBEPROXY_TEST_LOG_LEVEL:-$TEST_CLUSTER_LOG_LEVEL)

# TODO: change this and flex e2e test when default flex volume install path is changed for GCI
# Set flex dir to one that's readable from controller-manager container and writable by the flex e2e test.
if [[ "${MASTER_OS_DISTRIBUTION}" == "gci" ]] {
    setglobal CONTROLLER_MANAGER_TEST_VOLUME_PLUGIN_DIR = '"--flex-volume-plugin-dir=/etc/srv/kubernetes/kubelet-plugins/volume/exec'"
}
# Set flex dir to one that's readable from kubelet and writable by the flex e2e test.
if [[ "${NODE_OS_DISTRIBUTION}" == "gci" ]] || shell {[[ "${MASTER_OS_DISTRIBUTION}" == "gci" ]] && [[ "${REGISTER_MASTER_KUBELET}" == "false" ]]} {
    setglobal KUBELET_TEST_VOLUME_PLUGIN_DIR = '"--volume-plugin-dir=/etc/srv/kubernetes/kubelet-plugins/volume/exec'"
}

setglobal TEST_CLUSTER_DELETE_COLLECTION_WORKERS = $(TEST_CLUSTER_DELETE_COLLECTION_WORKERS:---delete-collection-workers=1)
setglobal TEST_CLUSTER_MAX_REQUESTS_INFLIGHT = $(TEST_CLUSTER_MAX_REQUESTS_INFLIGHT:-)
setglobal TEST_CLUSTER_RESYNC_PERIOD = $(TEST_CLUSTER_RESYNC_PERIOD:---min-resync-period=3m)

# ContentType used by all components to communicate with apiserver.
setglobal TEST_CLUSTER_API_CONTENT_TYPE = $(TEST_CLUSTER_API_CONTENT_TYPE:-)

setglobal KUBELET_TEST_ARGS = ""$(KUBELET_TEST_ARGS:-) --max-pods=110 --serialize-image-pulls=false $(TEST_CLUSTER_API_CONTENT_TYPE) $(KUBELET_TEST_VOLUME_PLUGIN_DIR:-)""
if [[ "${NODE_OS_DISTRIBUTION}" == "gci" ]] || [[ "${NODE_OS_DISTRIBUTION}" == "ubuntu" ]] {
  setglobal NODE_KUBELET_TEST_ARGS = '" --experimental-kernel-memcg-notification=true'"
}
if [[ "${MASTER_OS_DISTRIBUTION}" == "gci" ]] || [[ "${MASTER_OS_DISTRIBUTION}" == "ubuntu" ]] {
  setglobal MASTER_KUBELET_TEST_ARGS = '" --experimental-kernel-memcg-notification=true'"
}
setglobal APISERVER_TEST_ARGS = ""$(APISERVER_TEST_ARGS:-) --runtime-config=extensions/v1beta1 $(TEST_CLUSTER_DELETE_COLLECTION_WORKERS) $(TEST_CLUSTER_MAX_REQUESTS_INFLIGHT)""
setglobal CONTROLLER_MANAGER_TEST_ARGS = ""$(CONTROLLER_MANAGER_TEST_ARGS:-) $(TEST_CLUSTER_RESYNC_PERIOD) $(TEST_CLUSTER_API_CONTENT_TYPE) $(CONTROLLER_MANAGER_TEST_VOLUME_PLUGIN_DIR:-)""
setglobal SCHEDULER_TEST_ARGS = ""$(SCHEDULER_TEST_ARGS:-) $(TEST_CLUSTER_API_CONTENT_TYPE)""
setglobal KUBEPROXY_TEST_ARGS = ""$(KUBEPROXY_TEST_ARGS:-) $(TEST_CLUSTER_API_CONTENT_TYPE)""

# Historically fluentd was a manifest pod and then was migrated to DaemonSet.
# To avoid situation during cluster upgrade when there are two instances
# of fluentd running on a node, kubelet need to mark node on which
# fluentd is not running as a manifest pod with appropriate label.
# TODO(piosz): remove this in 1.8
setglobal NODE_LABELS = $(KUBE_NODE_LABELS:-beta.kubernetes.io/fluentd-ds-ready=true)

# To avoid running Calico on a node that is not configured appropriately,
# label each Node so that the DaemonSet can run the Pods only on ready Nodes.
if [[ ${NETWORK_POLICY_PROVIDER:-} == "calico" ]] {
	setglobal NODE_LABELS = ""$NODE_LABELS,projectcalico.org/ds-ready=true""
}

# Apply the right node label if metadata proxy is on.
if [[ ${ENABLE_METADATA_PROXY:-} == "simple" ]] {
        setglobal NODE_LABELS = ""$(NODE_LABELS),beta.kubernetes.io/metadata-proxy-ready=true""
}

# Optional: Enable node logging.
setglobal ENABLE_NODE_LOGGING = $(KUBE_ENABLE_NODE_LOGGING:-true)
setglobal LOGGING_DESTINATION = $(KUBE_LOGGING_DESTINATION:-gcp) # options: elasticsearch, gcp

# Optional: When set to true, Elasticsearch and Kibana will be setup as part of the cluster bring up.
setglobal ENABLE_CLUSTER_LOGGING = $(KUBE_ENABLE_CLUSTER_LOGGING:-true)
setglobal ELASTICSEARCH_LOGGING_REPLICAS = '1'

# Optional: Don't require https for registries in our local RFC1918 network
if [[ ${KUBE_ENABLE_INSECURE_REGISTRY:-false} == "true" ]] {
  setglobal EXTRA_DOCKER_OPTS = ""$(EXTRA_DOCKER_OPTS) --insecure-registry 10.0.0.0/8""
}

# Optional: Install cluster DNS.
setglobal ENABLE_CLUSTER_DNS = $(KUBE_ENABLE_CLUSTER_DNS:-true)
setglobal DNS_SERVER_IP = '"10.0.0.10'"
setglobal DNS_DOMAIN = '"cluster.local'"

# Optional: Enable DNS horizontal autoscaler
setglobal ENABLE_DNS_HORIZONTAL_AUTOSCALER = $(KUBE_ENABLE_DNS_HORIZONTAL_AUTOSCALER:-true)

# Optional: Install cluster docker registry.
setglobal ENABLE_CLUSTER_REGISTRY = $(KUBE_ENABLE_CLUSTER_REGISTRY:-false)
setglobal CLUSTER_REGISTRY_DISK = $(CLUSTER_REGISTRY_DISK:-${INSTANCE_PREFIX}-kube-system-kube-registry)
setglobal CLUSTER_REGISTRY_DISK_SIZE = $(CLUSTER_REGISTRY_DISK_SIZE:-200GB)
setglobal CLUSTER_REGISTRY_DISK_TYPE_GCE = $(CLUSTER_REGISTRY_DISK_TYPE_GCE:-pd-standard)

# Optional: Install Kubernetes UI
setglobal ENABLE_CLUSTER_UI = $(KUBE_ENABLE_CLUSTER_UI:-true)

# Optional: Install node problem detector.
#   none           - Not run node problem detector.
#   daemonset      - Run node problem detector as daemonset.
#   standalone     - Run node problem detector as standalone system daemon.
if [[ "${NODE_OS_DISTRIBUTION}" == "gci" ]] {
  # Enable standalone mode by default for gci.
  setglobal ENABLE_NODE_PROBLEM_DETECTOR = $(KUBE_ENABLE_NODE_PROBLEM_DETECTOR:-standalone)
} else {
  setglobal ENABLE_NODE_PROBLEM_DETECTOR = $(KUBE_ENABLE_NODE_PROBLEM_DETECTOR:-daemonset)
}
setglobal NODE_PROBLEM_DETECTOR_VERSION = $(NODE_PROBLEM_DETECTOR_VERSION:-)
setglobal NODE_PROBLEM_DETECTOR_TAR_HASH = $(NODE_PROBLEM_DETECTOR_TAR_HASH:-)

# Optional: Create autoscaler for cluster's nodes.
setglobal ENABLE_CLUSTER_AUTOSCALER = $(KUBE_ENABLE_CLUSTER_AUTOSCALER:-false)
if [[ "${ENABLE_CLUSTER_AUTOSCALER}" == "true" ]] {
  setglobal AUTOSCALER_MIN_NODES = $(KUBE_AUTOSCALER_MIN_NODES:-)
  setglobal AUTOSCALER_MAX_NODES = $(KUBE_AUTOSCALER_MAX_NODES:-)
  setglobal AUTOSCALER_ENABLE_SCALE_DOWN = $(KUBE_AUTOSCALER_ENABLE_SCALE_DOWN:-false)
  setglobal AUTOSCALER_EXPANDER_CONFIG = $(KUBE_AUTOSCALER_EXPANDER_CONFIG:---expander=price)
}

# Optional: Enable Rescheduler
setglobal ENABLE_RESCHEDULER = $(KUBE_ENABLE_RESCHEDULER:-true)

# Optional: Enable allocation of pod IPs using IP aliases.
#
# BETA FEATURE.
#
# IP_ALIAS_SIZE is the size of the podCIDR allocated to a node.
# IP_ALIAS_SUBNETWORK is the subnetwork to allocate from. If empty, a
#   new subnetwork will be created for the cluster.
setglobal ENABLE_IP_ALIASES = $(KUBE_GCE_ENABLE_IP_ALIASES:-false)
if test $(ENABLE_IP_ALIASES) = true {
  # Size of ranges allocated to each node. gcloud current supports only /32 and /24.
  setglobal IP_ALIAS_SIZE = $(KUBE_GCE_IP_ALIAS_SIZE:-/24)
  setglobal IP_ALIAS_SUBNETWORK = $(KUBE_GCE_IP_ALIAS_SUBNETWORK:-${INSTANCE_PREFIX}-subnet-default)
  # Reserve the services IP space to avoid being allocated for other GCP resources.
  setglobal SERVICE_CLUSTER_IP_SUBNETWORK = $(KUBE_GCE_SERVICE_CLUSTER_IP_SUBNETWORK:-${INSTANCE_PREFIX}-subnet-services)
  # Add to the provider custom variables.
  setglobal PROVIDER_VARS = ""$(PROVIDER_VARS:-) ENABLE_IP_ALIASES""
}

# Enable GCE Alpha features.
if [[ -n "${GCE_ALPHA_FEATURES:-}" ]] {
  setglobal PROVIDER_VARS = ""$(PROVIDER_VARS:-) GCE_ALPHA_FEATURES""
}

# If we included ResourceQuota, we should keep it at the end of the list to prevent incrementing quota usage prematurely.
setglobal ADMISSION_CONTROL = $(KUBE_ADMISSION_CONTROL:-Initializers,NamespaceLifecycle,LimitRanger,ServiceAccount,PersistentVolumeLabel,PodPreset,DefaultStorageClass,DefaultTolerationSeconds,NodeRestriction,Priority,ResourceQuota)

# Optional: if set to true kube-up will automatically check for existing resources and clean them up.
setglobal KUBE_UP_AUTOMATIC_CLEANUP = $(KUBE_UP_AUTOMATIC_CLEANUP:-false)

# Optional: setting it to true denotes this is a testing cluster,
# so that we can use pulled kubernetes binaries, even if binaries
# are pre-installed in the image. Note that currently this logic
# is only supported in trusty or GCI.
setglobal TEST_CLUSTER = $(TEST_CLUSTER:-true)

# Storage backend. 'etcd2' and 'etcd3' are supported.
setglobal STORAGE_BACKEND = $(STORAGE_BACKEND:-)
# Storage media type: application/json and application/vnd.kubernetes.protobuf are supported.
setglobal STORAGE_MEDIA_TYPE = $(STORAGE_MEDIA_TYPE:-)

# OpenContrail networking plugin specific settings
setglobal NETWORK_PROVIDER = $(NETWORK_PROVIDER:-kubenet) # none, opencontrail, kubenet
setglobal OPENCONTRAIL_TAG = $(OPENCONTRAIL_TAG:-R2.20)
setglobal OPENCONTRAIL_KUBERNETES_TAG = $(OPENCONTRAIL_KUBERNETES_TAG:-master)
setglobal OPENCONTRAIL_PUBLIC_SUBNET = $(OPENCONTRAIL_PUBLIC_SUBNET:-10.1.0.0/16)

# Network Policy plugin specific settings.
setglobal NETWORK_POLICY_PROVIDER = $(NETWORK_POLICY_PROVIDER:-none) # calico

# How should the kubelet configure hairpin mode?
setglobal HAIRPIN_MODE = $(HAIRPIN_MODE:-promiscuous-bridge) # promiscuous-bridge, hairpin-veth, none

# Optional: if set to true, kube-up will configure the cluster to run e2e tests.
setglobal E2E_STORAGE_TEST_ENVIRONMENT = $(KUBE_E2E_STORAGE_TEST_ENVIRONMENT:-false)

# Optional: if set to true, a image puller is deployed. Only for use in e2e clusters.
# TODO: Pipe this through GKE e2e clusters once we know it helps.
setglobal PREPULL_E2E_IMAGES = $(PREPULL_E2E_IMAGES:-true)

# Evict pods whenever compute resource availability on the nodes gets below a threshold.
setglobal EVICTION_HARD = $(EVICTION_HARD:-memory.available<250Mi,nodefs.available<10%,nodefs.inodesFree<5%)

# Optional: custom scheduling algorithm
setglobal SCHEDULING_ALGORITHM_PROVIDER = $(SCHEDULING_ALGORITHM_PROVIDER:-)

# Optional: install a default StorageClass
setglobal ENABLE_DEFAULT_STORAGE_CLASS = $(ENABLE_DEFAULT_STORAGE_CLASS:-true)

# Optional: Enable legacy ABAC policy that makes all service accounts superusers.
# Disabling this by default in tests ensures default RBAC policies are sufficient from 1.6+
# Upgrade test jobs that go from a version < 1.6 to a version >= 1.6 should override this to be true.
setglobal ENABLE_LEGACY_ABAC = $(ENABLE_LEGACY_ABAC:-false) # true, false

# TODO(dawn1107): Remove this once the flag is built into CVM image.
# Kernel panic upon soft lockup issue
setglobal SOFTLOCKUP_PANIC = $(SOFTLOCKUP_PANIC:-true) # true, false

# Enable a simple "AdvancedAuditing" setup for testing.
setglobal ENABLE_APISERVER_ADVANCED_AUDIT = $(ENABLE_APISERVER_ADVANCED_AUDIT:-true) # true, false

if [[ "${ENABLE_APISERVER_BASIC_AUDIT:-}" == "true" ]] {
  echo "Warning: Basic audit logging is deprecated and will be removed. Please use advanced auditing instead."
}

setglobal ENABLE_BIG_CLUSTER_SUBNETS = $(ENABLE_BIG_CLUSTER_SUBNETS:-false)

if [[ -n "${LOGROTATE_FILES_MAX_COUNT:-}" ]] {
  setglobal PROVIDER_VARS = ""$(PROVIDER_VARS:-) LOGROTATE_FILES_MAX_COUNT""
}
if [[ -n "${LOGROTATE_MAX_SIZE:-}" ]] {
  setglobal PROVIDER_VARS = ""$(PROVIDER_VARS:-) LOGROTATE_MAX_SIZE""
}

# Fluentd requirements
setglobal FLUENTD_GCP_MEMORY_LIMIT = $(FLUENTD_GCP_MEMORY_LIMIT:-300Mi)
setglobal FLUENTD_GCP_CPU_REQUEST = $(FLUENTD_GCP_CPU_REQUEST:-100m)
setglobal FLUENTD_GCP_MEMORY_REQUEST = $(FLUENTD_GCP_MEMORY_REQUEST:-200Mi)

# Heapster requirements
setglobal HEAPSTER_GCP_BASE_MEMORY = $(HEAPSTER_GCP_BASE_MEMORY:-140Mi)
setglobal HEAPSTER_GCP_MEMORY_PER_NODE = $(HEAPSTER_GCP_MEMORY_PER_NODE:-4)
setglobal HEAPSTER_GCP_BASE_CPU = $(HEAPSTER_GCP_BASE_CPU:-80m)
setglobal HEAPSTER_GCP_CPU_PER_NODE = $(HEAPSTER_GCP_CPU_PER_NODE:-0.5)

# Adding to PROVIDER_VARS, since this is GCP-specific.
setglobal PROVIDER_VARS = ""$(PROVIDER_VARS:-) FLUENTD_GCP_MEMORY_LIMIT FLUENTD_GCP_CPU_REQUEST FLUENTD_GCP_MEMORY_REQUEST HEAPSTER_GCP_BASE_MEMORY HEAPSTER_GCP_MEMORY_PER_NODE HEAPSTER_GCP_BASE_CPU HEAPSTER_GCP_CPU_PER_NODE""

# prometheus-to-sd configuration
setglobal PROMETHEUS_TO_SD_ENDPOINT = $(PROMETHEUS_TO_SD_ENDPOINT:-https://monitoring.googleapis.com/)
setglobal PROMETHEUS_TO_SD_PREFIX = $(PROMETHEUS_TO_SD_PREFIX:-custom.googleapis.com)
setglobal ENABLE_PROMETHEUS_TO_SD = $(ENABLE_PROMETHEUS_TO_SD:-true)

# TODO(#51292): Make kube-proxy Daemonset default and remove the configuration here.
# Optional: [Experiment Only] Run kube-proxy as a DaemonSet if set to true, run as static pods otherwise.
setglobal KUBE_PROXY_DAEMONSET = $(KUBE_PROXY_DAEMONSET:-false) # true, false

# Optional: duration of cluster signed certificates.
setglobal CLUSTER_SIGNING_DURATION = $(CLUSTER_SIGNING_DURATION:-)

# Optional: enable pod priority
setglobal ENABLE_POD_PRIORITY = $(ENABLE_POD_PRIORITY:-)
if [[ "${ENABLE_POD_PRIORITY}" == "true" ]] {
    setglobal FEATURE_GATES = ""$(FEATURE_GATES),PodPriority=true""
}

# Optional: enable certificate rotation of the kubelet certificates.
setglobal ROTATE_CERTIFICATES = $(ROTATE_CERTIFICATES:-)

# The number of services that are allowed to sync concurrently. Will be passed
# into kube-controller-manager via `--concurrent-service-syncs`
setglobal CONCURRENT_SERVICE_SYNCS = $(CONCURRENT_SERVICE_SYNCS:-)